Java基础（一）——面向对象

一、对象

1、成员变量和局部变量的区别

　　两类变量同名时，局部变量具有更高的优先级。

　　作用域不同：局部变量的作用域仅限于定义它的方法，作用于函数或者语句中；成员变量的作用域在整个类中。

　　初始值不同：Java会给成员变量一个初始值；Java不会局部变量赋予初始值。

　　在内存中的位置：成员变量存在堆内存中，因为对象的存在而存在；局部变量存在栈（局部变量表）内存中。

2、构造函数

　　特点：函数名与类名相同。不用定义返回值类型。不可以写return语句。

　　注意：默认构造函数的特点。多个构造函数是以重载的形式存在的。一般函数不能调用构造函数。

3、构造代码块

　　在类的声明中，可以包含多个构造代码块，当创建类的实例时，会依次执行这些代码块 。

　　作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。

　　与构造函数的区别：构造代码块是给所有对象进行统一初始化，是对不同对象的共性进行初始化，而构造函数是给对应的对象初始化。

代码示例：

 1 public class Test {
 2     // 构造代码块
 3     {
 4         num = 200;
 5     }
 6     public int num = 10;
 7
 8     public static void main(String[] args) {
 9         Test test = new Test();
10
11         System.out.println(test.num); // 10
12     }
13 }
14
15
16 public class Test {
17     public int num = 10;
18     {
19         num = 200;
20     }
21
22     public static void main(String[] args) {
23         Test test = new Test();
24
25         System.out.println(test.num); // 200
26     }
27 }

面试点

4、对this的理解

　　this到底代表什么？

　　this代表本类的对象。代表它所在函数所属对象的引用（函数和变量是属于哪个对象的。或者说是哪个对象在调用这个函数，这个变量，他就属于哪个对象）。简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

　　this的作用：用于区分成员变量和局部变量。用于构造函数之间的调用。

　　this的应用：当定义类中函数时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡是本类功能内部用到本类对象时，用this。this语句：用于构造函数之间的相互调用。且只能用this （不能直接访问）。且必须是构造函数中的第一个语句，因为初始化要先执行。

1 class Person {
2     public Person() {
3         Person("kk"); // this("kkk");
4     }
5
6     public Person(String name) {
7
8     }
9 }

会报编译错误

二、静态static

1、介绍

　　static关键字，只能用于修饰成员（成员变量和成员函数）。

①、被修饰后的成员具有以下特点

• 随着类的加载而加载（重点理解）。消失而消失。
• 优先于对象存在（重点理解）。
• 被所有对象所共享。
• 可以直接被类名调用。

②、存储区

• 类变量随着类的加载而存在于方法区。
• 实例变量随着对象的建立而存在于堆内存中。

③、生命周期

• 类变量随着类的存在而存在，消失而消失。它的生命周期最长。
• 实例变量生命周期随着对象的消失而消失。

④、注意

• 静态方法只能访问静态成员，无法从静态上下文访问非静态变量。
• 静态方法中不可以写this，super关键字。因为静态优先于对象存在。
• 主函数是静态的。
• 静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收！

2、main函数

　　主函数是一个特殊的函数，作为程序的入口，格式是固定的，可以被JVM调用。JVM在调用主函数时，传入的是new String[0]。定义如下：

　　public：代表该函数访问权限是最大的。

　　static：代表主函数随着类的加载就已经存在了。

　　void：主函数没有具体的返回值。

　　main：不是关键字，但是是一个特殊的单词，可以被JVM识别。

　　String[] args：函数的参数，参数类型是一个字符串数组。

3、静态代码块

　　先看代码（无继承关系）。下面再解释。

 1 public class StaticTest {
 2     static {
 3         System.out.println("StaticTest 静态代码块");
 4     }
 5
 6     {
 7         System.out.println("StaticTest 构造代码块");
 8     }
 9
10     public StaticTest() {
11         System.out.println("StaticTest 构造器");
12     }
13
14     public static void main(String[] args) {
15         System.out.println("-------------A----------");
16
17         new T().method();
18         new T();
19
20         System.out.println("-------------B----------");
21
22         new StaticTest();
23     }
24 }
25
26 class T {
27     static {
28         System.out.println("1");
29     }
30
31     {
32         System.out.println("2");
33     }
34
35     public T() {
36         System.out.println("3");
37     }
38
39     public void method() {
40         System.out.println("T-----method");
41     }
42 }
43
44 // 结果
45 StaticTest 静态代码块
46 -------------A----------
47 1
48 2
49 3
50 T-----method
51 2
52 3
53 -------------B----------
54 StaticTest 构造代码块
55 StaticTest 构造器

面试点

　　解释：首先，记住几个知识点：

①、静态代码块随着类的加载而执行，因为一个类只会被加载一次，所以静态代码块也只执行一次。且优先于main函数。

②、先有类，再有对象。构造代码块优先于构造函数（这个下一节还会提到）。

　　这样，就不难得出上面的结果。

①、因为main方法是StaticTest类的，所以执行main之前，需要装载StaticTest类，那么装载StaticTest，就会执行他的静态代码块。

②、new T().method();需要创建 T 的对象，就需要装载 T 类，同理，装载 T 类会执行 T 的静态代码块，后面是 2  3 不难理解。然后调用method()方法。

③、new T();由于一个类只会被装载一次。所以后面再是 2  3 。 没有 1 。接着后面的打印也不难理解。

　　再看代码（有继承关系）。

 1 // 有继承关系
 2 public class Son extends Father {
 3     static {
 4         System.out.println("6");
 5     }
 6
 7     {
 8         System.out.println("7");
 9     }
10
11     public Son() {
12         // 会默认调用父类的无参构造器 super();
13         System.out.println("8");
14     }
15
16     public static void main(String[] args) {
17         new Son();
18     }
19 }
20
21 class Father {
22     static {
23         System.out.println("1");
24     }
25
26     {
27         System.out.println("2");
28     }
29
30     public Father() {
31         System.out.println("3");
32     }
33 }
34
35 // 结果
36 1 6 2 3 7 8

面试点

　　解释：一点，先父类后子类。再结合上面的知识点，不难理解结果。

三、对象的初始化过程

　　知识点：

①、类先于对象。

②、父类先于子类。

③、对象中，成员变量初始化步骤。默认初始化（int num = 0）-->显示初始化、构造代码块初始化-->构造器初始化。

　　特别注意：这里的显示初始化、构造代码块初始化，没有绝对的先后顺序，取决于你源代码中的顺序执行。还记得本文中，第一个贴代码"面试点"的位置么？

 1 public class Test {
 2     public static void main(String[] args) {
 3         new KK();
 4     }
 5 }
 6
 7 class KK {
 8
 9     {
10         System.out.println("1");
11     }
12
13     {
14         System.out.println("2");
15     }
16
17     public KK() {
18         System.out.println("KK");
19     }
20
21     Y y = new Y();
22 }
23
24 class Y {
25     public Y() {
26         System.out.println("Y");
27     }
28 }
29
30 // 结果
31 1 2 Y KK

面试点

　　Y y = new Y();在类 KK 中的位置不同，结果不同，读者可自己验证。

四、封装、继承、多态

　　这个不多阐述，请读者自行百度。

1、封装

2、继承

3、多态

4、final关键字

　　final可以修饰类，方法，变量和属性。

①、特点：

• final修饰的类不可以被继承。
• final修饰的方法不可以被覆盖。
• final修饰的变量是一个常量，只能被赋值一次。
• 内部类只能访问被final修饰的局部变量。

final修饰属性不会进行隐式的初始化，必须显示赋值。或在构造方法中显示初始化，但二者只能选其一。

五、抽象类和接口

　　这里不阐述他们的区别之类的，请读者自行百度。

　　后面会专门有小节做详细介绍。