Java复习纲要（一）

该博客仅为自己复习语法总结归纳，不适合没有语法基础的初学者阅读。

Java基础语法

字符集

1. 程序是一个字符序列，字符序列的所有可用字符构成了“字符集”，字符集之外的字符若出现在程序中就是“错别字”，会产生编译错误。字符集的每一字符都有唯一的二进制编码。
2. C/C++采用ASCII码作为字符集，ASCII码占用1字节，使用低7位编码，最高位置0，可表示2的7次方个字符，包括英文大小写和标点符号、数字、常用算符等
3. Java使用2字节Unicode码作为其字符集，可表达2的16次方个编码。

注：对同样的字符，如’a’，在C/C++中占一个字节，而在java中要占两个字节。

Java为何采用与C/C++不同的字符集呢？

因为采用双字节编码Unicode字符集中已包含各国文字。这样无论使用哪种语言，进行信息交互时均可采用Unicode编码。这为网络环境下的信息自由交互奠定了基础。Java设计之初是面向网络环境，当然要采用Unicode编码。

标识符

1. 给类，方法，变量等起名字的符号

2. 由数字，字母，下划线和货币符等字符组成，数量不限

3. 不能以数字开头

4. 不能是关键字

5. 区分大小写

6. 常见命名规定：

   1. 小驼峰命名法：如name，firstName（针对方法，变量）

   2. 大驼峰命名法：如Student，GoodStudent（针对类）

关键字

1. 关键字又称保留字，在编辑器中有唯一的解释，关键字的字母全部小写，常用编辑器针对关键字有特殊的颜色标记
2. 不要把系统类Object，Thread，Class当做保留字
3. null，true，false既不是标识符，更不是保留字

数据类型

1. 基本数据类型
   1. 数值型
      • 整数（byte，short，int，long）
      • 浮点数（float，double）
      • 字符（char）
   2. 非数值型：布尔（boolean）
2. 引用数据类型
   1. 类（class）
   2. 接口（interface）
   3. 数组([])

数组使用

1. 数据变量的声明：数组元素类型[ ] 数组名; 或 数组元素类型 数组名[ ]（更推荐使用第一种）

   int[] a;
   int[][] c;
   int b[];
   

2. 数组对象的创建：变量名 = new 数组元素类型[n]; 或 数组类型 数组引用名 = {数组元素值1，数组元素值2，…}；

   int[] x = new int[n];//其中n表示可容纳的数组元素个数
   //注：数组元素若未赋值，均有默认值，其中数值型为0，布尔型为false，引用类型为null
   
   int[] y={
          1,2,3};//第二种方式只能在数组声明时使用
   int[][] z={
          {
          1,2},{
          1,2,3,4},{
          1,2,3}};
   //z.length为3
   
   int[][] a=new int[3][];//正确
   int[][] b=new int[][3];//错误
   

3. 对二维数组进行遍历

   for(int i=0;i<z.length;i++){
          
     for(int j=0;j<z[i].length;j++)
       System.out.print(" " + z[i][j] + " ");
     System.out.println();
   }
   

字符串

1. 字符串String属于class这一大类

2. 创建字符串对象：String 变量名 = 字符串常量；或 String 变量名 = new String(字符串值)；

   String s1 = "abc";//在常量池创建字符串
   String s2 = new String("abc");//在非常量池创建字符串对象
   

3. 相等判断:

   1. ==：判断两字符串引用是否指向同一对象
   2. equals()：用于判断字符串对象中存储的内容是否一样
   3. 如上面创建的字符串：s1==s2为假，因为s1指向的常量池的对象，与s2指向对象不同，s1.equals(s2)为真，因为他们的值都为"abc"。

4. null和空串("")不同：null表示不指向任何字符串对象；""表示某个字符串对象，该对象中未存储任何字符

5. "A"和’A’是截然不同的两个数据，前面是引用型字面量，后者是基本型字面量。

6. 字符数组和字符串不同，字符数组也没有诸如C语言的’\0’结束标志

   char[] a={
          'a','b','c','d'};//字符数组
   String b="abcd";//字符串
   for(int i=0;i<b.length;i++)
     System.out.print(b.charAt(i));
   //输出abcd
   

7. 在Java中，String对象是只读的，即String的内容从不改变，String s=“abc”; s=s+“123”;并不是将字符串对象的值从"abc"改为"abc123"，而是自动创建了一个新的String对象，值为"abc123"，然后更改s的值，令其指向新对象的地址。

输入语句

1. Java的输入语句要先导入：import java.util.Scanner;

2. 再创建Scanner对象，通过对象提供的读取数据方法来读取数据

   import java.util.Scanner;
   class App{
          
     public static void main(String[] args){
          
       int data;
       Scanner sc = new Scanner(System.in);
       data = sc.nextXxx();
       char c = sc.next().charAt(0);//读取字符串的第一个字母
       
       //Xxx表示除char类型之外的其他7种基本类型，nextInt()、nextDouble()可分别读取int，double类型的数据，nextLine()读取一行字符串，以回车结束，字符串中不包括回车符
       //sc.hasNextXxx()用于判断是否还有Xxx型数据等待读取
     }
   }
   

面向对象语言基础

类的定义

1. 类的基本定义形式：class 类名{定义成员，方法}
2. 类中的内容统称为成员，成员包括成员变量，成员常量，成员方法
3. 成员常量不使用默认值，只能在声明时初始化，或者在构造函数中初始化，否则会编译报错
4. 一般类名的首字母大写，成员的首字母小写

class Pet{
     
	String name;//成员变量
	final int age=3;//成员常量
	void showMe(){
     //成员方法
		System.out.print("Hi，I'm " + name);
	}
}

class Species{
     }//类成员可以缺省，即空类
class LinkNode{
     
  Pet d;//成员变量类型可以是现有的类
  LinkNode next;//成员变量可以递归定义
}

构造函数

1. 与类同名，无返回值，且不能用void修饰
2. 若类中未定义构造函数，则系统提供一个默认的构造函数，反之则不提供
3. 构造函数通过new指令调用，不能直接通过引用名调用

对象及其引用

1. 构建类的实例，必须调用类中的构造函数
2. 使用构造函数创建对象：new 构造函数名([参数列表])；
3. 对象内的所有成员变量都是有初始值的，要么使用相关类型的默认值，要么在构造函数中直接指定，而成员方法中的变量则不具备此特色，所以成员方法中的变量要自己手动赋初值

A a =new A();
//a就是引用变量，它指向了一个A对象，也可以说它引用了一个A对象。我们通过操纵这个a来操作A对象。 此时，变量a的值为它所引用对象的地址。

类的继承

1. Java采用的是单继承策略，一个子类只能继承一个超类，但一个超类可以派生出多个子类
2. 基本语法：class 子类名 extends 超类名{}
3. 若定义类时未用extends，则该类是java.lang.Object类的子类，Object类是所有类的共同祖先
4. 在构造子类的对象时，会自动调用超类的构造函数，调用次序与派生次序相同，即先调用Object，再调超类，最后调子类
5. 子类中定义的成员变量若与继承自超类的成员变量同名，则超类的成员变量将被隐藏

修饰

1. 常用修饰：权限修饰，static修饰（修饰成员），final修饰（修饰类或成员），abstract修饰（修饰类或方法）
2. 类的访问权限修饰：public或缺省
3. 成员的访问权限修饰：public、protected、缺省、private
4. 权限是对外的，不是对内的，被private修饰的成员除自身的成员外，外界无法访问对象的私有成员
5. final修饰：被修饰类不能派生出子类，被修饰变量称为常量，被修饰方法不能被重写
6. static修饰成员：静态方法不能直接使用类中的实例成员，但可以直接使用类中的静态成员；实例方法中可以直接使用类中的实例及静态成员

注：被final修饰的引用变量指向对象内部的变量值是可以改变的，但不能指向其他对象

final T t1 = new T(3);
T t2 = new T(5);
t1.a = 5;//正确
t1 = t2;//编译错

重载

1. 同名不同参：函数名相同，参数列表不同
2. 使用重载的目的旨在实现对象自身行为的一名多用，即同一个功能在不同环境下有不同的方法体，如：多吉.嗅（主人气味）{欢快、愉悦的反应}； 多吉.嗅（老虎气味）{警戒，充满敌意}；

重写

1. 同名同参同返回值，且要求子类的存取权限不得小于超类方法的存取权限
2. static修饰的方法不能重写是因为对象不存在

instanceof运算符用于判断"对象是否是某个引用型的实例"。

抽象类

1. 抽象方法不能有方法体
2. 抽象类无法创建对象即无法实例化（无论包不包含抽象方法）
3. 非抽象方法必须有方法体
4. {}表示无方法体，{；}表示有方法体
5. abstract不能修饰最终方法、静态方法或构造函数，这三类方法不能被重写

接口

1. 抽象类旨在建立抽象类与其派生类之间的契约，而接口则是在任意类之间建立契约
2. 一个类可实现多个接口，每个接口只能继承一个接口
3. 接口是一组常量和抽象方法的集合
   • public static final 类型 成员常量 = 常量值；
   • public abstract 返回类型 成员方法名([参数列表])；
4. 接口用interface定义，类用class定义