Java中的继承

左手的ㄟ右手 2023-10-02 21:16 26阅读 0赞

### 一、继承 ###

#### 1.1继承的概念 ####

*  继承是Java面向对象编程的基石，允许创建分等级层次的类
 *  继承就是子类继承父类的行为和特征，使得子类对象有父类的实例域或方法
 *  子类从父类继承方法，使子类具有父类相同的行为
 *  继承是从已有的类中派生出新的类，新的类能吸收已有的

举例：

![a6799b638c0e48bfb30616465a315fe5.png][]

>  *  兔子和山羊的父类是食草动物，老虎和狮子的父类是食肉动物
>  *  食草动物和食肉动物的父类是动物
>  *  所以继承要符合的条件是is-a
>  *  父类比子类的概括性更强，子类比父类更加具体化
>  *  虽然食草动物和食肉动物都属于动物的子类，但是两者的行为和特征都有所差别，所以子类会有父类的一般特征但也有自身的特征

#### 1.2类的继承方式 ####

在Java中可以使用extends关键字申明一个类是从另一个类继承下来的，格式如下

> class 父类 \{
> 
> \}
> 
> class 子类 extends 父类 \{
> 
> \}

代码形式如下：

//子类Student继承父类People
    public class Student extends People

*  Student称之为子类（派生类），People称之为父类（基类或者超类)

> **作用**：当子类继承父类后，就可以使用父类的方法和属性了

*  举例一：子类继承了父类，就可以调用父类的方法

**父类：**

//父类
    public class People {
        public void say(){
            System.out.println("Hello World");
        }
    }

**子类：利用关键字“extends"进行继承**

//子类
    public class Men extends People {
    }

**启动项：**

public class DemoApplication {
    
        public static void main(String[] args) {
    
    
            //利用new关键字创建一个子类的对象
            Men man = new Men();
            //通过子类对象调用父类的方法
            man.say();
        }
    }

**结论：子类man可以通过继承父类People从而调用父类中的方法say()**

*  举例2：有一个Dog类，有一个Cat类

狗类：

//狗类
    public class Dog {
        public String name;
        public int age;
    
        public void dogCall(){
            System.out.println(name + "汪汪汪");
        }
    
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }

猫类：

public class Cat {
        public String name;
        public int age;
    
        public void dogCall(){
            System.out.println(name + "喵喵喵");
        }
    
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }

观察发现Dog类和Cat类有相同的**成员变量**和**成员方法，**为了避免写重复代码，将其中相同的部分提取出来，组成一个**父类Animal:**

**父类Animal:**包含有Dog类和Cat类公共的属性和方法

public class Animal {
        
        //Dog类和Cat类公共的属性
        public String name;
        public int age;
    
        //Dog类和Cat类公共的方法
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }

> 将Dog类和Cat类的相同属性和方法都放到一个类中，组成了父类动物类，父类动物类在原来的特性上面加以拓展，增加Dog的新功能（例如这里Dog类的功能是**"汪汪叫“**），就有了Dog类，那么Dog就需要继承动物类
> 
>  *  Dog和Cat类都需要继承Animal类
>  *  Animal类就称为 父类/ 基类 /超类
>  *  Dog类 / Cat类 就称为 子类 / 派生类
>  *  继承之后子类可以复用父类的成员，子类只需要关心自己独有的属性或行为
>  *  子类可以继承父类的属性和行为，但不能继承父类的构造器
>  *  子类拥有父类非private的属性、方法
>  *  **子类继承父类之后，必须添加属于自己的新成员变量或者属性，否则继承就没有意义了**

增加父类Animal之后的Dog类：

//Dog通过extends关键字继承父类Animal
    public class Dog extends Animal {
    
        //子类Dog独有的方法
        public void dogCall(){
            System.out.println(name + "汪汪汪");
        }
    
    }

增加父类Animal之后的Cat类：

//Cat类通过extends关键字继承父类Animal
    public class Cat extends Animal {
    
        //子类Cat独有的方法
        public void catCall(){
            System.out.println(name + "喵喵喵");
        }
    
    
    }

### 二、父类成员访问 ###

子类将父类的成员继承了下来，包括成员属性和成员方法，下面探讨如何访问

#### 2.1 子类访问父类的成员变量 ####

*  访问父类与子类不同名的成员变量：**直接访问**

//父类
    public class Animal {
    
        //Dog类和Cat类公共的属性
        public String name;
        public int age;
    
        //Dog类和Cat类公共的方法
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }
    
    
    //子类
    public class Dog extends Animal {
    
        //这里的colour就是子类与父类不同名的成员变量
        public String colour;
    
    
        //子类Dog独有的方法
        public void dogCall(){
            System.out.println(name + "汪汪汪");
        }
    
    }

*  访问父类成员的属性被private修饰时，前面介绍过被**private**修饰的变量只能在**同一个包同一个文件的同一个类**下使用，那么此时如何访问：可以利用**Generate**进行封装

例如：在父类中的age属性使用private修饰，即使DOG继承了父类，也不能对这个属性进行访问，解决办法是对这个属性进行封装，

**父类Animal:利用右键快捷键选择Generate对属性进行封装**

//父类
    public class Animal {
    
        //Dog类和Cat类公共的属性
        public String name;
        private int age;
    
    
        //右键选择Generate进行封装
        public int getAge() {
            return age;
        }
        //右键选择Generate进行封装
        public void setAge(int age) {
            this.age = age;
        }
    
        //Dog类和Cat类公共的方法
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }

**子类Dog类：**

//子类
    public class Dog extends Animal {
    
        //这里的colour就是子类与父类不同名的成员变量
        public String colour;
    
    
        //子类Dog独有的方法
        public void dogCall(){
    
            //将从父类继承的name属性赋值
            String name = "大黄";
    
            //通过getAge访问父类的私有属性age
            System.out.println(name + getAge() + "汪汪汪");
        }
    
    }

**启动项：**

public class DemoApplication {
    
        public static void main(String[] args) {
    
            //通过New关键字进行创建dog对象
            Dog dog = new Dog();
    
            //通过子类对象访问父类的私有属性age并进行赋值
            dog.setAge(1);
    
            //通过对象dog调用子类方法
            dog.dogCall();
            
        }
    }

**打印输出结果：**

大黄1汪汪汪

*  访问父类与子类同名的成员变量

**父类：**

//父类
    public class Animal {
    
        String name = "阿黄";
        
        //Dog类和Cat类公共的方法
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }

**子类：**

//子类
    public class Dog extends Animal {
    
        //子类Dog独有的方法
        public void dogCall(){
    
            //将从父类继承的name属性赋值
            String name = "阿福";
            System.out.println(name  + "汪汪汪");
        }
    
    }

**启动项：**

//启动项
    public class DemoApplication {
    
        public static void main(String[] args) {
    
            //通过New关键字进行创建dog对象
            Dog dog = new Dog();
    
            //通过对象dog调用子类方法
            dog.dogCall();
        }
    }

**打印输出：打印输出的为子类中的赋值**

阿福汪汪汪

父类中有属性名为name,子类中也有属性名name,且他们的类型相同，我们通过打印可以看到打印输出的为子类name成员变量的值

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

>  *  **如果访问的成员变量子类有，优先访问子类**
>  *  **如果访问的成员变量子类没有，访问从父类继承下来的成员变量，如果父类也没有，则编译报错**
>  *  **如果访问的成员变量子类和父类同名，根据就近原则优先访问子类的成员变量，**
>  *  **也可以通过关键字类访问成员变量（访问子类本类的用this,访问父类的用super)**

#### **2.2 子类访问父类的成员方法** ####

*  访问父类中与子类不同名的方法：**直接访问**

父类：父类方法eat()

//父类
    public class Animal {
    
        String name = "阿黄";
    
        //父类的方法eat()
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }

子类：子类方法dogCall()

//子类
    public class Dog extends Animal {
    
        //子类Dog独有的方法dogCall()
        public void dogCall(){
            //将父类的方法一起添加进来，方便调用
            eat();
    
            //将从父类继承的name属性赋值
            String name = "阿福";
            System.out.println(name  + "汪汪汪");
        }
    
    }

启动项：

打印输出：

阿黄吃饭
    阿福汪汪汪

*  访问父类与子类中同名的方法：**优先访问子类**

**父类：eat()方法**

**子类：eat()方法**

//子类
    public class Dog extends Animal {
    
        //子类Dog的方法eat()
        public void eat(){
            //将父类的方法一起添加进来，方便调用
    
            //将从父类继承的name属性赋值
            String name = "阿福";
            System.out.println(name  + "汪汪汪");
        }
    
    }

**启动项：**

//启动项
    public class DemoApplication {j
    
        public static void main(String[] args) {
    
            //通过New关键字进行创建dog对象
            Dog dog = new Dog();
    
            //通过对象dog调用子类方法
            dog.eat();
        }
    }

**打印输出：**

阿福汪汪汪

**结论：当访问父类和子类同名的方法时，优先访问子类的成员方法**

**那么现在存在这样一个问题：**

**如果父类和子类的成员变量和成员方法相同，访问时优先级肯定时子类更高，如何通过子类的方法去访问父类的成员变量或者方法呢**

### 三、Super关键字详解 ###

上面验证了如果子类和父类的变量或者方法相同，那么通过子类的方法去访问,一定会访问到子类的方法，那么如何才能访问到父类中相同的方法和变量呢，就是使用super关键字

> **super.成员变量 ：表示访问父类的成员变量**
> 
> **super.成员方法 ： 表示访问父类的成员方法**
> 
> super(）: 表示访问父类的构造方法

**super关键字的作用是：在子类中访问父类的成员方法或者变量**

**如果我们在子类中看到了super关键字，那么一定是访问了父类的成员方法或者变量**

**父类：**

**子类：利用super关键字访问父类中同名变量name**

//子类
    public class Dog extends Animal {
    
        //子类Dog的方法eat()
        public void eat(){
    
            //将从父类继承的name属性赋值
            String name = "阿福";
            //利用super关键字访问父类中同名的成员变量name
            System.out.println(super.name  + "汪汪汪");
        }
    
    }

**启动项：**

public class DemoApplication {
    
        public static void main(String[] args) {
    
            //通过New关键字进行创建dog对象
            Dog dog = new Dog();
    
            //通过对象dog调用子类方法
            dog.eat();
        }
    }

**打印输出：成功利用super关键字调用了父类的name**

阿黄汪汪汪

在上述代码中，我们在Dog类的eat方法中，使用了super.name，即调用了父类的“name=阿黄”，所以打印的name是父类中的name，通过运行结果来看也确实如此

>  *  super关键字只能在非静态方法中使用
>  *  super在子类方法中，访问父类的成员方法和变量

### 三、子类的构造器 ###

子类之所以叫子类，因为它继承了父类，但子类是不继承父类的构造器的，他只是进行一个调用，

>  *  如果父类的构造器没有参数，则子类的构造器不需要使用super关键字调用父类的构造器，系统会自动调用父类的无参构造
>  *  如果父类的构造器带有参数，则必须在子类构造器中通过super关键字调用父类构造器并赋予相应的形参列表
>  *  super(实参列表)必须在构造器的第一行

**父类：**

//父类
    public class Animal {
    
        private int age;
    
        //父类的无参构造
        public Animal() {
            System.out.println("Animal()的无参构造");
        }
    
    
        //父类的有参构造
        public Animal(int age) {
            System.out.println("Animal()的有参构造");
            this.age = age;
        }
    }

**Dog类：利用super调用父类中的有参构造器**

//子类
    public class Dog extends Animal {
    
        private int age;
    
        //自动调用父类的无参构造
        public Dog() {
            System.out.println("Dog的无参构造");
        }
    
        public Dog(int age) {
    
            //利用super调用父类中的有参构造器
            super(200);
            System.out.println("Dog的有参构造"+age);
    
            this.age = age;
        }
    }

**Cat类**：**利用super调用父类中的有参构造器**

//Cat类通过extends关键字继承父类Animal
    public class Cat extends Animal {
    
        private int age;
    
    
        //调用的无参构造
        public Cat() {
            System.out.println("Cat的无参构造");
        }
    
    
        public Cat(int age) {
            //利用super调用父类中的有参构造
            super(100);
            System.out.println("Cat的有参构造"+age);
    
            this.age = age;
        }
    }

**启动项：**

public class DemoApplication {
    
        public static void main(String[] args) {
    
            System.out.println("Dog类继承-----------");
            Dog dog = new Dog();
            Dog dog1 = new Dog(300);
    
            System.out.println("Cat类继承------------");
            Cat cat = new Cat();
            new Cat(400);
    
    
        }
    }

**控制台打印输出：**

Dog类继承-----------
    Animal()的无参构造
    Dog的无参构造
    Animal()的有参构造
    Dog的有参构造300
    Cat类继承------------
    Animal()的无参构造
    Cat的无参构造
    Animal()的有参构造
    Cat的有参构造400

[a6799b638c0e48bfb30616465a315fe5.png]: https://img-blog.csdnimg.cn/a6799b638c0e48bfb30616465a315fe5.png