6.1 命名规则#

1
标识符可以包含字母，数字，_，$，但是不能以数字开头，不能包含空格；

6.2 命名习惯#

7.1 整型#

Java 各整数类型有==固定的==表数范围和字段长度，不受具体操作系统的影响，以保证 Java 程序的可移植性。

定义 long 类型的变量，赋值时需要以”l”或”L”作为后缀。

开发过程中，整型变量通常声明为 int 型。

整型常量默认为 int。

7.2 浮点型#

浮点型有==固定的==表数范围和字段长度，不受具体操作系统的影响。

定义 float 类型的变量，赋值时需要以”f”或”F”作为后缀。

float、double 的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用 BigDecimal 类。

浮点型常量默认为 double。

7.3 字符型#

char 占 2 个字节。值用单引号括起来，例子：char a = 'a';、char b = '中';。

char 类型用的是 Unicode 字符集，每个字符对应一个 Unicode 数值（没有涉及具体的编码方式，UTF-8 是一种可变长度编码方式，可以根据字符的不同使用1至4个字节进行编码。），把这个数值强转为 char 类型即可显示这个字符。

char 类型能被赋值 int 类型常量。

1
final int b1= 23320; //少了final，就会过不了编译
2
char a = b1;  //或直接是char a = 23320;
3
System.out.println(a);  //能打印字符

7.4 布尔型#

boolean 类型数据只有两个值：true、false，无其它

不可以使用 0 或非 0 的整数替代 false 和 true，这点和 C 语言不同，布尔型不能和其他基本数据类型做运算。

8.1 自动类型转换#

byte ，short，char ==> int ==> long ==> float ==> double

表示范围小的可以转变为表示范围大的，不是看占用存储空间大小。float 能表示的数比 long 还大。

注：只要有 char、byte 、short 参与的运算的结果都是 int。

1
byte a = 10;
2
byte b = a + 12;
3
//会报错，算式里的整数常量 12 默认是 int ，需要用 int 变量接收
4
//浮点数同理，而浮点数常量默认为 double。
5

6
System.out.println('A' + 1); //char 与 int 运算，结果为int，即 66。
7
System.out.println('A'== 65); //“==”也是运算，涉及自动类型转换，结果为 true。
8

9
int a = 'c'; //这里也涉及自动转型
10
System.out.println(a); //99

8.2 强制类型转换#

和 C 语言类似，但 String 类型不能通过强制类型转换为基本数据类型，因为 String 不是基本数据类型。

强转改变了字节数，可能导致数值变化。

1
int b = 10;
2
byte a = (byte)b;

9.1 字符串#

String 和基本数据类型（包括布尔型）可以用“+”拼接。

1
String a = "abc";
2
System.out.println(a+1); //结果是abc1，类型为字符串
3
 System.out.println(a+true); //结果是abctrue

10.1 二进制#

以0b或0B开头。

1
 int a = 0b110;//或者0B110
2
 System.out.println(a); //输出为:6,以10进制输出

10.2 八进制（少用）#

以0开头。

1
 int b = 012;
2
 System.out.println(b); //输出为10，以10进制输出

10.3 十六进制#

以0x或0X开头，a-f不区分大小写。

1
 int a = 0x110;//或者0X110
2
 System.out.println(a); //输出为:272，以10进制输出

10.4 补码（符号位不参与运算）#

整型是以==二进制补码==形式存储的，并且最高位是符号位。

• 正数：最高位是 0。
• 负数：最高位是 1。

正数的补码、反码、原码一样，称为三码合一。

负数的补码、反码、原码不一样：

• 负数的原码：把十进制转为二进制，然后最高位设置为 1。

• 负数的反码：在原码的基础上，==最高位不变==，其余位取反（0 变 1,1 变0）。

• 负数的补码：反码加 1。

求补码最快的方法是：除符号位、==最后个 1 及以后的位==不变，其余位全取反。

补码的补码为原码。

补码转原码：最高位不变，其余位取反再加 1，因此也可以使用最快方法。

11.1 运算符的细微差异#

java 中的 % 是取余，商向 0 靠近，被除数 = 除数 * 商 + 余数。

1
System.out.print(-5%2); //本身商为 -2.5，但是向0取整则为 -2，余数为 -1
2
System.out.print(-5/2); //本身商为 -2.5，但是向0取整则为 -2，

python中 % 为取模，商向负无穷靠近。

1
print(5//2) #地板除，得 2.
2
print(5/2) #得2.5
3
print(-5%2) #本身商为 -2.5，但是向负无穷取整得 -3，取模为 1，-5 = 2*(-3) + 1

a+=2;与a= a+2;的细微差别，a+=2; int b =1000; a+=b;中 a 的类型不会改变，比如 a 的类型为 byte，则运算完也为 byte，只是把高位抛弃，只看地位对应哪个值， -=、*=、 /=、%= ++具有相同的性质。

1
short s1 = 10;
2
s1 += 2; //因为在得到 int 类型的结果后，JVM 自动会进行强制类型转换，将 int 类型强转成 short
3
s1++;

11.2 比较运算符#

1. 比较运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
2. > < >= <= ：只适用于基本数据类型（除 boolean 类型之外）。
3. == != ：适用于基本数据类型和引用数据类型。

11.3 逻辑运算符#

& 和 &&：表示“且”。

| 和 || ：表示“或”。

a&b和a&&b的区别在于 a 为 false 时，&仍会判断b，从而执行b中的表达式，比如age++；而&&会短路，不再判断 b。|和||同理，推荐使用&&和||。

^：表示“异或”。

!：表示“非”。

11.4 位运算符（运算用补码，看结果用原码）#

位运算涉及到了自动类型转换（byte、short 移位后会变为int，且机制复杂，可以不用掌握）。

a<<n：左移 n 位，低位补0。在一定范围内，相当于乘 2^n^（正负数都是）。

有可能会移成负数，即把数值的 1 移到符号位。

当左移的位数 n 超过该数据类型的总位数时，相当于左移（n % 总位数）位，比如 int 是模32，long是模 64（不考虑 byte、short 的情况）。

a>>n：右移 n 位，高位补==与符号位相同的值==。在一定范围内，相当于除 2^n^，然后向下取整（正负数都是）。

a>>>n：：右移 n 位，高位==补 0==。（正数、负数都适用）。

负数会变成正数。

a&b（与）、a|b（或）、~a（非）、a^b（异或）

11.5 条件运算符#

c = 条件表达式 ? A : B;表达式为true执行 c = A，表达式为false执行 c = B。

也可以结合输出，syetem.out.println(条件表达式 ? "我是A" : "我是B");

返回值的类型为两个返回值中精度更高的那个类型。

1
System.out.println(true ? 1 : 2.0); //自动类型提升，返回的是 1.0

16.1 一维数组#

16.1.3 一维数组内存存储#

1
public static void main(String[] args) {
2
   int[] arr = new int[3];
3
    System.out.println(arr); //打印的是哈希值，不是内存地址
4
}

只有在 new 数组对象时，才会在堆中分配。声明数组只会在栈中分配。

16.2 二维数组#

二维数组内存#

16.3 Arrays 工具类#

java.util.Arrays 类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

• 打印数组

Arrays.toString(arr)：打印数组所有元素，形式为：[元素1,元素2,元素3...]。

当 arr 是基本数据类型数组时，直接打印数值。

当 arr 是引用数据类型数组时，每个元素调用该引用类型的 toString()。没有重写 toString()，则打印哈希值。

二维数组的内层元素也是引用类型，调用其的 toString() 打印哈希值，若想把内层数组的值一起打印出来，需要用 Arrays.deepToString()。

1
int[] arr = {1,2,3,4,5};
2
System.out.println(Arrays.toString(arr));
3
//[1, 2, 3, 4, 5]
4

5
Person person1 = new Person();
6
Person person2 = new Person();
7
Person[] arr = new Person[]{person1,person2};
8
System.out.println(Arrays.toString(arr));
9
//[Person{name='lc', age=10}, Person{name='lc', age=10}]
10

11
int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
12
System.out.println(Arrays.deepToString(arr)); //[[3, 8, 2], [2, 7], [9, 0, 1, 6]]
13
System.out.println(Arrays.toString(arr)); //[[I@214c265e, [I@448139f0, [I@7cca494b]

• 排序

  • static void sort(int[] a) ：将 a 数组按照值从小到大进行排序。

    1
        int[] arr = {1,2,3,43,5};
    2
        Arrays.sort(arr);
    3
        System.out.println(Arrays.toString(arr));//[1,2,3,5,43]
    

    除 boolean 外的基本数据类型，都能排序。

  • static void sort(Object[] a) ：根据元素的自然顺序，对对象数组按升序进行排序。自然顺序通过重写 Comparable 接口的 compareTo(obj o2) 实现。

  • static <T> void sort(T[] a, Comparator<? super T> c) ：根据比较器产生的顺序，对指定对象数组进行升序排序。比较器通过重写 Comparator 接口的 compare(obj o1,obj o2) 实现。

    可以通过修改 compare()、compareTo() 的实现 ，达到降序排列的目的，具体内容见 Java 学习笔记三的 9.1 小节。

• 比较两个数组的内容是否相等

  • static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、相同下标的元素的数值是否完全相同。

    1
        int[] a = new int[]{1,2,3,4};
    2
        int[] b = new int[]{1,2,3,4};
    3
        System.out.println(Arrays.equals(a,b));//true
    

  • static boolean equals(Object[] a,Object[] a2)：比较两个数组的长度、相同下标的对象的内容是否完全相同。

    1
        Person person = new Person();
    2
        Person person1 = new Person();
    3
        Person person2 = new Person();
    4
        Person[] p = new  Person[]{person,person1};
    5
        Person[] p1 = new Person[]{person,person2};
    6
        System.out.println(Arrays.equals(p,p1)); //根据Person的equals判断
    

    通过该类的 equals()方法比较对象的内容，若没重写 equals()方法（相当于“==”），则比较的是“是否为同一个对象”。

1.1 方法重载（Overload，两同一不同）#

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可。

与权限修饰符、返回值类型、形参名无关，比如public void add(int m,int n)和 public void add(int n,int m)就不算重载。

1
class Human{
2
    int a ;
3
    public void Method(){
4

5
    }
6
    protected int Method(int a){ //两个Method构成了重载
7
        return 12;
8
    }
9
}

1.2 可变形参#

格式：方法名(参数的类型名…参数名)，例如public static void test(int a ,String...books){}。

特点：

1. 方法的参数个数可以是 0 个或多个。

2. 可变形参的方法与同名的方法之间，彼此构成重载。例如，public void test(int a){}和public int void test(int...a){}能同时存在。当调用同名函数时，优先级：形参列表确定的函数 > 可变形参的函数。

3. 可变形参与形参是数组是等价的，二者不能同时声明，否则报错。

public static void test(int a,String[] books){}与例子写法是等价的。

4. 可变形参需要放在形参列表的==最后==。

5. 在一个方法中，最多声明一个可变形参。

1.3 参数传递机制-值传递#

形参是基本数据类型：将实参的“数据值”传递给形参。

形参是引用数据类型：将实参的“地址值”传递给形参。

前提是实参和形参类型一致。

1.4 import#

导入==其他包==下的类。格式：import 包名.类名;。

• import 包名.*：导入包下面的所有类。
• 类所在包的其他类 和 java.lang 无需导入，可以直接使用。
• 导包导入的是当前文件夹里的类，不包括其子文件夹里的类。

比如使用import com.*; 是指导入 com 目录下的所有类，这里只有 Test 类，并不会导入在 com 的下一级 lc 目录中的 Phone 类。

• 如果在代码中使用不同包下的同名的类，那么就需要使用全类名(包名+类名)的方式指明调用的是哪个类。

  如：java.sql.Date date = new java.sql.Date(time);

1.5 封装性#

1.6 构造器（Constructor）#

搭配 new 关键字创建对象。

1
public class Student {
2
 private String name;
3
 private int age;
4
 // 无参构造,当程序员没显式给出构造器时，系统会默认调用无参构造且构造器的修饰符与类相同；当程序员给出有参构造时，则默认无参构造会失效。
5
 public Student() {}
6
 // 有参构造，有参构造可以给私有变量赋初值。
7
 public Student(String n,int a) {
8
   name = n;
9
   age = a;
10
 }
11
 //构造器名与类名相同，构造器没有返回值。构造器可以重载。
12
 public String getName() {
13
   return name;
14
 }
15
 public void setName(String n) {
16
   name = n;
17
 }
18
 public int getAge() {
19
   return age;
20
 }
21
 public void setAge(int a) {
22
   age = a;
23
 }
24
 public String getInfo(){
25
   return "姓名：" + name +"，年龄：" + age;
26
 }
27
}
28

29
 //调用无参构造创建学生对象
30
 Student s1 = new Student();
31
 //调用有参构造创建学生对象
32
 Student s2 = new Student("张三",23);

1.7 Java Bean#

一种特殊的类，具有以下属性：

1、具有一个 public 修饰的无参构造函数。

2、所有属性由 private 修饰。

3、通过 public 修饰的 get 方法和 set 方法获得或修改属性。

4、可序列化。

实现 Serializable 接口，用于实现bean的持久性。

1.8 this 关键字#

当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加 this 来表明该变量是类的成员变量。即：我们可以用 this 来区分成员变量和局部变量。

this 代表当前对象或即将创建的对象，Base sub = new Sub();。这里的对象是 Sub 对象，通过看 new 后面的类名判断是何种对象。

this 可以作为一个类中构造器相互调用的特殊格式。

• this()：调用本类的无参构造器。
• this(实参列表)：调用本类的有参构造器。

this()和this(实参列表)只能声明在构造器首行，且不能出现递归调用。

1
public class Student{
2
    private String name;
3
    private int age;
4
    //无参构造
5
    public Student(){}
6
    //有参构造
7
    public Student(String name){
8
        this.name = name;
9
    }
10
    public Student(String name,int age){
11
        this(name); //此行代表先调用 public Student(String name) 这个构造器，减少了代码量。
12
        this.age = age; //这里的 this 代表即将创建的对象。
13
    }
14
    public void setName(String name){
15
        this.name = name; //this代表当前对象，“this.”修饰的变量代表成员变量。
16
    }
17
}

1.9 继承性#

继承的出现让类与类之间产生了 is-a 的关系，比如： A student is a person。

关键字：extends，Java 中的继承是一种扩展，写法：public class B extends A{}。

子类会继承父类中实现了的接口方法。

子类不能直接访问父类中私有的（private）的成员变量，需通过 get/set 方法。

一个父类可以同时拥有多个子类，但一个子类只有一个父类。

类加载的时候，先加载父类，再加载子类。所以先加载父类的静态代码块。

1.10 重写（overwrite、override）#

子类重写从父类继承来的方法，以便适应新需求。

@Override：写在方法上面，用来检测是否满足重写的要求。这个注解就算不写，只要满足要求，也算重写。

重写的要求：

• 方法名和参数列表不能变。

• 子类重写的方法的权限修饰符不能小于父类被重写方法的权限修饰符。

  因为多态是以父类的引用类型调用子类的方法，必须保证父类方法能运行的地方，子类重写后的方法也能执行，所以权限不能变小。

  ① 父类私有方法不能重写。 ② 跨包父类中缺省的方法不能重写。

• 若返回值类型是基本数据类型和 void，则不能改变。

• 若返回值类型是引用数据类型，则返回值类型不能大于父类中被重写的方法的返回值类型。（例如：Student < Person）。

  也就是，返回值类型不变或是返回值类型的子类。原因是返回值可能赋给父类引用类型，这里也涉及了多态。不能把父类的对象赋值给子类引用类型的变量。

• 子类重写的方法抛出的异常不能大于父类被重写方法的异常。

  还是和多态有关，父类的引用类型调用子类的方法，若子类抛出了更大的异常，针对父类写的 try-catch 语句就捕获不到子类的异常。

• static 修饰的方法不能被重写。

1.11 super 关键字#

1.12 多态性#

多态的使用前提：① 类的继承关系 ② 方法的重写

Java 中多态性的体现：**父类的引用可以指向子类的对象。**比如：Person p = new Student();

一种引用可以指向多种对象。

常用多态的地方：

1. 方法的形参

2. 方法的返回值

父类引用作为方法的形参，是多态使用最多的场合。即使增加了新的子类，原方法也无需改变，提高了扩展性，符合开闭原则（对扩展开放，对修改关闭）。

1
public class Person{
2
  private Pet pet;
3
  public void adopt(Pet pet) {//形参是父类类型，实参传入子类对象
4
     this.pet = pet;
5
  }
6
  public void feed(){
7
    pet.eat();   //pet 实际引用的对象类型不同，执行的 eat 方法也不同。
8
    }
9
}
10
    ...
11
        Person person = new Person();
12
        Dog dog = new Dog();
13
     person.adopt(dog);//实参是 dog 子类对象，形参是父类 Pet 类型

**弊端：**使用父类的引用，无法直接访问子类特有的属性和方法。

使用了多态后，==同名属性则会使用父类的，子类独有的属性无法使用，子类新定义的方法无法使用，只有重写过的方法能使用。==

只有先向下转型，才能使用子类的属性或新定义的方法。

根据左边的引用类型，决定调用父类的属性还是子类的属性，而同名方法是调用的子类对象重写过后的方法。

1
    Base b = new Sub(); //引用类型是 Base，调用Base的属性，即 1。
2
    System.out.println(b.a);
3
    Sub s = new Sub(); //引用类型是 Sub，调用 Sub 的属性，即 2。
4
    System.out.println(s.a);
5

6
    class Base{
7
            int a = 1;
8
    }
9
    class Sub extends Base{
10
            int a = 2;
11
    }

1
class Base{
2
    void express(){
3
        System.out.println("我是Base");
4
    }
5
}
6
class Sub extends Base{
7
    @Override
8
    void express() {
9
        System.out.println("我是Sub");
10
    }
11
}
12

13
Base b = new Sub(); //引用类型是 Base
14
b.express(); //按右侧的Sub类型执行方法，打印"我是Sub"
15
Sub s = new Sub(); //引用类型是 Sub
16
s.express(); //按右侧的Sub类型执行方法，打印"我是Sub"

1.13 向下转型#

子类对象由父类引用类型==>子类引用类型

父类对象不存在向下转型。

向上转型是多态。

1
if(pets[i] instanceof Dog){ //
2
   Dog dog = (Dog) pets[i];
3
   dog.watchHouse(); //Dog 特有的方法
4
}

1.14 Object 类#

如果一个类没有显式继承父类，那么默认则继承 Object 类。

Object 类没有属性，只有方法。

1
   @Test
2
    public void test(){
3
       Animal a1 = new Animal();
4
       try {
5
           Animal a2 = (Animal)a1.clone();
6
           System.out.println(a1==a2); //false，
7
       } catch (CloneNotSupportedException e) {
8
           throw new RuntimeException(e);
9
       }
10

11
   }
12
//因为 clone() 的返回值为 Object，这里需要强转，a2 和 a1 是 2 个不同的对象。
13

14
class Animal implements Cloneable{ //需要实现Cloneable接口
15
    int age =10;
16
    @Override
17
    protected Object clone() throws CloneNotSupportedException {
18
        return super.clone();
19
    }
20
}

1
 Base sub = new Sub();
2
 System.out.println(sub.getClass());//输出为：class com.lc.Sub

1
 System.out.println(base); //com.lc.Base@1b6d3586

1
@Override
2
 public String toString() {
3
 return "Person{" + "name='" + name + '\'' + ", age=" + age +'}';
4
 }

1.15 static#

成员变量按照是否使用 static 可以分为：

1. 使用：静态变量（也被称为类变量）。

   1. 随类加载而加载，内存空间里就一份（因为类只加载一次），被类的所有对象共享。jdk6 放在方法区，jdk7 及以后放在堆空间。

   2. 可以通过类或对象调用。

2. 不使用：非静态变量或实例变量。

   1. 每个对象拥有一份实例变量，随对象的创建而加载，存放在堆空间的对象实体中。
   2. 只能通过对象调用。

static 修饰的方法：类方法、静态方法。

特点：

1. 随类加载而加载，可以通过类或对象调用。

2. 静态方法内可以使用静态变量和其他的静态方法，不可以调用非静态的属性和方法。

3. 静态方法中不能使用 this. 和 super.，静态方法在创建对象之前就能使用，所以不能有this. 和 super.。

1
public class ChildTest {
2
    public static void main(String[] args) {
3
        Base base = null;
4
        System.out.println(base.a);
5
        //这里会输出1，因为静态变量属于类，和具体的对象无关，即便该对象是null。。
6
    }
7
}
8
class Base{
9
    static int a = 1;
10
}

类的实例对象可以作为类的属性。

JVM 把类 A 的模板加载进内存后，执行到A a = new A();时，发现内存中有类 A 的模板，则能过编译且成功执行。

1
class A {
2
    static A a = new A(); //随类加载而加载，只执行一次。以后使用时，就去对应存储位置找现成的。静态变量a里也有属性a，只不过指向的是自己。
3
}

1.16 native 关键字#

当一个方法被 native 修饰时，说明这个方法是用非 Java 的编程语言写的。

1.17 类成员-代码块（初始化块）#

1
public class A{
2
  int a = 10;
3
  public A(){
4
  }
5
    {
6
        ... //非静态代码块
7
  }
8
    static{
9
        ... //静态代码块
10
    }
11
}

静态代码块和非静态代码块的相同点：

1. 用于初始化类的信息。

2. 内部可以声明变量、调用属性或方法、编写输出语句等操作。

3. 如果声明多个代码块，则按照声明的先后顺序（即在类中，谁在上面，谁先执行）执行。

   静态代码块的执行总先于非静态代码块的执行。

   不同点：

4. 静态代码块==随类的加载而执行==，只执行一次；非静态代码块==随对象的创建而执行==，即调用构造器时执行，可执行多次。

   理解：

   1. 可以把“非静态代码块”当作类中直接调用父类的那些构造器的一部分，并放在那些构造器的前几行（但在父类的构造器后），一调用构造器就先执行非静态代码块。

   2. 若调用的构造器使用了this(...)，非静态代码块不看成这些构造器的一部分，而看成在this(...)里面，直到找到那个直接调用父类的构造器，将代码块视为其一部分。

   3. 子类的构造器都会直接或间接调用父类的构造器，所以父类的非静态代码块也会执行，且父类构造器比子类构造器先执行。

   1
   public A(){  //执行的时候可以理解成这样
   2
     [super();] //父类构造器,可以不写，默认调用父类空参构造器。
   3
     {
   4
     ... //非静态代码块
   5
             }
   6
         System.out.println("我是直接调用父类的构造器");
   7
     ...
   8
   }
   9
   public A(int a){
   10
      this(); //使用了this(),则没有调用父类的构造器，属于间接调用，因为A()中调用了父类构造器。
   11
      System.out.println("我不是直接调用父类的构造器");
   12
   }
   

   示例：

   1
   Base base = new Base(1,"lc");
   2
   /*
   3
   new Base(1,"lc")调用的是Base(int b, String name)构造器，其中又调用了this(b),即public Base(int b)。
   4
   public Base(int b)又调用this()，即public Base()。
   5
   public Base()没有显式给出调用父类构造器，则默认调用父类空参构造器。
   6
   从以上描述可以看出，public Base()是类中直接调用父类的构造器，非静态代码块可以看为它的一部分，但是在父类的构造器之后。
   7
   public A()是类中直接调用其父类Object的构造器，而Object没有任何输出，然后执行类A的非静态代码块,再执行类A构造器的其余代码，执行完再执行Base的非静态代码块，再执行Base()的其余代码以及其他构造器的代码。
   8
   */
   9
   /*
   10
      结果为：
   11
      我是代码块A
   12
      我是构造器D
   13
      我是代码块Base
   14
      我是构造器A
   15
      我是构造器B
   16
      我是构造器C
   17
   */
   18
   class Base extends A{
   19
     int b = 1;
   20
     String name;
   21
     {
   22
         System.out.println("我是代码块Base");
   23
     }
   24
     public Base(){
   25
         System.out.println("我是构造器A");
   26
     }
   27
   
   28
     public Base(int b) {
   29
         this();
   30
         this.b = b;
   31
         System.out.println("我是构造器B");
   32
     }
   33
     public Base(int b, String name) {
   34
         this(b);
   35
         this.name = name;
   36
         System.out.println("我是构造器C");
   37
     }
   38
   }
   39
   class A{
   40
     {
   41
         System.out.println("我是代码块A");
   42
     }
   43
   
   44
     public A() {
   45
         System.out.println("我是构造器D");
   46
     }
   47
   }
   

5. 静态代码块内部只能调用静态的属性或方法，不能调用非静态的属性、方法；非静态代码块中非静态的或静态的属性、方法都可以调用。

非静态代码块的意义：如果多个重载的构造器有公共代码，并且这些代码都是先于构造器其他代码执行的，那么可以将这部分代码抽取到非静态代码块中，减少冗余代码。

静态代码块的意义：当静态变量的初始化很复杂时，可以使用静态代码块。

给实例属性赋值的执行先后次序：

1. 默认值

2. 显式初始化或代码块初始化（谁放上边，谁先执行，且父类构造器执行完成后，子类中的成员变量才会开始显式初始化。）

   1
   class A{
   2
       {
   3
           a = 20; //先代码块初始化，再显式初始化，最终a的值为10。
   4
       }
   5
       int a = 10; //比较神奇的是，可以先赋值，再定义变量。
   6
   }
   7
   
   8
   class A{
   9
       int a = 10;
   10
       {
   11
           a = 20; //先显式初始化，再代码块初始化，最终a的值为20。
   12
       }
   13
   }
   

3. 构造器中初始化

4. 通过“对象.属性”赋值

1.18 final#

final 代表最终的，即修饰的内容不能修改。

final 能够修饰的结构：类、方法、变量。

• final 修饰类：该类无法被继承。

• final 修饰方法：该方法无法被重写。

• final 修饰变量（成员变量和局部变量都行），一旦赋值，就无法更改。

  • 成员变量赋值（==必须初始化==）

    • 显式赋值

    • 代码块中赋值

    • 构造器中赋值

  • 局部变量赋值

    • 方法内的局部变量，调用之前必须赋值。
    • 方法的形参，调用时传给形参的值无法更改。

• final 和 static 一起修饰的成员变量，称为全局常量。

final 修饰引用类型变量时，其指向的对象的物理地址不能变。即不能再给这个变量赋另外的对象，但对象里面的属性值能修改。

“对象的运行时类型@对象的hashCode值的十六进制形式”不是该对象物理地址。

1.19 abstract#

abstract 代表抽象的，可以修饰类和方法。

• 修饰类：该类为抽象类，不能实例化。==可以包含构造器==（抽象类的构造器不能被直接调用，子类创建对象间接会调用抽象类的构造器，初始化父类成员变量。）

  1. 抽象类也是类，可以有属性、非抽象方法，代码块。

  2. 抽象类也可以继承抽象类。

• 修饰方法：只有方法的声明，没有方法体。无需具体实现，实现是子类的事。

  1
  public abstract void eat(形参); //抽象方法声明，没有“{}”。
  

  1. 有抽象方法的类一定是抽象类，没有抽象方法的类也可以是抽象类。

  2. 子类必须重写完所有抽象方法才能实例化。

可以创建引用类型为抽象类的数组，但存放的元素必须是，继承了抽象类并重写完所有抽象方法的类所创建的实例。

1
Human[] human = new Human[3];
2
human[0] = new Chinese();
3
human[1] = new American();

1.20 接口#

1.20.2 冲突问题#

方法冲突：

• 父类优先原则

  当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类默认执行父类的成员方法。

  几种情况：

  1. 若不重写，默认保留父类的方法
  2. 在重写的方法里，调用父类的方法，super.方法();
  3. 在重写的方法里，调用接口的默认方法，接口名.super.方法();
  4. 完全重写

属性冲突:

• 父类的属性与接口属性重名。

  解决方法：

  1. super.属性：父类属性
  2. 接口名.属性：接口属性（因为接口里的属性是static的，所以可以通过接口名调用）

1.21 内部类（InnerClass）#

将一个类 A 定义在另一个类 B 里面，里面的那个类 A 就称为内部类（InnerClass），类 B 则称为外部类（OuterClass）。

当一个事物 A 的内部的某部分是一个完整结构 B ，而结构 B 又只为事物 A 提供服务，不在其他地方单独使用，那么完整结构 B 最好使用内部类。

1
class Person{
2
  //静态成员内部类
3
  static class Dog{
4

5
  }
6
    //非静态成员内部类
7
    class Bird{
8
        //若出现同名变量或方法，就近原则。想使用外部类的，需用Person.this.变量（方法）名。
9
        //this.变量（方法）名，就近原则。
10
    }
11
    public void method(){
12
        //局部内部类
13
        class InnerClass1{
14

15
        }
16
    }
17
    public Person(){
18
        //局部内部类可以重名，不能有权限修饰符
19
        class InnerClass1{
20

21
        }
22
    }
23
}
24

25
//在main()创建静态内部类实例，若在外部类中创建内部类的实例，就和之前创建对象一样。
26
Person.Dog dog = new Person.Dog();
27

28
//在main()创建非静态内部类实例，非静态内部类需要外部类的对象来创建。
29
Person p1 = new Person();
30
Person.Bird bird = p1.new Bird(); //也可以写成Bird bird = p1.new Bird();

1
new 父接口(){  //创建了实现类的一个对象
2
    重写方法...
3
}.方法(方法的参数);
4

5
new 父类(构造器参数){ //创建了子类的一个对象
6
    重写方法...
7
}.方法(方法的参数);

1
public class Demo {
2
    public static void main(String[] args) {
3
        new B(){  //通过匿名内部类的对象直接调用方法。
4
            @Override
5
            public void a() {
6
        ...
7
            }
8
        }.a();
9
         B b = new B(){  //多态
10
            @Override
11
            public void a() {
12
        ...
13
            }
14
        };
15
        b.a(); //通过父接口的引用调用方法
16
    }
17
}
18
interface B{
19
    void a();
20
}

1
interface A{
2
    void method();
3
}
4
public class Test{
5
    public static void test(A a)
6
    {
7
        a.method;
8
    }
9
public static void main(String[] args) {
10
        test(new A(){
11
            @Override
12
            public void method() {
13
         System.out.println("a");
14
            }
15
        });//此时匿名内部类是一个参数
16
}
17
}

1.22 枚举类#

枚举类型本质上是一种类，只不过是这个类的实例是有限的、固定的几个，不能让用户随意创建。比如：春、夏、秋、冬。

若枚举只有一个对象, 则可以作为一种单例模式的实现方式。

1
enum Season{  //默认继承了 Enum 类，不能再显式继承其他类，但可以实现接口。
2
    //1.必须在枚举类开头声明多个对象，对象直接用“,”隔开，省略了修饰符“public static final”。
3
    SPRING("春天","春暖花开"),
4
    //可以看成“public static final SPRING = new Season("春天","春暖花开");”，但是不能这么写
5
    SUMMER("夏天","夏日炎炎"),
6
    AUTUMN("秋天","秋高气爽"),
7
    WINTER("冬天","白雪皑皑");
8
    //2.声明描述枚举类的属性，用“private final”修饰。
9
    private final String seasonName;
10
    private final String seasonDesc;
11

12
    Season(String seasonName, String seasonDesc) { //构造器修饰符省略了“private”
13
        this.seasonName = seasonName;
14
        this.seasonDesc = seasonDesc;
15
    }
16

17
    public String getSeasonName() {
18
        return seasonName;
19
    }
20

21
    public String getSeasonDesc() {
22
        return seasonDesc;
23
    }
24
}
25

26
//通过“枚举类名.常量”获取枚举对象，如 Season.SPRING
27
System.out.println(Season.SPRING.toString()); //默认打印对象名，SPRING，可以重写
28
System.out.println(Season.SPRING.name()); //打印对象名，SPRING
29
Season[] values = Season.values(); //所有枚举类对象放到 values 数组中
30
Season.valueOf("SPRING"); //返回字符串同名的枚举对象，没有相应的枚举对象则报错。

枚举类实现接口的 2 种方式：

1
enum A implements 接口1，接口2{ //共用一个重写后的方法。
2
  //抽象方法的实现
3
}
4

5
//2、枚举类的常量可以继续重写抽象方法，每个枚举对象有自己的重写方法。
6
enum A implements 接口1，接口2{
7
    常量名1(属性1,属性2..){
8
        //抽象方法的实现或重写，实现方式是匿名内部类
9
    },
10
    常量名2(属性1,属性2..){
11
        //抽象方法的实现或重写
12
    },
13
    //...
14
}

1.23 注解（Annotation）#

注解是给编译器或其他程序读取的。程序可以根据不同的注解，做出相应的处理。

1
【元注解】
2
【修饰符】 @interface 注解名{
3
    【成员列表】
4
}

1
@Target({METHOD})
2
public @interface myAnnotation{
3
    String value() default "hello"; //default "hello" 可加可不加，指定默认返回值
4
}
5

6
...
7
@myAnnotation(value="world")
8
public void method1(){
9

10
}
11
@myAnnotation() //使用默认返回值，"hello"
12
public void method1(){
13

14
}

1
public class Person {
2
    @Test
3
    public void test1(){
4
        System.out.println("hello");
5
        method(10); //需要测试的方法写里面，并且无需通过对象调用。
6
    }
7
    public int method(int num){
8
        return num;
9
    }
10
}

1.24 包装类#

装箱：把基本数据类型转为包装类对象。

拆箱：把包装类对象拆为基本数据类型。

有自动装箱和自动拆箱。

1
Integer i = 1; //自动装箱
2
//底层调用 Integer i = Integer.valueOf(1);
3
i = i + 5; //等号右边：将 i 对象转成基本数值(自动拆箱) i.intValue() + 5; 加法运算完成后，再次装箱，把基本数值转成对象。
4
//只能与自己对应的类型之间才能实现自动装箱与拆箱。
5
Double d = 1;//错误的，1 是 int 类型,没有自动类型提升，过不了编译。

1
int a = 10;
2
//String str = a;//错误的
3
String str = String.valueOf(a);

1
int a = 10;
2
String str = a + "";

1
//除了 Character 类之外，可以使用 parseXxx()。parseXxx()是静态方法，返回值为包装类。但由于自动拆箱，可以赋值给基本数据类型。
2
int a = Integer.parseInt("123");

1
//自动装箱的底层调用的是 Integer 的 valueOf
2
Integer a = 1; //自动装箱，在一定范围内，相同的值使用的是同一个对象。
3
Integer b = 1;
4
System.out.println(a==b); //true
5

6
Integer a = new Integer(1); //2 个不同的对象
7
Integer b = new Integer(1);
8
System.out.println(a==b); //false
9

10
Integer i = 1000;
11
double j = 1000;
12
System.out.println(i==j);//true 会先将 i 自动拆箱为 int，然后根据基本数据类型“自动类型转换”规则，转为 double 比较。
13

14
Integer i = 1;
15
Double d = 1.0;
16
System.out.println(i==d);//编译报错,2个不同的包装类的比较不会自动拆箱。

1
    Integer b = new Integer(2); //没有满足前提1
2
    Integer c = b;
3
    b += 10;//等价于 b = new Integer(b+10);
4
    b -= 10;
5
    System.out.println(b==c); //false
6

7
    Integer f = 1113; //没有满足前提2，不在缓存范围内
8
    Integer c = f;
9
    c += 10;
10
    c -= 10;
11
    System.out.println(c==f); //false
12

13
    Integer f = 12; //满足了前提1和2
14
    Integer c= f;
15
    c += 10;
16
    c -= 10;
17
    System.out.println(c==f); //true

1.1 异常体系#

1.2 异常处理#

运行时异常，不针对性地处理，出现异常时再改代码；编译时异常需用以下的语句处理。

1
    try{
2
    ...... //可能产生异常的代码
3
          //{}里定义的是局部变量，不能在其他的{}里使用
4
    }
5
    catch( 异常类型1 e ){ //e是异常类创建的对象的引用
6
    ...... //当产生异常类型1型异常时的处置措施
7
    }
8
    catch( 异常类型2 e ){
9
    ...... //当产生异常类型2型异常时的处置措施
10
    }
11
    finally{
12
    ..... //无论 try 或 catch 中是否发生异常，finally中的语句一定要执行。
13
   //若try 或 catch 里有 return 语句，也需等 finally 里的语句执行完后才能 return。即便在finally 里修改了需要返回的变量的值，return 的值也是修改前的那个值，除非在 finally 再写个 return，抢先 return。
14
    }
15
    //catch()最多执行一个。若多个异常存在子父类关系，则子类放上面，父类放下面。
16
    /*
17
    catch(... e){
18
        e.printStackTrace(); //打印异常信息，就是红色字体那个信息
19
        System.out.println(e.getMessage()); // 返回值为 new 异常类名("需打印的字符串")里的字符串
20
    }
21
    */

1
public void readFile(String file) throws FileNotFoundException,IOException {
2
  ...
3
  // 读文件的操作可能产生 FileNotFoundException 或 IOException 类型的异常
4
  FileInputStream fis = new FileInputStream(file);
5
    ...
6
}

1
    Father f = new Son();
2
    try{
3
        ...
4
    }catch(异常类型 e){ //这里的异常类型需写父类抛出的异常类型，因为编译看左边，把 f 当成了 Father 类型，但实际执行的是子类的方法，若子类抛的更大，则这里抓不住，也就处理不了。
5
        ...
6
    }

1.3 自定义异常类#

步骤：

1. 继承一个异常类型。自定义编译型异常继承Exception；自定义运行时异常继承RuntimeException。
2. 提供至少两个构造器，一个是无参构造，一个是参数为(String message)的构造器。
3. 自定义异常需要提供 serialVersionUID。

2.1 基本概念#

String s1 = "hello";“hello”叫字符串常量，字符串常量存储在字符串常量池，字符串常量池不允许存放 2个相同的字符串常量。jdk7 之前，字符串常量池在方法区，jdk7 及以后字符串常量池在堆中。

String 对象的字符内容是存储在一个字符数组 value[] 中的。"hello" 等价于 char[] data={'h','e','l','l','o'}。

1
//jdk8中的String源码：
2
public final class String //String类用final修饰，所以不能继承 String。
3
    implements java.io.Serializable, Comparable<String>, CharSequence {
4
    /** The value is used for character storage. */
5
    private final char value[]; //String对象的字符内容是存储在此数组中
6
//jdk9中char数组改成了byte[]数组。

不可变的原因：

private final char value[];

• private ： 外部无法获取字符数组，且 String 没有提供 value 的 get 和 set 方法（外部不能改）。

• final ：引用不可变，且 String 也没有提供修改 value 数组某个元素值的方法（内部不能改）。

所以一旦创建了 String 对象就无法改变。赋值、拼接、replace() 看似改变了字符串的值，实际上是创建存储新值的新对象，而没有修改原对象的值。

2.2 字符串拼接：#

• 常量 + 常量：结果仍存储在字符串常量池中，返回此字面量的地址。

  这里的常量指的是字面量或 final 修饰的常量（但不能是某个函数的返回值，即便返回值不变。如 final String s = B.get()）。

  因为在编译期间就能确定拼接的结果，所以直接返回了字面量的地址。

  1
      String s = "abc"+"def";
  2
      final String s1 = "abc"; //s1 也看成常量
  3
      String s2 = s1 + "def";
  4
      System.out.println(s == s2); //true
  

• 一旦拼接了变量，则会在堆中 new 一个对象，再指向字符串常量池中的字符串，返回的是堆空间对象的地址。

concat() 始终会在堆空间 new 一个对象，指向常量池的字面量。

2.3 常见的构造器#

• public String() ：创建一个新的 String 对象，使其表示空字符串。

  1
  String s = new String(); //相当于String s = new String("");
  

• String(String original)： 创建一个新的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。

• public String(char[] value) ：通过字符数组来构造新的 String。

• public String(char[] value,int offset, int count) ：通过字符数组的一部分来构造新的 String。

• public String(byte[] bytes) ：使用默认字符集解码参数中的字节数组来构造新的 String。

• public String(byte[] bytes,String charsetName) ：使用“指定的字符集”解码参数中的字节数组来构造新的 String。

2.4 String 和 char[] 的转换#

String => char[]：调用 String 的 toCharArray()。

1
char[] arr = str.toCharArray();

char[] => String：调用 String 的构造器。

1
String s = new String(arr);

2.5 String 和 byte[] 的转换#

String => byte[]：调用 String 的 getBytes()。

1
byte[] arr1 = "我爱你".getBytes("字符集"); //不指定字符集则默认使用 utf-8

byte[] => String：调用 String 的构造器。

1
String s1 = new String(arr1,"字符集");//不指定字符集则默认使用 utf-8

编码：String => 字节数组(看得懂的 => 看不懂的)

解码：字节或字节数组 => String

编码和解码的字符集必须相同。

2.6 字符串常量池的理解#

感觉理解还是不到位，暂时像下图这样记，了解了虚拟机后再补充。

String s2 = new String("hellolc");，会创建 2 个对象，一个是堆空间中 new 的对象，另一个是堆空间的字符串常量池中的 String 对象。

1
String s1 = new String("1") + new String("2");
2
//实际上是执行的：String s1 = StringBuilder().append("1").append("2").toString();
3
//以上代码只会在字符串常量池中放入"1"和"2"，并不会在常量池中放入"12"，记成结论就行。
4
//下图省略了 new 出来的2个字符串对象(new String("1")、new String("2"))。

s.inertn()：如果在常量池中存在与 s 内容相同的字符串，就直接返回常量池中相应字符串的引用（情况1），否则在常量池中保存 s 的引用，并将 s 的引用返回（情况2）。

情况 2 的图（省略了常量池里的”111”、“222”）：

1
    String s1 = new String("111") + new String("222");
2
    s1.intern();
3
    String s2 = "111222";
4
    System.out.println(s1==s2); //true，情况2

1
常量池里没有"111222"，先把 s1 的引用放入常量池，s2 取到的实际上是 s1的引用。

情况 1 的图（省略了常量池里的”111”、“222”）：

1
    String s1 = new String("111") + new String("222");
2
    String s2 = "111222";
3
    s1.intern();
4
    System.out.println(s1==s2); //fasle，情况1

常量池最初没有”111222”，String s2 = "111222"; ，将”111222”放入了常量池，再调用s1.intern();时，常量发现有了”111222”，则直接返回常量池中相应字符串的引用，由于没使用返回值，相当于什么也没做，所以 s1 和 s2 的引用不同。

2.7 字符串相关类之可变字符序列#

因为 String 对象是不可变对象，虽然可以共享常量对象，但是若频繁地修改或拼接字符串，会导致效率极低，空间消耗也比较高。

继承结构：

AbstractStringBuilder（jdk 9及以后改成 byte[]）：

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样，两者地主要区别是方法是否添加 synchronized，下面以 StringBuilder 为例。

2.7.2 StringBuilder（后提出）#

线程不安全的，效率高；最初使用 char[] 数组存储，jdk 9及以后改成 byte[]。

常见构造器：

1
    public StringBuilder() {  //空参：默认容量为16
2
        super(16);
3
    }
4

5
    public StringBuilder(int capacity) { //主动指定容量大小，避免多次扩容
6
        super(capacity);
7
    }
8

9
    public StringBuilder(String str) { //传入字符串，容量为16 + 字符串的长度
10
        super(str.length() + 16);
11
        append(str);
12
    }

扩容：不断地添加元素，一旦 count 要超过 value.length 时，就扩容，默认扩容为“原有容量的 2 倍 + 2”，并将原数组的元素复制到新数组中。

面试题（StringBuffer 与 null）：

1
    String str = null;
2
    StringBuffer sb = new StringBuffer();
3
    sb.append(str); //底层会改成添加"null"字符串。
4

5
    System.out.println(sb.length());//返回现有字符的个数，4
6

7
    System.out.println(sb);// null
8

9
    StringBuffer sb1 = new StringBuffer(str);
10
    System.out.println(sb1);//空指针异常，StringBuffer、StringBuilder的构造器不能传 null。

返回值的说明：StringBuilder里的一部分方法的返回值为StringBuilder类型，实际上返回的是被操作对象本身（源码里返回的this），没有创建新对象。

StringBuffer同理。