JavaSE学习之--继承和多态（二）-阿里云开发者社区

JavaSE学习之--继承和多态（一）+https://developer.aliyun.com/article/1413489

5.再谈初始化

先回顾一下静态代码块，实例代码块，构造方法之间执行的先后顺序！

class Test {
    int a;
    // 构造方法
    public Test() {
        System.out.println("这是构造方法！！！");
    }
    // 静态块
    static {
        System.out.println("这是静态代码块！！！");
    }
    // 实例代码块
    {
        System.out.println("这是实例代码块！！！");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Test test1 = new Test();
        System.out.println("=============");
        Test test2= new Test();
    }
}

执行结果：

总结：执行顺序-->静态代码块-->实例代码块-->构造方法

且静态代码块只会被执行一次

那如果既有父类的代码块和构造方法，又有子类的代码块和构造方法，执行顺序是怎样的呢？

先看代码：

class Test {
    int a;
    // 父类的构造方法
    public Test() {
        System.out.println("这是构造方法！！！");
    }
    // 父类的静态块
    static {
        System.out.println("这是静态代码块！！！");
    }
    // 父类的实例代码块
    {
        System.out.println("这是实例代码块！！！");
    }
}
class DTest extends Test {
    // 子类的构造方法
    public DTest() {
        System.out.println("这是子类的构造方法！！！");
    }
    // 子类的静态代码块
    static {
        System.out.println("这是子类的静态代码块！！！");
    }
    // 子类的代码块
    {
        System.out.println("这是子类的代码块！！！");
    }
}
public class Test1 {
    public static void main(String[] args) {
        DTest test1 = new DTest();
        System.out.println("=============");
        DTest test2= new DTest();
    }
}

执行结果：

执行顺序：

1.父类，子类的静态代码块

2.父类实例代码块，构造方法

3.子类的实例代码块，构造方法

所有的静态代码块无论实例化多少个对象都只会被执行一次！！！

6.protected关键字

为了实现封装特性，引入了访问修饰限定符，不同的关键字有不同的权限

protected是“受保护的”，它的权限是可以在同包不同类访问，也可以在不同包但是此包的类是另一个包中类的子类，也就是两个包之间的类存在继承关系！

1.同一个包不同类中成员的访问

class B {
    private int a;
    int b;
    protected int c;
    public int d;
}
class C extends B {
    // 同一个包不同类
    public void method() {
        super.a = 20;// err，private成员不能跨类访问
        super.b = 20;// 默认权限的成员可以跨类访问
        super.c = 20;// protected成员可以跨类访问
        super.d = 20;// public成员可以跨类访问
    }
}

2.不同包不同类中成员的访问

class B {
    private int a;
    int b;
    protected int c;
    public int d;
}
// 不同包但存在继承关系之间成员的访问
class C extends B {
    public void method2() {
        super.a = 20;// err private成员不能跨类访问
        super.b = 20;// err 默认权限成员不能跨包访问
        super.c = 20;// protected成员在子类中可以访问
        super.d = 20;// public成员可以跨包访问
    }
}

注意不要忘记引入父类的包：

总结：

1.继承是可以跨包的，如果另一个包中类是另一个包中的类的子类，则存在继承关系；子类会继承父类所有的成员和方法（但是不能全部访问，这取决于父类中成员或方法的访问权限）

2.我们有这么多的权限，那什么时候用什么权限呢？前期学习，大家都会使用一种粗暴的方法，把所有的成员设置为private,所有的方法设置为public,在前期对权限理解不深的时候我们可以这样设置，但使用哪个权限还是要具体问题具体分析，这取决于你对成员或方法的需求！

7.Java中的继承关系（三种）

8.final关键字

final关键字可以修饰变量，方法，类

1.修饰变量会使变量不能被修改（成为常量）

final int b = 20;
        b = 30;// err b是常量，无法修改常量的值

2.修饰类，代表此类无法被继承

final class B {
    private int a;
    int b;
    protected int c;
    public int d;
}
// 此时B就无法被继承
class C extends B {
}

平常我们使用的String类就是被final修饰的

3.修饰方法，此方法无法被重写

9.继承与组合

继承反映的是类与类之间的关系，同样的，组合也是一种反应类与类关系的一种思想！

它代表一个类可以由多个类组成，比如一个Person类可以由Leg,Nose,Head类组成，不同于继承的是组合并没有关键字，只需在类中包含其他类就可以实现类的组合，请看下面代码：

class Nose{};
class Head{};
class Leg{};
class Person{
    private Nose nose;// 可以复用Nose类中的方法和属性
    private Head head;// 可以复用Head类中的方法和属性
    private Leg leg;// 可以复用Leg类中的方法和属性
}
class Stu extends Person{
    // 继承了人的鼻子，头，腿
};

二.多态

多态就是通过父类引用不同对象，调用同一个重写的方法时，所表现的行为不同（所产生的结果不同），这种现象就叫做多态！

要理解多态，需要理解几个基本概念：向上转型，重写，向下转型，动态绑定

1.向上转型

1.向上转型的定义：

父类引用引用子类对象就叫做向上转型（子类对象被父类引用）

class Animal{};
class Dog extends Animal{};
class Cat extends Animal{};
public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
｝

2.实现向上转型的三种方式

1.直接赋值

2.方法传参

3.方法返回

1.直接赋值

Animal animal1 = new Dog();
        Animal animal2 = new Cat();

2.方法传参

将方法形参设置为父类引用，实参是子类对象，通过调用方法实现将父类引用指向子类对象！

class Animal{
    public void makeSound() {
        System.out.println("动物发出叫声！");
    }
};
class Dog extends Animal{
    @Override
    public void makeSound() {
        System.out.println("小狗在汪汪叫！");
    }
};
//class Cat extends Animal{};
public class Test {
    public static void animalMakeSound(Animal animal) {
        animal.makeSound();
    }
    public static void main(String[] args) {
        Animal mydog = new Dog();
        animalMakeSound(mydog);
    }

在main方法中我们创建了一个Dog对象，并将其向上转型为Animal类型，接着在animalMakeSound方法中调用该对象，让父类引用指向该对象，在方法内部实现了向上转型！

通过上述代码我们可以看出，将形参设置为父类引用最大的好处就是增加了代码的通用性！因为实参可以是任意子类对象

JavaSE学习之--继承和多态（三）+https://developer.aliyun.com/article/1413491

JavaSE学习之--继承和多态（二）