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();    }}