java基础查漏补缺

• 1160

初始化块的使用分析：

一个类里可以有多个初始化块；

如果一个类里定义了两个普通初始化块，则前面定义的初始化块先执行，后面定义的初始化块后执行；

初始化块虽然也是Java类里的一种成员，但它没有名字，也就没有标识，因此无法通过类、对象来调用初始化块；

初始化块只能在创建对象时自动执行而且在执行构造方法之前执行。

静态初始化块

    如果定义初始化块时使用了static修饰符，则这个初始化块就变成了静态初始化块，也被称为类初始化块。

静态初始化块是类相关的，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行，因此静态初始块总是比普通初始化块先执行。

静态初始块属于类的静态成员，用于对类属性执行初始化处理，不能对实例属性进行初始化处理。

系统在类初始化阶段执行静态初始化时，不仅会执行本类的静态初始化块，还会一直上溯到Object类（如果它包含静态初始化块）。经过这个过程，才完成了对类的初始化过程。

1.创建Animal类

[java]  view plain  copy

1. public class Animal {  
2.   
3.     {  
4.         System.out.println("---animal初始化块----");  
5.   
6.     }  
7.   
8.     public Animal() {  
9.         System.out.println("-----animal构造器-------");  
10.     }  
11.   
12.     static {  
13.         System.out.println("---Animal--static初始化块-----");  
14.   
15.     }  
16.   
17.       
18.     public static void main(String[] args) {  
19.   
20.         new Animal();  
21.     }  
22.   
23. }  

2.创建Bird子类

[java]  view plain  copy

1. public class Bird extends Animal {  
2.   
3.     static {  
4.         System.out.println("------bird---static初始化块---");  
5.     }  
6.   
7.     {  
8.         System.out.println("----Bird初始化块----");  
9.     }  
10.   
11.     public Bird() {  
12.         System.out.println("---Bird构造器-----");  
13.     }  
14.   
15.     public static void main(String[] args) {  
16.         new Bird();  
17.           
18.     }  
19. }  

1.先执行static初始化块，先祖先开始到子类

2.再执行祖先的初始化操作(先执行祖先的方法，再执行祖先的构造器)，再执行下一个祖先的初始化，依次到最后的子类(先执行子类的方法，再执行子类的构造器)。

当然，如果你在Animal类里最上面写上” public static Animal animal=new Animal();”,那它就会先执行初始化块，因为虽然new了Animal对象，但它毕竟是 static 修饰的。

• 1160

初始化块的使用分析：

一个类里可以有多个初始化块；

如果一个类里定义了两个普通初始化块，则前面定义的初始化块先执行，后面定义的初始化块后执行；

初始化块虽然也是Java类里的一种成员，但它没有名字，也就没有标识，因此无法通过类、对象来调用初始化块；

初始化块只能在创建对象时自动执行而且在执行构造方法之前执行。

静态初始化块

    如果定义初始化块时使用了static修饰符，则这个初始化块就变成了静态初始化块，也被称为类初始化块。

静态初始化块是类相关的，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行，因此静态初始块总是比普通初始化块先执行。

静态初始块属于类的静态成员，用于对类属性执行初始化处理，不能对实例属性进行初始化处理。

系统在类初始化阶段执行静态初始化时，不仅会执行本类的静态初始化块，还会一直上溯到Object类（如果它包含静态初始化块）。经过这个过程，才完成了对类的初始化过程。

1.创建Animal类

[java]  view plain  copy

1. public class Animal {  
2.   
3.     {  
4.         System.out.println("---animal初始化块----");  
5.   
6.     }  
7.   
8.     public Animal() {  
9.         System.out.println("-----animal构造器-------");  
10.     }  
11.   
12.     static {  
13.         System.out.println("---Animal--static初始化块-----");  
14.   
15.     }  
16.   
17.       
18.     public static void main(String[] args) {  
19.   
20.         new Animal();  
21.     }  
22.   
23. }  

2.创建Bird子类

[java]  view plain  copy

1. public class Bird extends Animal {  
2.   
3.     static {  
4.         System.out.println("------bird---static初始化块---");  
5.     }  
6.   
7.     {  
8.         System.out.println("----Bird初始化块----");  
9.     }  
10.   
11.     public Bird() {  
12.         System.out.println("---Bird构造器-----");  
13.     }  
14.   
15.     public static void main(String[] args) {  
16.         new Bird();  
17.           
18.     }  
19. }  

1.先执行static初始化块，先祖先开始到子类

2.再执行祖先的初始化操作(先执行祖先的方法，再执行祖先的构造器)，再执行下一个祖先的初始化，依次到最后的子类(先执行子类的方法，再执行子类的构造器)。

当然，如果你在Animal类里最上面写上” public static Animal animal=new Animal();”,那它就会先执行初始化块，因为虽然new了Animal对象，但它毕竟是 static 修饰的。

1. 类变量与成员变量的区别？

成员变量和类变量的区别：

   1、两个变量的生命周期不同

      成员变量随着对象的创建而存在，随着对象的回收而释放。

      静态变量随着类的加载而存在，随着类的消失而消失。

   2、调用方式不同

      成员变量只能被对象调用。

      静态变量可以被对象调用，还可以被类名调用。

   3、别名不同

      成员变量也称为实例变量。

      静态变量也称为类变量。

   4、数据存储位置不同

      成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

 

• 1160

初始化块的使用分析：

一个类里可以有多个初始化块；

如果一个类里定义了两个普通初始化块，则前面定义的初始化块先执行，后面定义的初始化块后执行；

初始化块虽然也是Java类里的一种成员，但它没有名字，也就没有标识，因此无法通过类、对象来调用初始化块；

初始化块只能在创建对象时自动执行而且在执行构造方法之前执行。

静态初始化块

    如果定义初始化块时使用了static修饰符，则这个初始化块就变成了静态初始化块，也被称为类初始化块。

静态初始化块是类相关的，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行，因此静态初始块总是比普通初始化块先执行。

静态初始块属于类的静态成员，用于对类属性执行初始化处理，不能对实例属性进行初始化处理。

系统在类初始化阶段执行静态初始化时，不仅会执行本类的静态初始化块，还会一直上溯到Object类（如果它包含静态初始化块）。经过这个过程，才完成了对类的初始化过程。

1.创建Animal类

[java]  view plain  copy

1. public class Animal {  
2.   
3.     {  
4.         System.out.println("---animal初始化块----");  
5.   
6.     }  
7.   
8.     public Animal() {  
9.         System.out.println("-----animal构造器-------");  
10.     }  
11.   
12.     static {  
13.         System.out.println("---Animal--static初始化块-----");  
14.   
15.     }  
16.   
17.       
18.     public static void main(String[] args) {  
19.   
20.         new Animal();  
21.     }  
22.   
23. }  

2.创建Bird子类

[java]  view plain  copy

1. public class Bird extends Animal {  
2.   
3.     static {  
4.         System.out.println("------bird---static初始化块---");  
5.     }  
6.   
7.     {  
8.         System.out.println("----Bird初始化块----");  
9.     }  
10.   
11.     public Bird() {  
12.         System.out.println("---Bird构造器-----");  
13.     }  
14.   
15.     public static void main(String[] args) {  
16.         new Bird();  
17.           
18.     }  
19. }  

1.先执行static初始化块，先祖先开始到子类

2.再执行祖先的初始化操作(先执行祖先的方法，再执行祖先的构造器)，再执行下一个祖先的初始化，依次到最后的子类(先执行子类的方法，再执行子类的构造器)。

当然，如果你在Animal类里最上面写上” public static Animal animal=new Animal();”,那它就会先执行初始化块，因为虽然new了Animal对象，但它毕竟是 static 修饰的。

1. final、finally、finalize的区别？

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供finally块来执行任何清除操作。如果抛出一个异常，那么相匹配的catch子句就会执行，然后控制就会进入finally块（如果有的话）。
finalize—方法名。Java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的

• 1160

2.初始化块的使用分析：

一个类里可以有多个初始化块；

如果一个类里定义了两个普通初始化块，则前面定义的初始化块先执行，后面定义的初始化块后执行；

初始化块虽然也是Java类里的一种成员，但它没有名字，也就没有标识，因此无法通过类、对象来调用初始化块；

初始化块只能在创建对象时自动执行而且在执行构造方法之前执行。

静态初始化块

    如果定义初始化块时使用了static修饰符，则这个初始化块就变成了静态初始化块，也被称为类初始化块。

静态初始化块是类相关的，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行，因此静态初始块总是比普通初始化块先执行。

静态初始块属于类的静态成员，用于对类属性执行初始化处理，不能对实例属性进行初始化处理。

系统在类初始化阶段执行静态初始化时，不仅会执行本类的静态初始化块，还会一直上溯到Object类（如果它包含静态初始化块）。经过这个过程，才完成了对类的初始化过程。

1.创建Animal类

[java]  view plain  copy

1. public class Animal {  
2.   
3.     {  
4.         System.out.println("---animal初始化块----");  
5.   
6.     }  
7.   
8.     public Animal() {  
9.         System.out.println("-----animal构造器-------");  
10.     }  
11.   
12.     static {  
13.         System.out.println("---Animal--static初始化块-----");  
14.   
15.     }  
16.   
17.       
18.     public static void main(String[] args) {  
19.   
20.         new Animal();  
21.     }  
22.   
23. }  

2.创建Bird子类

[java]  view plain  copy

1. public class Bird extends Animal {  
2.   
3.     static {  
4.         System.out.println("------bird---static初始化块---");  
5.     }  
6.   
7.     {  
8.         System.out.println("----Bird初始化块----");  
9.     }  
10.   
11.     public Bird() {  
12.         System.out.println("---Bird构造器-----");  
13.     }  
14.   
15.     public static void main(String[] args) {  
16.         new Bird();  
17.           
18.     }  
19. }  

1.先执行static初始化块，先祖先开始到子类

2.再执行祖先的初始化操作(先执行祖先的方法，再执行祖先的构造器)，再执行下一个祖先的初始化，依次到最后的子类(先执行子类的方法，再执行子类的构造器)。

当然，如果你在Animal类里最上面写上” public static Animal animal=new Animal();”,那它就会先执行初始化块，因为虽然new了Animal对象，但它毕竟是 static 修饰的。

3.String是有length()方法的。没有length属性；   

而数组，只有length属性，没有length()方法。

• 1160

初始化块的使用分析：

一个类里可以有多个初始化块；

如果一个类里定义了两个普通初始化块，则前面定义的初始化块先执行，后面定义的初始化块后执行；

初始化块虽然也是Java类里的一种成员，但它没有名字，也就没有标识，因此无法通过类、对象来调用初始化块；

初始化块只能在创建对象时自动执行而且在执行构造方法之前执行。

静态初始化块

    如果定义初始化块时使用了static修饰符，则这个初始化块就变成了静态初始化块，也被称为类初始化块。

静态初始化块是类相关的，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行，因此静态初始块总是比普通初始化块先执行。

静态初始块属于类的静态成员，用于对类属性执行初始化处理，不能对实例属性进行初始化处理。

系统在类初始化阶段执行静态初始化时，不仅会执行本类的静态初始化块，还会一直上溯到Object类（如果它包含静态初始化块）。经过这个过程，才完成了对类的初始化过程。

1.创建Animal类

[java]  view plain  copy

1. public class Animal {  
2.   
3.     {  
4.         System.out.println("---animal初始化块----");  
5.   
6.     }  
7.   
8.     public Animal() {  
9.         System.out.println("-----animal构造器-------");  
10.     }  
11.   
12.     static {  
13.         System.out.println("---Animal--static初始化块-----");  
14.   
15.     }  
16.   
17.       
18.     public static void main(String[] args) {  
19.   
20.         new Animal();  
21.     }  
22.   
23. }  

2.创建Bird子类

[java]  view plain  copy

1. public class Bird extends Animal {  
2.   
3.     static {  
4.         System.out.println("------bird---static初始化块---");  
5.     }  
6.   
7.     {  
8.         System.out.println("----Bird初始化块----");  
9.     }  
10.   
11.     public Bird() {  
12.         System.out.println("---Bird构造器-----");  
13.     }  
14.   
15.     public static void main(String[] args) {  
16.         new Bird();  
17.           
18.     }  
19. }  

1.先执行static初始化块，先祖先开始到子类

2.再执行祖先的初始化操作(先执行祖先的方法，再执行祖先的构造器)，再执行下一个祖先的初始化，依次到最后的子类(先执行子类的方法，再执行子类的构造器)。

当然，如果你在Animal类里最上面写上” public static Animal animal=new Animal();”,那它就会先执行初始化块，因为虽然new了Animal对象，但它毕竟是 static 修饰的。