Java中的父与子

前记

不就是子类继承父类？这有何难？

结果做题被啪啪打脸 Σ(っ °Д °;)っ，父子关系属实需要梳理一下！

好好总结，之后再遇到Java父子也不怕！

正文

1.继承

Java最重要的三个特性：封装、继承、多态。笔者认为假如没有继承，多态也无从谈起，所以先说说继承吧┗|｀O′|┛

1.1概念

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

• 通过继承创建的新类称为“子类”或“派生类”。
• 被继承的类称为“基类”、“父类”或“超类”。

子类拥有父类所有属性和方法（包括父类私有成员、私有方法），
但是不一定能直接访问所有属性或使用所有方法（父类私有）
举例：
Father.java

public class Father {
    private int id = 10;
    public int getId(){
        return id;
    }
}

Son.java

public class Son extends Father{
}

Main.java

public class Main {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.getId());  //打印10
    }
}

子类可以通过非私有方法访问到所拥有的的父类私有成员，但是不能以“对象.id”的形式直接访问（私有方法类似）

Java中四种修饰符（public、protected、default、private）

修饰符	特点
public	可以在同一个工程中任何地方被访问
protected	当前类，同一个包下的类和不同包下的子类可以访问
default（缺省）	只能被同一个包下的类访问
private	只有当前类可以访问，是封装性的体现

• 四种修饰符都可以修饰类的内部结构：构造器、成员变量、方法
• 只有public和default可以修饰类

1.2 初始化

在继承中，代码执行顺序如下：

1. 父类静态变量，父类静态代码块
2. 子类静态变量，子类静态代码块
3. 父类非静态对象，父类非静态代码块
4. 父类构造函数
5. 子类非静态对象，子类非静态代码块
6. 子类构造函数

外部类的加载或者实例对象的创建 都不会加载其普通内部类或者静态内部类
而访问外部类的静态内部类时，只会加载静态内部类，不会加载外部类

注意静态代码块和静态内部类的区别
分清三种内部类

static关键字的作用

Java中各代码块的执行顺序

举例：
Father.java

public class Father {
    public Father(){
        System.out.println("father create");
    }
    static {
        System.out.println("father");
    }
}

Son.java

public class Son extends Father{
    public Son(){
        System.out.println("son create");
    }
    static {
        System.out.println("son");
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        Son son = new Son();
    }
}

控制台打印结果

father
son
father create
son create

实例化子类对象时，会先隐式调用父类构造器方法得到父类对象，再初始化子类特有属性与之合起来成为一个子类对象

1.3 特点

Java中一个子类只能直接继承一个父类（单继承），可以实现多个接口。
不过也可以通过父类再继承祖父类间接继承多个类

• 好处：提高代码复用性和可扩展性，减少代码冗余
• 坏处：提高类之间耦合性，代码独立性变差

2. 多态

2.1 概念

“父类引用指向子类对象”，多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
多态的特点是“动态绑定”，即编译期间无法确定实际运行的情况，运行期间java虚拟机会根据实际创建的对象类型决定使用哪个方法。

2.2 实现

实现多态的做法：

1. 子类重写父类中的方法，一个父类有多个不同的子类，每个子类对于同一父类方法可能有不同的实现
2. 把父类作为参数类型，将父类及其子类对象作为参数传入
3. 运行时，根据实际传入参数的对象类型动态决定使用哪个方法

举例：
Animal.java

public class Animal {
    public int id = 1;
    public static String name = "animal";
    public Animal(){
        speak();
    }
    public void speak(){
        System.out.println("animal speak");
    }
    public static void see(){
        System.out.println("animal see");
    }
}

Dog.java

public class Dog extends Animal{
    public int id = 2;
    static String name = "dog";
    public void speak(){
        System.out.println("dog speak");
    }
    public static void see(){
        System.out.println("dog see");
    }
}

Cat.java

public class Cat extends Animal{
    public int id = 3;
    static String name = "cat";
    public void speak(){
        System.out.println("cat speak");
    }
    public static void see(){
        System.out.println("cat see");
    }
}

主程序

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();  //由于隐式调用Animal的空参构造器方法，打印cat speak
        func(animal);
    }
    public static void func(Animal animal){
        animal.speak(); //打印cat speak  （非静态方法看子）
        animal.see(); //打印 animal see （静态方法看父）
        System.out.println(animal.id); // 打印1 （成员变量看父）
        System.out.println(animal.name); // 打印animal （成员变量看父）
    }
}

注意：
“编译看左，运行看右”：成员变量、静态方法和父类一致（编译期间就已经确定）；非静态方法在编译期间和父类一致，但运行期间和子类一致。

• 实例化子类对象时，如果父类构造器方法中调用了自己被子类重写过的同名方法，则会调用对应子类重写的方法，而不会执行自己原来的方法。（但此时子类对象未初始化，所有属性值均为null）

2.3 例题

例题1