关于类的继承简单学习分享

最新推荐文章于 2024-09-24 21:12:03 发布

苦碧小生

最新推荐文章于 2024-09-24 21:12:03 发布

阅读量697

点赞数 14

文章标签： java 开发语言

本文链接：https://blog.csdn.net/tjywhswbdn1456/article/details/139650047

版权

一下内容基于本人学过的一些皮毛，若有不正确或说的不好的地方望各位博友多多担待

前言

Java类的继承是面向对象编程中的一个重要概念，它允许一个类（称为子类）继承另一个类（称为父类）的属性和方法。继承的关键思想是通过重用现有类的代码，提高代码的复用性和可维护性。

在Java中，使用关键字extends来实现类的继承。子类会继承父类的方法和成员变量，并且可以在其基础上进行扩展或修改。

下面是继承的语法格式：

class 子类名 extends 父类名 {
   // 子类的属性和方法
}

一、单继承

在Java中，类只能继承一个父类，这被称为单继承。单继承意味着一个类只能直接继承自一个父类。

下面是一个简单的示例：

// 定义一个父类
class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// 定义一个子类，继承自Animal类
class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建一个子类对象
        Dog dog = new Dog();
        
        // 调用继承自父类的方法
        dog.eat();
        
        // 调用子类自己的方法
        dog.bark();
    }
}

在上面的示例中，Animal类是一个父类，其中有一个eat()方法。Dog类是一个子类，它继承自Animal类，并且有一个独特的bark()方法。

在主方法中，创建了一个Dog对象，并通过该对象调用了eat()和bark()方法。由于Dog类继承自Animal类，所以它可以访问和使用Animal类中的方法。同时，由于Dog类有自己的独特方法bark()，它也可以在子类中使用该方法。

需要注意的是，由于Java只支持单继承，所以一个类只能继承自一个父类。但是，一个父类可以有多个子类。这种关系被称为继承链。

二、多层继承

多层继承是指一个类继承自另一个类，而这个父类本身也继承自另一个类。这样的继承关系可以一直延伸下去，形成多个层次。

例如，我们可以定义一个名为Animal的父类，其中包含了动物的共有属性和方法。然后，我们可以定义一个名为Mammal的子类，继承自Animal类，表示哺乳动物的特性。再然后，我们可以定义一个名为Dog的子类，继承自Mammal类，表示狗的特性。

下面是一个Java多层继承的示例代码：

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

class Mammal extends Animal {
    protected int legs;

    public Mammal(String name, int legs) {
        super(name);
        this.legs = legs;
    }

    public void walk() {
        System.out.println(name + " is walking on " + legs + " legs.");
    }
}

class Dog extends Mammal {
    public Dog(String name) {
        super(name, 4);
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Rocky");
        dog.eat();
        dog.walk();
        dog.bark();
    }
}

在上述代码中，Animal是顶层的父类，Mammal是Animal的子类，Dog是Mammal的子类。每个子类都继承了父类的属性和方法，同时还可以定义自己的特定属性和方法。

在Main类的main方法中，我们创建了一个Dog对象，并调用了它从父类继承得到的eat()和walk()方法，以及它自己定义的bark()方法。

输出结果为：

Rocky is eating.
Rocky is walking on 4 legs.
Rocky is barking.

这个示例展示了多层继承的基本用法。在实际开发中，多层继承可以帮助我们建立更复杂的类继承关系，使代码更加模块化和可复用。

注意：过多的继承层次可能会导致类之间的耦合性增加，降低代码的可维护性，因此需要谨慎使用多层继承。

三、方法重写

方法重写是指在子类中定义与父类相同名称、参数和返回类型的方法的过程。父类中的方法被子类重写后，当调用该方法时，会根据调用对象的实际类型，动态地选择执行子类的方法。

下面通过一个简单的实例来讲解方法重写的用法和注意事项。

class Animal {
    public void eat() {
        System.out.println("Animal is eating...");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating...");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat(); // 输出 "Animal is eating..."
        
        Dog dog = new Dog();
        dog.eat(); // 输出 "Dog is eating..."
        
        Animal dog2 = new Dog();
        dog2.eat(); // 输出 "Dog is eating..."
    }
}

在上面的例子中，Animal类是一个父类，包含了一个eat()方法。Dog类继承自Animal类，并重写了eat()方法。

在main()方法中，首先创建了一个Animal对象，并调用了eat()方法，输出结果为"Animal is eating..."。然后创建了一个Dog对象，并调用了eat()方法，输出结果为"Dog is eating..."。最后创建了一个Animal类型的引用指向一个Dog对象，并调用了eat()方法，依然输出结果为"Dog is eating..."。

这个例子展示了方法重写的动态绑定的特性。当调用eat()方法时，会根据调用对象的实际类型来确定执行哪个类中的方法。无论是通过父类引用调用子类方法，还是通过子类对象调用自己的方法，都会根据实际类型来执行相应的方法。

需要注意的是，方法重写要求子类方法的访问修饰符必须与父类方法的访问修饰符相同或更宽松。子类方法不能比父类方法抛出更宽泛的异常类型，但可以不抛出异常或抛出更具体的异常类型。另外，方法重写不能改变父类方法中的final修饰符，也不能改变父类方法中的static修饰符。除此之外，子类方法的返回类型必须与父类方法的返回类型相同或是其子类。

`四、super`关键字

super关键字表示对父类的引用。它可以用来调用父类的构造方法、成员变量和方法。以下是super关键字的几个用法的简单案例：

1.调用父类的构造方法：

class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类Animal的构造方法
    }

    public void sound() {
        super.sound(); // 调用父类Animal的sound方法
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Lucky");
        dog.sound();
    }
}

输出结果：

Animal makes sound
Dog barks

2.调用父类的成员变量和方法：

class Animal {
    protected String name;

    public void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    public void setName(String name) {
        super.name = name; // 调用父类Animal的name变量
    }

    public void sound() {
        super.sound(); // 调用父类Animal的sound方法
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("Lucky");
        dog.sound();
    }
}

输出结果：