java学习笔记（十五）继承

继承

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。[1] Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

在java中用extends关键字实现类与类之间的继承
格式：
        class 子类名 extends 父类名 {

        } 

        父类：基类，超类
        子类：派生类

继承的好处：

    A:提高了代码的复用性
        多个类相同的成员可以放到同一个类中
    B:提高了代码的维护性
        如果功能的代码需要修改，修改一处即可
    C:让类与类之间产生了关系，是多态的前提

继承的特点：

    A:Java只支持单继承，不支持多继承。
    B:Java支持多层(重)继承(继承体系)。

方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：

1.必须存在继承关系
2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能

怎么去访问父亲的成员呢?
java就提供了一个关键字：super

super:
    super代表父类存储空间的标识(可以理解为父类对象)

this和super的使用区别?
    A:成员变量
        this.成员变量   本类的成员变量
        super.成员变量  父类的成员变量
    B:成员方法
        this.成员方法() 本类的成员方法
        super.成员方法()父类的成员方法 

继承间构造方法的关系：

    子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())
为什么呢?
    因为子类会继承父类中的数据，可能还会使用父类的数据。
    所以，子类初始化之前，一定要先完成父类数据的初始化。
    每个子类的构造方法的第一行，有一条默认的语句:
        super();

    注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。

假如父类没有无参构造方法,该怎么办呢?
    A:调用父类的其他构造方法。带参构造。
        怎么访问呢?
            super(...)

注意：
    super(…)或者this(….)必须出现在第一条语句上。
    因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。

建议：
    永远给出无参构造方法。

练习：猫狗案例继承版
猫：
成员变量：type,name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx()
show()
狗：
成员变量：type,name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx()
show()

提取出动物类，完成代码，并测试。
代码如下：
Animal.java

public class Animal {
    private String type;
    private int age;
    private String name;

    public Animal(){}
    public Animal(String name,String type,int age){
        this.name = name;
        this.type = type;
        this.age = age;
    }

    public void setType(String type){
        this.type = type;
    }
    public String getType(){
        return type;
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age  =age;
    }
    public int getAge(){
        return age;
    }

    //吃饭的方法
    public void eat(){
        System.out.println("动物喜欢吃粮食");
    }

}

Dog.java

public class Dog extends Animal{
    //有参数和无参数的构造方法
    public Dog(){}
    public Dog(String name,String type,int age){
        setAge(age);
        setName(name);
        setType(type);
    }

    //狗喜欢吃肉
    public void eat(){
        System.out.println("狗喜欢吃肉");
    }

}

Cat.java

public class Cat extends Animal{
    public Cat(){}
    public Cat(String name,String type,int age){
        setAge(age);
        setName(name);
        setType(type);
    }

    //猫喜欢吃鱼
    public void eat(){
        System.out.println("猫咪喜欢吃鱼");
    }

}

Test.java

public class Test {
    public static void main(String[] args) {
        //创建对象
        Dog d = new Dog();
        d.eat();

        System.out.println("------------");
        Cat c = new Cat("bob", "波斯猫", 2);
        c.eat();
        System.out.println(c.getAge()+"  "+c.getName()+"  "+c.getType());

    }

}

多态

多态：同一个对象,在不同时刻表现出来的不同状态。

举例：
    A:猫
        猫是猫
        猫是动物
    B:水
        水(液态)
        冰(固态)
        水蒸气(气态)

多态的前提：
    A:有继承关系 
    B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）    
    C:有父类引用指向子类对象

        Fu f = new Fu();

        左边：Fu类型的引用
        右边：Fu类型的对象

        Zi z = new Zi();

        Fu f = new Zi();    

成员访问特点

    A:成员变量
        编译看左边,运行看左边
    B:构造方法
        子类构造默认访问父类的无参构造
    C:成员方法（重点理解）
        编译看左边,运行看右边

        为什么变量和方法不一样呢?
            方法重写。
    D:静态成员方法
        编译看左边,运行看左边
        因为静态的内容是和类相关的，与对象无关。

练习：

class Fu {
    public void show() {
        System.out.println("fu show");
    }
}

class Zi extends Fu {
    public void show() {
        System.out.println("zi show");
    }

    public void method() {
        System.out.println("zi method");
    }
}

class DuoTaiTest {
    public static void main(String[] args) {
        Fu f = new Zi();
        f.method();
        f.show();
    }
}