Java知识点(二)——三大特性：封装继承多态

1、如何理解多态？

多态是一种运行期的行为，不是编译期的行为。

多态：父类型的引用可以指向子类型的对象。比如 Parent p = new Child()；当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的该同名方法。如果想要调用子类中有而父类中没有的方法，需要进行强制类型转换，如上面的例子中，将 p 转换为子类 Child 类型的引用。因为当用父类的引用指向子类的对象，用父类引用调用方法时，找不到父类中不存在的方法。这时候需要进行向下的类型转换，将父类引用转换为子类引用。

2、抽象关键字abstract为什么不能和static、private、final共存？

(1) 区别：private 是私有的意思，当它修饰方法的时候，子类是不能够继承父类私有方法的，但是 abstract 修饰的方法必须要被子类继承并且实现，所以两者冲突。

static 是静态的意思，所谓静态就是被共享，而当它修饰方法的时候就是静态方法，静态方法是不用创建对象就可以调用的，当在有继承关系的时候，abstract 修饰的是抽象，不可以被实例化，抽象方法必须由子类去实现，所以和static 冲突了。

final 是最终的意思，也就是不能被继承或者重写，而 abstract 修饰的方法必须要由子类重写，所以也是冲突的。

所以 abstract 只能和public 以及 protected 一起使用。

(2) Static：A) 静态变量，被 static 修饰的变量类似一个全局变量(Java 中没有此概念)。当这个类被虚拟机第一次加载的时候，就会为该变量分配内存空间。当该类创建实例时，并不会生成对 static 变量的拷贝。而是多个该类的实例共享使用该变量。所有该类的对象都可以操作这块存储空间。如果用 final 修饰就另当别论了。创建完成后就需要进行初始化，定义时可以直接初始化。如果需要通过计算来初始化你的 static 变量，可以声明一个 static 块，Static 块仅在该类被加载时执行一次，且在类被第一次装载时。

注意：static 定义的变量初始化会优先于任何其它非 static 变量，不论顺序如何。

在涉及到继承的时候，会先初始化父类的 static 变量，然后是子类的，依次类推。可以使用”类名.变量名“直接使用，并且被该类所有实例化对象共享。可以被类中所有方法使用(static 与非 static)。该类中某一个对象修改了变量的值，其他所有该类对象中的对应值都会随之改变，定义时初始化，或者通过静态代码块初始化。

B) 静态方法，被 static修饰的方法我们称之为类方法。可以通过类直接调用该方法，而没必要创建该类的实例后调用该方法。

注意:可以使用”类名.方法名“直接使用。只能调用其他Static 方法。只能使用 static 成员变量。不能以任何形式引用 this 和 super

用途：静态方法常常为应用程序中的其它类提供一些实用工具，在 Java 的类库中大量的静态方法正是出于此目的而定义的。Arrays 和 Collections。

C) 静态类，通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。

补充：static 表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态 static 代码块，但是 Java 语言中没有全局变量的概念。被 static 修饰的成员变量和成员方法独立于该类的任何对象。它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java 虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static 对象可以在它的任何对象创建之前访问，无需引用任何对象。

用 public 修饰的static 成员变量和成员方法本质是全局变量和全局方法，当声明这个类的对象时，不生成 static 变量的副本，而是类的所有实例共享同一个 static 变量。

static 变量前可以有private 修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用，但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private 是访问权限限定，static 表示不要实例化就可以使用，这样就容易理解多了。static 前面加上其它访问权限关键字的效果也以此类推。

static 修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为: 类名.静态方法名(参数列表...)；类名.静态变量名。用static 修饰的代码块表示静态代码块，当 Java 虚拟机(JVM)加载类时,就会执行该代码块。

static 变量：按照是否静态对类成员变量进行分类可分两种：一种是被static 修饰的变量，叫静态变量或类变量；另一种是没有被 static 修饰的变量，叫实例变量。两者的区别是: 对于静态变量在内存中只有一个拷贝(节省内存)，JVM 只为静态分配一次内存, 在加载类的过程中完成静态变量的内存分配，可用类名直接访问(方便)，当然也可以通过对象来访问(但是这是不推荐的)。对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响(灵活)。

static 方法：静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用 this 和 super 关键字，不能直接访问所属类的实例变量和实例方法 (就是不带 static 的成员变量和成员成员方法)。

（3）final 特点：A) 用 final 修饰的变量表示常量，只能被赋一次值，不能修改。final 修饰的基本类型变量：值不能被修改。final 修饰的引用类型变量(对象)：对象地址不能被修改，对象内部的成员可以被修改。被定义为 final 的对象引用只能指向唯一一个对象，不可以将它再指向其他对象，但是一个对象内部的值却是可以改变的。被 final 修饰的变量是一个常量，必须被赋值后才能使用。可以在定义时赋值，也可在构造方法中赋值。(只要在构造方法结束前给赋值就可以。)

B) 用 final 修饰的方法不能被子类的方法覆盖；

C) 用 final 修饰的类不能被继承，没有子类。final 类不能被继承，因此final 类的成员方法没有机会被覆盖，默认都是 final 的。但是 final 类中的成员变量可以被定义为 final 或非 final 形式。在设计类时,如果类不需要有子类，类的实现细节不允许改变，那么就设计为 final 类。

D) final 不能用来修饰构造方法。

（4）static 和 final：static、final 用来修饰成员变量和成员方法。对于变量，表示一旦给值就不可修改，并且通过类名可以访问。对于方法，表示不可覆盖，并且可以通过类名直接访问。 

3、接口与抽象类有什么区别？

（1）抽象类：含有abstract 修饰符的 class 即为抽象类，abstract类不能创建的实例对象。含有 abstract 方法的类必须定义为 abstract class，abstract class 类中的方法不必都是抽象的。abstract class 类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为 abstract 类型。

（2）接口：可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为 public abstract 类型，接口中的成员变量类型默认为 public static final。

（3）区别：

   a) 抽象类可以有构造方法，接口中不能有构造方法。

   b) 抽象类中可以有普通成员变量，接口中没有普通成员变量。

   c) 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

   d) 抽象类中的抽象方法的访问类型可以是 public，protected，但接口中的抽象方法只能是 public 类型的，并且默认即为 public   abstract 类型。

   e) 抽象类中可以包含静态方法，接口中不能包含静态方法。

   f) 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是 public static final 类型，并且默认即为 public static final 类型。

   g) 一个类可以实现多个接口，但只能继承一个抽象类。
4、重载和重写有什么区别？

（1）重载 Overload 表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同(即参数个数或类型不同)。

条件：A) 方法名必须相同；

          B) 参数列表不同，参数列表不同又分为：参数列表的个数不同；参数列表的排列顺序不同；参数列表的数据类型不同。

必须同时满足条件 A 和 B 才叫方法的重载。

注意：在使用重载时只能通过不同的参数样式，不能通过访问权限、返回类型、抛出的异常进行重载。

（2）重写 Override 表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中定义的方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是 private 类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

在覆盖要注意以下的几点：

A) 覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

B) 覆盖的方法的返回值必须和被覆盖的方法的返回一致；

C) 覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

D) 被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

5、静态内部类的作用

（1）静态内部类，就是定义在外部类的成员位置上，之所以用静态修饰，就是因为内部类中都是共享数据，没有特有数据，定义成静态的，就可以直接用类名访问，不用在堆内存中创建对象，比较节省空间。

（2）在进行代码程序测试的时候，如果在每一个 Java 源文件中都设置一个主方法，会出现很多额外的代码。而且最主要的是这段主程序的代码对于 Java 文件来说，只是一个形式，其本身并不需要这种主方法，但是该主方法又必不可少。在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个 Java 源文件都设置一个类似的主方法。这对于代码测试是非常有用的，在一些中大型的应用程序开发中，是一个常用的技术手段。

6、匿名内部类

匿名内部类：没有名字的内部类是一个匿名子类对象。

定义前提：内部类必须继承一个类或者实现接口。

定义的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

使用场景：当函数的参数是接口类型引用时，如果接口中的方法不超过3 个，可以通过匿名内部类来完成参数的传递。在创建匿名内部类时，该类中封装的方法不要过多，最好两个或者两个以内。

new Object(){
    void show(){
    }
    System.out.println("show run");
}.show();

Object obj = new Object(){
    void show(){
    }
    System.out.println("show run");
};
obj.show();

区别：第一个可是编译通过，并运行。

第二个编译失败，因为匿名内部类是一个子类对象，当用 Object 的 obj 引用指向时，就被提升为了 Object 类型，而编译时会检查 Object 类中是否有 show 方法，所以编译失败。

7、构造代码块和构造函数的区别

（1）作用：构造函数是给特定的对象进行初始化的；构造代码块是对所有对象初始化。

（2）格式：构造函数是：类名{}；构造代码块：{}。

（3）执行顺序：静态代码块------->构造代码块------->构造函数。

8、普通代码块、静态代码块、构造代码块的区别

（1）普通代码块：在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序一样，由他们在代码中出现的次序决定--“先出现先执行”。

public class CodeBlock{
    public static void main(String[] args){
        {
            int x = 3;
            System.out.println("普通代码块内的变量 x = "+ x);
        }
        int x = 1;
        System.out.println("主方法内的变量 x = " + x);
        {
            int y=7;
            System.out.println("普通代码块内的变量 y="+y);
        }
    }
}

（2）构造代码块：直接在类中定义且没有加 static 关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

public class CodeBlock{
    {
        System.out.println("第一代码块");
    }

    public CodeBlock(){
        System.out.println("构造方法");
    }

    {
        System.out.println("第二构造块");
    }

    public static void main(String[] args){
        new CodeBlock();
        new CodeBlock();
    }
}

（3）静态代码块：在 java 中使用static 关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM 在加载类时会执行静态代码块，所以静态代码块先于主方法执行。

如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。

注意：A）静态代码块不能存在于任何方法体内。

          B）静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。

class Code{
    {
        System.out.println("Code 的构造块");
    }

    static{
        System.out.println("Code 的静态代码块");
    }

    public Code(){
        System.out.println("Code 的构造方法");
    }
}

public class CodeBlock{
    {
        System.out.println("CodeBlock 的构造块");
    }

    static{
        System.out.println("CodeBlock 的静态代码块");
    }

    public CodeBlock(){
        System.out.println("CodeBlock 的构造方法");
    }

    public static void main(String[] args){
        System.out.println("CodeBlock 的主方法");
        new Code();
        new Code();
        new CodeBlock();
        new CodeBlock();
    }
}

9、子类实例化的初始化过程

在继承关系初始化顺序如下：父类静态(静态代码块和静态成员：按代码书写先后顺序执行)---->子类静态(同父类)---->父类非静态(变

量隐式初始化---->变量显示初始化)---->父类构造(构造代码块---->构造函数)---->子类非静态(同父类)---->子类构造(同父类)。