【JAVA】面向对象的编程语言(继承篇)

╰+攻爆jí腚メ 2024-04-14 12:02 38阅读 0赞

![在这里插入图片描述][cb92708569c2448f8083684b0e799056.png_pic_center]

--------------------

> 个人主页：[【?个人主页】][Link 1]  
> 系列专栏：[【❤️初识JAVA】][JAVA]

--------------------

#### 文章目录 ####

*  前言
 *  继承
 *  类的继承方式
 *  继承的各种类型
 *  多继承
 *  继承的特性
 *  各种继承关键字
 *   *  extends关键字
     *  implements关键字
     *  super 与 this 关键字
     *   *  super 关键字
         *  this 关键字
     *  final 关键字

--------------------

## 前言 ##

在之前的文章中，我们介绍过面向对象的编程语言，今天我们就来就进入到JAVA面对对象的编程世界，今天我们主要来介绍面向对象的编程范式中一个重要的概念——继承。  
![在这里插入图片描述][7417c21562b64e1b98aab8e4f3383af5.webp_pic_center]

## 继承 ##

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

> 继承就是子类继承父类的特征和行为，使得子类对象（实例）**具有父类的实例域和方法**，或**子类从父类继承方法，使得子类具有父类相同的行为**。

## 类的继承方式 ##

在JAVA中我们可以通过 extends 关键字可以申明一个类是从另外一个类继承而来的：

class 父类 {
        
    }
     
    class 子类 extends 父类 {
        
    }

## 继承的各种类型 ##

![在这里插入图片描述][db1d8bf764954ba2b38a42990e36d54e.png_pic_center]

## 多继承 ##

Java不支持多重继承，即一个子类不能继承多个父类。这是因为多重继承可能会导致一些问题，比如：

>  *  **命名冲突**：如果两个父类中有相同的`方法`或`属性`，则子类不知道该继承哪一个。
>  *  **菱形继承问题**：如果一个类同时继承自两个父类，这两个父类又都继承自同一个父类，则子类中会存在两个相同的父类，容易造成混乱。

为了解决这些问题，Java引入了接口(interface)的概念，使得一个类可以同时实现多个接口。虽然接口中也可以定义方法和属性，但是接口中的方法都是抽象方法，没有方法体，而且接口中的属性都是常量。这样可以避免命名冲突和菱形继承问题。通过实现不同的接口，一个类可以具有多个不同的功能。

## 继承的特性 ##

>  *  子类拥有父类`非 private 的属性、方法`。
>  *  子类可以拥有自己的属性和方法，即`子类可以对父类进行扩展`。
>  *  子类可以用`自己的方式实现父类的方法`。
>  *  Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

## 各种继承关键字 ##

### extends关键字 ###

在 Java 中，extends 关键字用于表示一个类继承自另一个类。子类（派生类）继承父类（基类、超类）的所有方法和属性，并且还可以添加自己的方法和属性。被继承的类称为超类或基类，继承自该类的类称为子类或派生类。

class Animal {
        
        void move() {
        
            System.out.println("动物可以移动");
        }
    }
    
    class Dog extends Animal {
        
        void move() {
        
            System.out.println("狗可以跑和走");
        }
    }
    
    public class TestDog {
        
        public static void main(String args[]) {
        
            Animal a = new Animal(); // Animal 对象
            Animal b = new Dog(); // Dog 对象
    
            a.move(); // 执行 Animal 类的方法
    
            b.move(); // 执行 Dog 类的方法
        }
    }

> Animal 类是一个超类，Dog 类是一个子类。Dog 继承了 Animal 类，并重写了 Animal 类的 move() 方法。在 main() 方法中，创建了 Animal 和 Dog 类的对象，并调用了它们的 move() 方法。由于 Animal 对象调用的是 Animal 类的 move() 方法，而 Dog 对象调用的是 Dog 类重写的 move() 方法。

### implements关键字 ###

implements是Java中的一个关键字，用于实现接口。当一个类实现一个接口时，必须使用implements关键字，并且实现该接口中定义的所有方法。

public interface MyInterface {
        
       public void method1();
       public void method2();
    }
    
    public class MyClass implements MyInterface {
        
       public void method1() {
        
          System.out.println("Implementation of method1");
       }
       public void method2() {
        
          System.out.println("Implementation of method2");
       }
    }

> MyClass实现了MyInterface接口并实现了其中的method1和method2方法。这使得MyClass能够使用接口中定义的方法，并且可以通过多态性来引用MyInterface的实例。

### super 与 this 关键字 ###

Java 中的 super 和 this 都是关键字，分别用于访问父类和本类中的成员。

#### super 关键字 ####

super 可以用来访问父类中被子类覆盖的方法和属性

super.父类方法名(参数列表);//或者
    super.父类属性名;
    //例如:
    public class Father {
        
        public String name;
        
        public Father(String name) {
        
            this.name = name;
        }
        
        public void eat(String food) {
        
            System.out.println(name + " is eating " + food);
        }
    }
    
    public class Son extends Father {
        
        public int age;
        
        public Son(String name, int age) {
        
            super(name);
            this.age = age;
        }
        
        @Override
        public void eat(String food) {
        
            super.eat(food); // 调用父类的 eat 方法
            System.out.println(name + " is " + age + " years old");
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            Son son = new Son("Tom", 18);
            son.eat("apple");
        }
    }

其中，父类方法和属性必须是被子类继承和覆盖的。在子类中，如果要访问父类中的成员，就可以使用 super 关键字。

#### this 关键字 ####

this 关键字可以用来引用当前对象的属性或方法

this 关键字可以用来引用当前对象的属性或方法//或者
    this 关键字可以用来引用当前对象的属性或方法
    //例如：
    public class Student {
        
        private String name;
        private int age;
        
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
        
        public void getInfo() {
        
            System.out.println("Name: " + this.name);
            System.out.println("Age: " + this.age);
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            Student s = new Student("Tom", 18);
            s.getInfo();
        }
    }

### final 关键字 ###

Java 中的 final 关键字用于表示不可变的值或不可变的引用  
对于变量，final 修饰的变量表示为常量，一旦被赋值后不能被修改。

>  *  对于方法，final 修饰的方法表示方法不能被子类重写。
>  *  对于类，final 修饰的类表示类不能被继承。

使用 final 可以使程序更加安全可靠，因为常量值不变，可以防止意外修改值导致程序出错；final 方法和类可以保证方法和类的行为不会被改变，有助于程序设计和优化。  
![在这里插入图片描述][666435e08eac44598e252f5e9359fb88.gif_pic_center]

[cb92708569c2448f8083684b0e799056.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/27df79a95990418e871f172661e61baa.png
[Link 1]: https://blog.csdn.net/weixin_73602725?type=blog
[JAVA]: https://blog.csdn.net/weixin_73602725/category_12366012.html?spm=1001.2014.3001.5482
[7417c21562b64e1b98aab8e4f3383af5.webp_pic_center]: https://img-blog.csdnimg.cn/7417c21562b64e1b98aab8e4f3383af5.webp#pic_center
[db1d8bf764954ba2b38a42990e36d54e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/61a956b05a90411884b3531324dbe2b1.png
[666435e08eac44598e252f5e9359fb88.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/5724612b672242398cdbcb066c3da325.gif