Java 入门概念梳理之一

2019-06-15 00:00:00 概念 梳理 入门


Java入门学习

简介

public class HelloWorld {
    public static void main(String []args) {
        System.out.println("Hello World");
    }
}
//输出
    // javac将java源文件编译为class字节码文件
$ javac HelloWorld.java
    // java后边执行的是java文件的类名,如HelloWorld,注意不要家后缀
$ java HelloWorld
Hello World
  • Java分三个体系
    • JavaSE(J2SE/JavaEE)(Java2 Platform Standard Edition,java平台标准版)
    • JavaEE(J2EE/JavaEE)(Java 2 Platform,Enterprise Edition,java平台企业版)
    • JavaME(J2ME/JavaME)(Java 2 Platform Micro Edition,java平台微型版)。
  • 特性
    • 简单:和C近,丢弃操作符重载,多继承,自动的强制类型转换,不适用指针而是引用,自动GC
    • OOP: 提供类,接口和集成,只支持类间继承,支持接口之间多继承并支持类与接口之间的实现机制。
      全面支持动态绑定。纯OOP。
    • 分布式的:支持Internet应用开发,在基本Java应用编程接口中有java net
      ,提供了网络应用变成的类库,包括URL,URLConnection,Socket,ServerSocket等
    • 健壮的:强制型机制、异常处理、垃圾回收,丢弃指针。
    • 安全的:通过网络下载的类具有一个安全防范机制
    • 体系结构中立
    • 可移植的
    • 解释型的
    • 高性能的
    • 多线程的
    • 动态的


基础语法

java程序可认为一系列对象的集合

  • 对象: 类的一个实例,有状态和行为。
  • 类: 类的一个模板,描述一类对象的行为和状态。
  • 方法:行为
  • 实例变量:每个对象都有独特的实例变量,对象的状态由此决定

基本语法

  • 大小写敏感:Java是大小写敏感的,这就意味着标识符Hello与hello是不同的。
  • 类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。
  • 方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。
  • 源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记Java是大小写敏感的),文件名的后缀为.java。(如果文件名和类名不相同则会导致编译错误)。
  • 主方法入口:所有的Java 程序由public static void main(String []args)方法开始执行。

标识符:类名、变量名以及方法名都被称为标识符

修饰符:修饰类中方法和属性

  • 访问控制修饰符 : default, public , protected, private
  • 非访问控制修饰符 : final, abstract, strictfp

变量

  • 局部变量
  • 类变量(静态变量)
  • 成员变量(非静态变量)

数组:储存在堆上的对象,可以保存多个同类型变量

枚举: 枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

注释同JS

继承::::被继承的类称为超类(super class),派生类称为子类(subclass)。

接口:对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法,但是方法的具体实现完全取决于派生类。

《Java 入门概念梳理之一》


Java 对象和类

Java作为一种面向对象语言。支持以下基本概念:

  • 多态
  • 继承
  • 封装
  • 抽象
public class Dog{
  String breed;
  int age;
  String color;
  void barking(){
  }

  void hungry(){
  }

  void sleeping(){
  }
}
  • 对象
public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数:name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}
  • 实例

    public class Puppy{
    int puppyAge;
    public Puppy(String name){
      // 这个构造器仅有一个参数:name
      System.out.println("小狗的名字是 : " + name ); 
    }
    
    public void setAge( int age ){
       puppyAge = age;
    }
    
    public int getAge( ){
       System.out.println("小狗的年龄为 : " + puppyAge ); 
       return puppyAge;
    }
    
    public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPuppy.puppyAge ); 
    }
    }
  • 方法
public class Puppy{
    public Puppy(){
    }

    public Puppy(String name){
        // 这个构造器仅有一个参数:name
    }
}
  • 重载

Java packages:对类和接口进行分类。当开发Java程序时,可能编写成百上千的类,因此很有必要对类和接口进行分类。

Import 语句:提供一个合理的路径,使得编译器可以找到某个类。


基本数据类型

  • 内置数据类型(8种)
  • byte:
    • byte数据类型是8位、有符号的,以二进制补码表示的整数;
    • 最小值是-128(-2^7);
    • 最大值是127(2^7-1);
    • 默认值是0;
    • byte类型用在大型数组中节约空间,主要代替整数,因为byt- e变量占用的空间只有int类型的四分之一;
    • 例子:byte a = 100,byte b = -50。
  • short:
    • short数据类型是16位、有符号的以二进制补码表示的整数
    • 最小值是-32768(-2^15);
    • 最大值是32767(2^15 – 1);
    • Short数据类型也可以像byte那样节省空间。一个short变量- 是int型变量所占空间的二分之一;
    • 默认值是0;
    • 例子:short s = 1000,short r = -20000。
  • int:
    • int数据类型是32位、有符号的以二进制补码表示的整数;
    • 最小值是-2,147,483,648(-2^31);
    • 最大值是2,147,483,647(2^31 – 1);
    • 一般地整型变量默认为int类型;
    • 默认值是0;
    • 例子:int a = 100000, int b = -200000。
  • long:
    • long数据类型是64位、有符号的以二进制补码表示的整数;
    • 最小值是-9,223,372,036,854,775,808(-2^63);
    • 最大值是9,223,372,036,854,775,807(2^63 -1);
    • 这种类型主要使用在需要比较大整数的系统上;
    • 默认值是0L;
    • 例子: long a = 100000L,Long b = -200000L。
  • float:
    • float数据类型是单精度、32位、符合IEEE 754标准的浮点数;
    • float在储存大型浮点数组的时候可节省内存空间;
    • 默认值是0.0f;
    • 浮点数不能用来表示精确的值,如货币;
    • 例子:float f1 = 234.5f。
  • double:
    • double数据类型是双精度、64位、符合IEEE 754标准的浮点数;
    • 浮点数的默认类型为double类型;
    • double类型同样不能表示精确的值,如货币;
    • 默认值是0.0d;
    • 例子:double d1 = 123.4。
  • boolean:
    • boolean数据类型表示一位的信息;
    • 只有两个取值:true和false;
    • 这种类型只作为一种标志来记录true/false情况;
    • 默认值是false;
    • 例子:boolean one = true。
  • char:

    • char类型是一个单一的16位Unicode字符;
    • 最小值是’\u0000’(即为0);
    • 最大值是’\uffff’(即为65,535);
    • char数据类型可以储存任何字符;
    • 例子:char letter = ‘A’。
  • 引用数据类型
    • 在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量 声明时被指定为一个特定的类型,比如Employee、Pubby等。变量一旦声明后,类型就不能被改变了。
    • 对象、数组都是引用数据类型。
    • 所有引用类型的默认值都是null。
    • 一个引用变量可以用来引用与任何与之兼容的类型。
    • 例子:Site site = new Site(“Runoob”)。
  • Java常量
  • 自动类型转换:整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。
  • 强制类型转换:

    1. 条件是转换的数据类型必须是兼容的。
    2. 格式:(type)value type是要强制类型转换后的数据类型 实例:

      public class QiangZhiZhuanHuan{
      public static void main(String[] args){
          int i1 = 123;
          byte b = (byte)i1;//强制类型转换为byte
          System.out.println("int强制类型转换为byte后的值等于"+b);
      
      }
      }
  • 隐含强制类型转换
    1. 整数的默认类型是 int。
    2. 浮点型不存在这种情况,因为在定义 float 类型时必须在数字后面跟上 F 或者 f


Java变量类型

在Java语言中,所有的变量在使用前必须声明。声明变量的基本格式如下:
type identifier [ = value][, identifier [= value] ...] ;
Java语言支持的变量类型有:

  • 局部变量
    局部变量声明在方法、构造方法或者语句块中;
    局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
    访问修饰符不能用于局部变量;
    局部变量只在声明它的方法、构造方法或者语句块中可见;
    局部变量是在栈上分配的。
    局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。
  • 成员变量
    实例变量声明在一个类中,但在方法、构造方法和语句块之外;
    当一个对象被实例化之后,每个实例变量的值就跟着确定;
    实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
    实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
    实例变量可以声明在使用前或者使用后;
    访问修饰符可以修饰实例变量;
    实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
    实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
    实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。
  • 类变量
    类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。
    无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
    静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
    静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
    静态变量在程序开始时创建,在程序结束时销毁。
    与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
    默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
    静态变量可以通过:ClassName.VariableName的方式访问。
    类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。


Java修饰符

修饰符用来定义类、方法或者变量,通常放在语句的最前端

public class className {
// ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
// 方法体
}
  • 访问修饰符
修饰符当前类同一包内子孙类其他包
publicYYYY
protectedYYYN
defaultYYNN
privateYNNN
  • 非访问修饰符
    • static 修饰符,用来创建类方法和类变量。
      • 静态变量:
        static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
      • 静态方法:
        static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。
    • final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。
      • final 变量:
        final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变,但是里面的值可以改变。
        final 修饰符通常和 static 修饰符一起使用来创建类常量。
      • final 方法
        类中的 final 方法可以被子类继承,但是不能被子类修改。
        声明 final 方法的主要目的是防止该方法的内容被修改。
      • }
        final 类
        final 类不能被继承,没有类能够继承 final 类的任何特性。
    • abstract 修饰符,用来创建抽象类和抽象方法
      • 抽象类:
        抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。
        一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。
      • 抽象方法
        抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。
        抽象方法不能被声明成 final 和 static。
        任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
        如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
        抽象方法的声明以分号结尾,例如:public abstract sample();。
    • synchronized 和 volatile 修饰符,主要用于线程的编程。
      • transient 修饰符
      • volatile 修饰符
        volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
        一个 volatile 对象引用可能是 null。 Java运算符
  • 算术运算符
  • 关系运算符
  • 位运算符
  • 逻辑运算符
  • 赋值运算符
  • 其他运算符 Java循环结构
  • while 循环
  • do…while 循环
  • for 循环
    • Java 增强 for 循环
      “`for(声明语句 : 表达式)
      {
      //代码句子
      }
  • break 关键字
  • continue 关键字 Java分支结构
  • if 语句
  • switch 语句 Java Number&Math类

    《Java 入门概念梳理之一》

    所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。

    Math类同JS


    Java Character类

    Character 类用于对单个字符进行操作。Character 类在对象中包装一个基本类型 char 的值

    
    char ch = 'a';

// Unicode 字符表示形式
char uniChar = ‘\u039A’;

// 字符数组
char[] charArray ={ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ };

## Java String类
## Java StringBuffer类
> 当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。
  和 String 类不同的是,StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新的未使用对象。

## Java Array
### 声明数组变量

dataType[] arrayRefVar; // 首选的方法
dataType arrayRefVar[]; // 效果相同,但不是首选方法

public class TestArray {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println(“总和为: ” + total);
}
}

## Java Date(same as JS)
## Java RegExp(same as JS)
## Java Method

System.out.println(),那么它是什么呢?
println() 是一个方法。
System 是系统类。
out 是标准输出对象。
这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
/* 返回两个整型变量数据的较大值 /
public static int max(int num1, int num2) {
int result;
if (num1 > num2)
result = num1;
else
result = num2;

return result;
}
//调用
int larger = max(30, 40);

- void关键字
>一个void方法的调用一定是一个语句。 所以,它被在main方法第三行以语句形式调用。就像任何以分号结束的语句一样。
- 通过值传递参数:调用一个方法时候需要提供参数,你必须按照参数列表指定的顺序提供。
- 重载(JS没有重载但可以模拟):一个类的两个方法拥有相同的名字,但是有不同的参数列表
Java编译器根据方法签名判断哪个方法应该被调用。

public static double max(double num1, double num2) {
if (num1 > num2)
return num1;
else
return num2;
}

- 变量作用域:程序中变量可以被引用的部分。
>方法的参数范围覆盖整个方法,参数即局部变量,for循环内生命的变量范围从其生命到循环体结束,这点与JS不同
- 命令行参数的使用。
>有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
 命令行参数是在执行程序时候紧跟在程序名字后面的信息。
- 构造方法::::当一个对象被创建时,构造方法用来初始化该对象,构造方法和它所在类的名字相同,
但没有返回值。

// 一个简单的构造函数
class MyClass {
int x;

// 以下是构造函数
MyClass(int i ) {
x = i;
}
}
//你可以像下面这样调用构造方法来初始化一个对象:
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + ” ” + t2.x);
}
}

- finalize方法:在对象被回收前调用,用于清除回收对象。

//你必须指定在对象销毁时候要执行的操作,finalize() 一般格式是:
protected void finalize()
{
// 在这里终结代码
}
public class FinalizationDemo {
public static void main(String[] args) {
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);

c2 = c3 = null;  
System.gc(); //调用Java垃圾收集器

}
}

class Cake extends Object {
private int id;
public Cake(int id) {
this.id = id;
System.out.println(“Cake Object ” + id + “is created”);
}

protected void finalize() throws java.lang.Throwable {
super.finalize();
System.out.println(“Cake Object ” + id + “is disposed”);
}
}

## Java Stream,FIle , IO
>Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
 Java.io 包中的流支持很多种格式,比如:基本类型、对象、本地化字符集等等。
 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据,输出流表示向一个目标写数据。
 Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中。

//读取控制台输入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//从控制台读取多字符输入
int read( ) throws IOException

- 文件读写
![http://www.runoob.com/wp-content/uploads/2013/12/12-130Q122402I57.jpg][http://www.runoob.com/wp-content/uploads/2013/12/12-130Q122402I57.jpg]

## Java Scanner类:获取用户的输入

import java.util.Scanner;

public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println(“next:”);
if(scan.hasNext()){
String str1 = scan.next();
System.out.println(“input :”+str1);
}
}
}



## Java unExpect
>异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的
常见三种异常
- 检查型异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,
    一个异常就发生了,这些异常在编译时不能被简单地忽略。
- 运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
- 错误:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,
    一个错误就发生了,它们在编译也检查不到的。
### Exception类的层次
异常类有两个主要的子类:IOException 类和 RuntimeException 类。

---------------------

相关文章