JAVA继承

先看以下代码

class Student {
    String name;
    int age;
    void study() {
        System.out.println("good study");
    }
}

class Worker {
    String name;
    int age;
    void work() {
        System.out.println("good work");
    }
}

 

以上代码中，有两个类，各自己含有两个成员变量和一个成员方法。

其中，“String name;int age;”这两个变量，是两个类中所具备的共性的描述。

那么有没有办法，将共性的描述抽取单独封装，又可以让两个类所共用呢？答案当然是肯定的，这就用到JAVA类的一个特性——继承（extends）。

 

使用继承后，只要将学生和工人的共性供述提取出来，单独描述。然后让学生和工人类与这个单独描述的共性类有关系，就可以了。

代码如下：

class People {            //共性描述，即父类、超类、基类
    String name;
    int age;
}
    
class Student extends People{        //子类，继承父类
    void study() {
        System.out.println("good study");
    }
}

class Worker extends People{
    void work() {
        System.out.println("good work");
    }

 

继承的作用：
1、提高了代码的复用性
2、使类与类之间产生了关系，有了这个关系，才有多态的特性。

 

注：
不要为了获取其它类的功能，简化代码而继承。必须是类与类之间有所属关系，所属关系是is a。
父类是由子类不断抽取而来的。

如以下代码，

class A{
　　demo1(){}
　　demo2(){}
}
class B extends A{
　　demo1(){} 
　　demo3(){}
}

以下继承方式就是错误的

class A{
    demo1(){}
    demo2(){}
}
class B extends A{
    //demo1(){}        //为了简化A中的demo1方法而去继承，是错误的。继承的结果是B中有了demo1和demo2，可是B中没有demo2
    demo3(){}
}

以下是正确的继承方式

class C{          //将classA和classB的共性抽取，单独成立一个新的类
    demo1(){}    
}
class A extends C{
    demo2(){}
}
class B extends C{
    demo3(){}
}

 

先有父类，再有子类。

 

 JAVA中只继承单继承，不支持多继承。因为多继承容易带来安全隐患，当多个父类中定义了相同的功能，但功能内容不同时，子类对象就不确定要运行哪一个功能。

但是JAVA保留了这种机制，用另一种体现形式来完成多继承——多实现。

JAVA支持多层继承。也就是一个继承体系。如何使用继承体系中的功能呢？

先查问体系父类的描述，因为父类中定义的是该体系中的功性功能。通过了解该共性功能，就可以了解该体系的基本功能。那么这个体系也就可以基本使用了。

在具体调用时，要创建最子类的对象。原因一，父类有可能不能创建对象；原因二，创建子为对象可以使用更多的功能，包括基本的和特有的。

 

简单一句话：查阅父类功能，创建子类对象使用功能。

 

示例1、

public class ExtendsDemo1 {

    public static void main(String[] args) {
        Zi z = new Zi();
        System.out.println(z.num1 + "..." + z.num2);

    }

}

class Fu { // 父类。
    int num1 = 1;

}

class Zi extends Fu { // 子类。继承了父类，所以父类的num1可以直接使用。
    int num2 = 2;

}

输出：

1...2

 

示例1、

如子父成员变量同名，且非私有，子类访问子类变量要用this，子类访问父类变量要用super

public class extendsdemo {

    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

class Fu {
    int num = 1;

}

class Zi extends Fu { // 子父类有相同的变量。
    int num = 2; // 和父类变量名相同

    void show() {
        System.out.println(this.num); // this代表本类对象的引用
        System.out.println(super.num); // super代表父类对象的引用
    }

}

 

示例2：

子父类出现完全一样的函数时，当子类对象调用子类函数，会运行子类的内容。
如同父类函数被覆盖一样，这种情况是函数的另一个特性————重写（覆盖）

当子类继承父类，沿袭了父类的功能到子类中，但子类虽具备该功能，但是功能的内容却和父类不一样。这时，就没有必要在子类中重新定义该功能，而只要使用覆盖特性，保留父类的功能定义即可。

此时父类的方法还存在于内存中，只是没有运行。

public class ExtendsDemo {

    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

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

class Zi extends Fu {
    void show() { 　　　　// 和父类方法同名，一模一样，覆盖。
        System.out.println("show zi");
    }
}

输出：

show zi

 

注：

子类覆盖父类时，必须保证子类权限大于等于父类权限，才可覆盖，否则编译失败。

静态只能覆盖静态

 

以下代码中，子父类中的虽然有相同的show方法，但父类中的show方法是private修饰的，也就是子类完全不知道父类中有这个方法，也就谈不上覆盖了。

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

class Zi extends Fu {
    void show() { 　　　　//这不叫覆盖。
        System.out.println("show zi");
    }
}

 

 

 

重载：只看同名函数的参数列表

重写：子父类方法要一模一样