继承与多态（上）

一、继承

1.为什需要继承，继承的作用是什么？

​
class Dog{
    String name;
    int age;
    int weight;
    void show() {
        System.out.println(this.name + "发出叫声");
    }
    void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}
class Bird{
    String name;
    int age;
    int weight;
    void show(){
        System.out.println(this.name+"发出叫声");
    }
    void fly(){
        System.out.println(this.name+"飞起来了");
    }
}

​

可以看到，上面两个类有许多相同的成员变量和成员方法，这是它们的共性，为了提高代码的简洁性，我们可以把这些共性抽取出来，因此java提出了继承的概念，专门用来进行共性的抽取，实现代码的复用。 

2.继承的概念

继承是面向对象程序设计使代码可以复用的最重要的手段它 允许程序员在保持原有类特性的基础上进行扩展，增加新功能 ，这样产生新的类，称 派生类 。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是： 共性的抽取，实现代码复用 。

上述图片中，Dog和Bird类保留类父类的特性，并且增加了自己的特性，这就是继承，继承之后，子类可以使用父类的成员方法/成员变量/构造方法。

3.继承的语法

Java中是通过extends关键字来实现继承的，即

修饰符 class 子类 extends 父类{
//......
}

我们再对上面Dog和Bird类实现继承，使他们继承同一个类Animal

public class Test{
    public static void main(String[]args){

    }
}



class Animal{
    String name;
    int age;
    int weight;
    void show() {
        System.out.println(this.name + "发出叫声");
    }
}

class Dog extends Animal{
    public Dog(String name,int age,int weight) {
        this.name=name;
        this.age=age;
        this.weight=weight;
    }//Dog类具有Animal类的属性和方法
    void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}
class Bird extends Animal{
    void fly(){
        System.out.println(this.name+"飞起来了");
    }
}

！！！：

<1>父类的成员变量或成员方法会继承到子类中

<2>子类必须有特有的成员变量或成员方法，否则没有必要使用继承

4.父类成员的访问

4.1.子类中访问父类的成员变量

4.1.1.子类和父类不存在同名成员变量

public class Test{
    public static void main(String[]args){
       B b=new B();
       b.show();
    }
}
class A{
    int a=1;
    int b=2;
}
class B extends A{
    int c=3;
    public void show(){
        System.out.println(this.a+" "+this.b+" "+this.c);
    }
}//输出结果：1 2 3 ，此时a和b访问的时父类的成员变量a，b；c访问的时本类成员变量c

4.1.2.子类和父类存在同名成员变量 

public class Test{
    public static void main(String[]args){
       B b=new B();
       b.show();
    }
}
class A{
    int a=1;
    int b=2;
}
class B extends A{
    int b=3;
    public void show(){
        System.out.println(this.a+" "+this.b);
    }
}//输出结果：1 3 ，此时a访问的时父类的成员变量a；b访问的时本类成员变量b

因此我们得出:

在子类方法中 或者 通过子类对象访问成员时 ：

如果访问的成员变量子类中有，优先访问自己的成员变量。

如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

如果访问的成员变量与父类中成员变量同名，则优先访问自己的

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找

4.2.子类中访问父类的成员方法

4.2.1.子类和父类不存在同名成员方法

public class Test{
    public static void main(String[]args){
       B b=new B();
       b.showA();//访问A的show方法
       b.showB();//访问B的show方法
    }
}
class A{
   
    public void showA(){
        System.out.println("哈哈哈");
    }
}
class B extends A{
   
    public void showB(){
        System.out.println("呵呵");
    }
}

4.2.2.子类和父类存在同名成员方法

public class Test{
    public static void main(String[]args){
       B b=new B();
       b.func(1,2);//访问A的func
       b.func(1);//访问B的func
       b.show();//访问B的show方法

    }
}
class A{
    int a;
    int b;
    public void show(){
        System.out.println("哈哈哈");
    }
    public void func(int a,int b){
        System.out.println(a+b);
    }
}
class B extends A{

    public void show(){
        System.out.println("呵呵");
    }
    public void func(int a){
        System.out.println(a);
    }
}

因此，我们得出：

   通过子类对象访问父类与子类中 不同名方法时，优先在子类中找 ，找到则访问，否则在父类中找，找到则访问，否则编译报错。

   通过派生类对象访问父类与子类同名方法时，如果 父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访访问 ，如果没有则报错。（重载不一定发生再同一个类中，在不同类中也是可以发生的）

5.super关键字

对于上面子类和父类的成员变量/方法相同时，我们要想访问父类的成员变量/方法，就需要借助super关键字进行访问，它的作用是在子类中访问父类的成员变量或成员方法。

5.1.通过super调用父类的成员变量和普通方法

public class Base {
    int a;
    int b;
    public void methodA(){
        System.out.println("Base中的methodA()");
    }
    public void methodB(){
        System.out.println("Base中的methodB()");
    }
}
public class Derived extends Base {
    int a; // 与父类中成员变量同名且类型相同
    char b; // 与父类中成员变量同名但类型不同

    // 与父类中methodA()构成重载
    public void methodA(int a) {
        System.out.println("Derived中的method()方法");
    }

    // 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
    public void methodB() {
        System.out.println("Derived中的methodB()方法");
    }

    public void methodC() {
// 对于同名的成员变量，直接访问时，访问的都是子类的
        a = 100; // 等价于： this.a = 100;
        b = 101; // 等价于： this.b = 101;
// 注意：this是当前对象的引用
// 访问父类的成员变量时，需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分
        super.a = 200;
        super.b = 201;
// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
        methodA(); // 没有传参，访问父类中的methodA()
        methodA(20); // 传递int参数，访问子类中的methodA(int)
// 如果在子类中要访问重写的基类方法，则需要借助super关键字
        methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
        super.methodB();//访问基类的methodB
    }
}

 5.2.通过super调用父类的构造方法

看下一个知识点：子类构造方法

6.子类构造方法

子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法 。

public class Test{
    public static void main(String[] name){
        Dog dog=new Dog("狗",18,234);
       
    }
}
class Animal{
    String name;
    int age;
    //!!!父类一旦写了构造方法，那么子类就必须先实现父类的构造方法，否则报错
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类构造方法");
    }
}
class Dog extends Animal{
    int weight;

    public Dog(String name, int age, int weight) {
        super(name, age);//实现父类构造方法
        //super关键字必须是子类构造方法的第一条语句
        this.weight = weight;
        System.out.println("子类构造方法");
    }

    void bark(){
        System.out.println("汪汪叫");
    }
}
//打印结果：
//父类构造方法
//子类构造方法

！！！构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行 默认有隐含的super()调用 ，即调用基类构造方法

2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

3. 在子类构造方法中， super(...) 调用父类构造时， 必须是子类构造函数中第一条语句 。

4. super(...) 只能在子类构造方法中出现一次，并且 不能和this同时出现 。

5.与this一样，不能在静态方法或静态代码块中使用super关键字

7.再谈初始化（不明白可看上一篇《类和对象详解》）

public class Test{
    public static void main(String[] name){
       Dog dog=new Dog();
       System.out.println("==========");
       Dog dog2=new Dog();
    }
}
class Animal{
    static{
        System.out.println("Animal的静态");
    }

    {
        System.out.println("Animal的实例");
    }
    public Animal(){
        System.out.println("Animal的构造");
    }
}
class Dog extends Animal{
    static{
        System.out.println("Dog的静态");
    }
    {
        System.out.println("Dog的实例");
    }
    public Dog(){
        System.out.println("Dog的构造");
    }
}
//执行结果
//Animal的静态
//Dog的静态
//Animal的实例
//Animal的构造
//Dog的实例
//Dog的构造
//==========
//Animal的实例
//Animal的构造
//Dog的实例
//Dog的构造

说明：

1. 静态代码块先执行，并且 只执行一次 ，在类 加载阶段执行

2. 当有对象创建时，才会执行实例代码块， 实例代码块执行完成后，最后构造方法执行

3.父类静态代码块优先于子类静态代码块执行，且是最早执行

4.父类实例代码块和父类构造方法紧接着执行

5.子类的实例代码块和子类构造方法紧接着再执行

6.第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

8.继承方式

9.final关键字

9.1.final修饰修饰变量/字段

final修饰的变量相当于常量，不能被改变。

9.2. final修饰类

final修饰的类不能被继承。

9.3.final修饰成员方法

final修饰的成员方法不能被重写（后面了解）

 

10.继承与组合

和继承类似 , 组合也是一种表达类之间关系的方式 , 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法

( 诸如 extends 这样的关键字 ), 仅仅是将一个类的实例作为另外一个类的字段。

继承表示对象之间是 is-a 的关系 ，比如：狗是动物，猫是动物

组合表示对象之间是 has-a 的关系 ，比如：汽车

汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。

// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{
private Tire tire; // 可以复用轮胎中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
// 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}