Java继承

继承是面向对象的三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

继承的格式

• 格式：public class 子类名 extends 父类名{ }
• 范例：public class Zi extends Fu{ }
• Fu：是父类，也被称为基类、超类
• Zi：是子类，也被称为派生类

继承中子类的特点：

• 子类可以有父类的内容
• 子类还可以有自己特有的内容

eg：

package Java;

public class Fu {
    public void show(){
        System.out.println("show方法被调用");
    }
}

package Java;

public class Zi {
    public void method(){
        System.out.println("method方法被调用");
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Fu f=new Fu();
        f.show();

        Zi z=new Zi();
        z.method();
    }
}

终端：
show方法被调用
method方法被调用

eg:

package Java;

public class Fu {
    public void show(){
        System.out.println("show方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public void method(){
        System.out.println("method方法被调用");
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Fu f=new Fu();
        f.show();

        Zi z=new Zi();
        z.method();
        z.show();
    }
}

终端：
show方法被调用
method方法被调用
show方法被调用

继承的好处和弊端
继承好处

• 提高了代码的复用性（多个类相同的成员可以放到同一个类中）
• 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

继承弊端

• 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候使用继承？

• 继承体现的关系：is a
• 假设法：我有两个类A和B，如果他们满足A是B的一种，或是B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承
• 举例：苹果和水果，猫和动物，猫和狗

继承中变量的访问特点
在子类方法中访问一个变量

• 子类局部范围找
• 子类成员范围找
• 父类成员范围找
• 如果都没有就报错（不考虑父亲的父亲。。。）

eg：

package Java;

public class Fu {
    //年龄
    public int age=40;
    
}

package Java;

public class Zi extends Fu{
    //身高
    public int height=175;
    public void show(){
        System.out.println(age);
        System.out.println(height);
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.show();
    }
}

终端：
40
175

eg：

package Java;

public class Fu {
    //年龄
    public int age=40;
    
}

package Java;

public class Zi extends Fu{
    //身高
    public int height=175;
    //年龄
    public int age=20;
    public void show(){
        System.out.println(age);
        System.out.println(height);
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.show();
    }
}

终端：
20
175

eg：

package Java;

public class Fu {
    //年龄
    public int age=40;
    
}

package Java;

public class Zi extends Fu{
    //身高
    public int height=175;
    //年龄
    public int age=20;
    public void show(){
        int age=30;
        System.out.println(age);
        System.out.println(height);
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.show();
    }
}

终端：
30
175

super
super关键字的用法和this关键字的用法相似

• this：代表本类对象
• super：代表父类存储空间的标识（可以理解为父类对象引用）

eg：

package Java;

public class Fu {
    public int age=40;
    
}

package Java;

public class Zi extends Fu{

    public int age=20;
    public void show(){
        int age=30;
        System.out.println(age);
        //我要访问本类的成员变量age
        System.out.println(this.age);
        //我要访问父类的成员变量age
        System.out.println(super.age);
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.show();
    }
}

终端：
30
20
40

继承中构造方法的访问特点
子类中所有的构造方法默认都会访问父类中无参的构造方法
为什么呢？

• 因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
• 每一个子类构造方法的第一条语句默认都是：super()

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

• 通过使用super关键字去显示的调用父类的带参构造方法
• 在父类中自己提供一个无参构造方法

推荐：自己给出无参构造方法

eg：

package Java;

public class Fu {
    public Fu(){
        System.out.println("Fu中无参构造方法被调用");
    }
    public Fu(int age){
        System.out.println("Fu中带参构造方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public Zi(){
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        System.out.println("Zi中带参构造方法被调用");
    } 
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
    }
}

终端：
Fu中无参构造方法被调用
Zi中无参构造方法被调用

eg：

package Java;

public class Fu {
    public Fu(){
        System.out.println("Fu中无参构造方法被调用");
    }
    public Fu(int age){
        System.out.println("Fu中带参构造方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public Zi(){
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        System.out.println("Zi中带参构造方法被调用");
    }
    
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        Zi z2=new Zi(20);
    }
}

终端：
Fu中无参构造方法被调用
Zi中无参构造方法被调用
Fu中无参构造方法被调用
Zi中带参构造方法被调用

eg:

package Java;

public class Fu {
    public Fu(int age){
        System.out.println("Fu中带参构造方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public Zi(){
        super(20);
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        super(20);
        System.out.println("Zi中带参构造方法被调用");
    }   
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        Zi z2=new Zi(20);
    }
}

终端：
Fu中带参构造方法被调用
Zi中无参构造方法被调用
Fu中带参构造方法被调用
Zi中带参构造方法被调用

继承中成员方法的访问特点
通过子类对象访问一个方法

• 子类成员范围找
• 父类成员范围找
• 如果都没有就报错（不考虑父亲的父亲。。。）

eg：

package Java;

public class Fu {
    public void show(){
        System.out.println("Fu中show方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public void method() {        
        System.out.println("Zi中method()方法被调用");
    }  
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

终端：
Zi中method()方法被调用
Fu中show方法被调用

package Java;

public class Fu {
    public void show(){
        System.out.println("Fu中show方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public void method() {        
        System.out.println("Zi中method()方法被调用");
    }  
    public void show(){
        System.out.println("Zi中show方法被调用");
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

终端：
Zi中method()方法被调用
Zi中show方法被调用

eg：

package Java;

public class Fu {
    public void show(){
        System.out.println("Fu中show方法被调用");
    }
}

package Java;

public class Zi extends Fu{
    public void method() {        
        System.out.println("Zi中method()方法被调用");
    }  
    public void show(){
        super.show();
        System.out.println("Zi中show方法被调用");
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

终端：
Zi中method()方法被调用
Fu中show方法被调用
Zi中show方法被调用

方法重写
方法重写概述：

• 子类中出现了和父类一模一样的方法声明

方法重写的应用：

• 当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

@Override

• 是一个注解
• 可以帮助我们检查重写方法的方法声明的正确性

eg：

package Java.item;
/*
手机类
*/
public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

package Java.item;
/*测试类*/
public class PhoneDemo {
    public static void main(String[] args){
        //创建对象，调用方法
        Phone p=new Phone();
        p.call("落拓");
    }
}

终端：
给落拓打电话

eg：

package Java.item;
/*
手机类
*/
public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

package Java.item;
/*新手机*/
public class NewPhone extends Phone{
    public void call(String name){
        System.out.println("开启视频功能");
        System.out.println("给"+name+"打电话");
    }
}

package Java.item;
/*测试类*/
public class PhoneDemo {
    public static void main(String[] args){
        //创建对象，调用方法
        Phone p=new Phone();
        p.call("落拓");
        System.out.println("------");

        NewPhone np=new NewPhone();
        np.call("鱼皮");
    }
}

终端：
给落拓打电话
------
开启视频功能
给鱼皮打电话

eg：

package Java.item;
/*
手机类
*/
public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

package Java.item;
/*新手机*/
public class NewPhone extends Phone{
    public void call(String name){
        System.out.println("开启视频功能");
    //    System.out.println("给"+name+"打电话");
        super.call(name);
    }
}

package Java.item;
/*测试类*/
public class PhoneDemo {
    public static void main(String[] args){
        //创建对象，调用方法
        Phone p=new Phone();
        p.call("落拓");
        System.out.println("------");

        NewPhone np=new NewPhone();
        np.call("鱼皮");
    }
}

终端：
给落拓打电话
------
开启视频功能
给鱼皮打电话

方法重写的注意事项

• 私有方法不能被重写（父类私有成员子类是不能继承的）
• 子类方法访问权限不能更低（public>默认>私有）

Java中继承的注意事项

• Java中类只支持单继承，不支持多继承
• Java中类支持多层继承

案例：老师和学生
需求：定义老师类和学生类，然后写代码测试，最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试

package Java;

public class Person {
    private String name;
    private int age;

    public Person(){   
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}

package Java;

public class Teacher extends Person{
    public Teacher(){
    }
    
    public Teacher(String name,int age){
        super(name, age);
    }

    public void teach(){
        System.out.println("用爱成就每一位学员");
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        //创建老师类对象并进行测试
        Teacher t1=new Teacher();
        t1.setName("鱼皮");
        t1.setAge(23);
        System.out.println(t1.getName()+","+t1.getAge());
        t1.teach();

        Teacher t2=new Teacher("落拓", 29);
        System.out.println(t2.getName()+","+t2.getAge());
        t2.teach();
    }
}

终端：
鱼皮,23
用爱成就每一位学员
落拓,29
用爱成就每一位学员

案例：猫和狗
需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试

package Java;

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

    public Animal(){
    }

    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}

package Java;

public class Cat extends Animal{
    public Cat(){
    }

    public Cat(String name,int age){
        super(name,age);
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

package Java;

public class Dog extends Animal{
    public Dog(){
    }

    public Dog(String name,int age){
        super(name, age);
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

package Java;
/*
测试类*/
public class AnimalDemo {
    public static void main(String[] args){
        //创建猫类对象并进行测试
        Cat c1=new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println(c1.getName()+","+c1.getAge());
        c1.catchMouse();

        Cat c2=new Cat("加菲猫",5);
        System.out.println(c2.getName()+","+c2.getAge());
        c1.catchMouse();
    }
}

终端：
加菲猫,5
猫抓老鼠
加菲猫,5
猫抓老鼠