Java语言-----封装、继承、抽象、多态、接口

深碍√TFBOYSˉ_ 2024-04-20 14:24 10阅读 0赞

**目录**

前言

一.封装

1.1封装的定义

1.2访问修饰符的使用

二.继承

2.1继承的定义

2.2继承的方法

2.3继承使用注意点

三.多态

3,1多态的定义

3.2动态绑定

3.3方法重写

3.4向上（向下）转型

四.抽象

4.1抽象的概述和定义

4.2抽象的使用

五.接口

5.1接口的意义

5.2接口的定义

总结

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

> 😽个人主页： tq02的博客\_CSDN博客-C语言,Java领域博主
> 
> 🌈理想目标：努力学习，向Java进发，拼搏一切，找到一份朝九晚五，有假期的工作，让自己的未来不会有遗憾。  
> 🎁欢迎各位→点赞👍 + 收藏⭐ + 评论📝+关注✨
> 
> 本章讲解内容：Java封装、继承、抽象、多态、接口
> 
> 使用编译器：IDEA
> 
> ![b00a056748e248a8a45bda703cd490ee.jpeg][]

## 前言 ##

在讲述封装、继承、抽象、多态、接口前，我们得先了解一下，什么是类与对象，类与对象的详细讲解：[tq02的类与对象讲解][tq02]

## 一.封装 ##

### 1.1封装的定义 ###

>  **封装，在类里操作，将类的成员变量和成员方法进行封装处理**，意义：可以被认为是一个保护屏障，防止该类的代码和数据被[外部类][Link 1]定义的代码随机访问。而对类进行封装我们需要使用访问修饰符，一共分为四种，

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="width:118px;"><strong>访问修饰符</strong></td> 
   <td style="width:120px;">&nbsp; &nbsp; &nbsp; &nbsp; <span style="background-color:#ffd900;">&nbsp;private</span></td> 
   <td style="width:116px;">&nbsp; &nbsp; &nbsp;<span style="background-color:#ffd900;">default</span></td> 
   <td style="width:118px;">&nbsp; &nbsp;<span style="background-color:#ffd900;"> protected</span></td> 
   <td style="width:127px;">&nbsp; &nbsp; &nbsp;<span style="background-color:#ffd900;">public</span></td> 
  </tr> 
  <tr> 
   <td style="width:118px;">同一包的同一类</td> 
   <td style="width:120px;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;√</td> 
   <td style="width:116px;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;√</td> 
   <td style="width:118px;">&nbsp; &nbsp; &nbsp; &nbsp; √</td> 
   <td style="width:127px;">&nbsp; &nbsp; &nbsp; √</td> 
  </tr> 
  <tr> 
   <td style="width:118px;">同一包的不同类</td> 
   <td style="width:120px;"></td> 
   <td style="width:116px;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;√</td> 
   <td style="width:118px;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;√</td> 
   <td style="width:127px;">&nbsp; &nbsp; &nbsp; &nbsp;&nbsp;√</td> 
  </tr> 
  <tr> 
   <td style="width:118px;">不同包的子类</td> 
   <td style="width:120px;"></td> 
   <td style="width:116px;"></td> 
   <td style="width:118px;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;√</td> 
   <td style="width:127px;">&nbsp; &nbsp; &nbsp; &nbsp;&nbsp;√</td> 
  </tr> 
  <tr> 
   <td style="width:118px;">不同包的非子类</td> 
   <td style="width:120px;"></td> 
   <td style="width:116px;"></td> 
   <td style="width:118px;"></td> 
   <td style="width:127px;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;√</td> 
  </tr> 
 </tbody> 
</table>

注：1.如果成员变量或者成员方法没有使用封装则是默认使用default修饰符。

2.包是存放多个类的容器，就是防止在工程建立时，和其他人写的类名相同而起冲突。

3.子类是在继承当中可以学到的。

### 1.2访问修饰符的使用 ###

我们进行四种封装代码实例图

**1.private修饰**

![7c953f46386145c4a83ce8a8c9175b06.png][]

private修饰的price和name变量，其他类无法访问，只有自己的类里可以进行访问。就例如在BookList类里无法直接访问这两个元素变量。

**2.default修饰**

![e1506c1cedbb48e8b0d76adfce054b75.png][]

default修饰符，是指当你没有标注修饰符时，就默认了default修饰符，而此类的只有同一个包的其他类访问，例如BookList可以访问，但不同包的Student类无法访问。

**3.protected修饰符**

![37e1db0cfab44a09ba4503ba5896b22a.png][]

protected修饰符，类当被修饰了之后，同包下所有的类都可以访问，非同包下的其他包的子类也可以使用。如Student类继承之后也可以使用Book类。

**4.public修饰符**

![a5668663a8944e5a9d31f91b6b7d07d6.png][]

public修饰符，一旦使用，所有的类都可以使用，不在乎是否同包。

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

## 二.继承 ##

### 2.1继承的定义 ###

继承是什么？是所有OOP语言不可缺少的组成成分，是面向对象的三大特征之一，继承就相当于，孩子继承父亲的东西（父亲愿意给孩子的东西），关键字是extends，继承父类的成员变量和成员方法，一般是为了减少代码冗余。但是继承也得遵守访问修饰符，一旦不符合，则无法继承。

代码显示：

public class Animal {
        public String name;
        public Animal(String name) {
        this.name = name;
        }
        public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
    }
    // Cat.java
    class Cat {
        public String name;
        public Cat(String name) {
        this.name = name;
        }
        public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
    }
    // Bird.java
    class Bird {
        public String name;
        public Bird(String name) {
        this.name = name;
        }
        public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
        }
        public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
        }
    }

可以看得出来，Animal类和cat类还有Bird类，有很多重复的代码，而为了减少大量的冗余代码，我们可以使用继承的手段。

### 2.2继承的方法 ###

> 定义方法：
> 
> class 子类 extends 父类 \{  
> \}

代码实现：

class Animal {
        public String name;
        public Animal(String name) {
        this.name = name;
    }
        public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
        }
    }
    
    class Cat extends Animal {
        public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
        }
    }
    
    class Bird extends Animal {
        public Bird(String name) {
        super(name);
    }
        public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
        }
    }
    public class Test {
        public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
    }

我们可以看出，**Cat类和Bird类的成员变量和成员方法相当于是在Animal类的基础上，扩展出来**。

### 2.3继承使用注意点 ###

1.  使用 extends 指定父类.
2.  Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
3.  子类会继承父类的所有 public 的变量和方法.
4.  对于父类的 private 的字段和方法, 子类中是无法访问的.
5.  子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用
6.  所有的类都有一个父类---Object类

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

## 三.多态 ##

### 3,1多态的定义 ###

> 多态是面向对象三大特征最后一个，可以增强程序的扩展性，提高程序的可维护性。而它的主要支撑技术有向上转型、向下转型、动态绑定、方法重写。

### 3.2动态绑定 ###

即方法与方法的主体在运行时才进行绑定。例如，当父类和子类拥有一个同名的方法（remove），那么定义了an.remove()，remove方法的调用主体是an，但是an只有调用时，才能知道是实例化了哪个类。而这便是动态绑定。

### 3.3方法重写 ###

当子类和父类的成员方法名相同时，那么子类的成员方法便是方法重写。而当子类的对象实例化之后，使用和父类同名的方法，则使用的子类的方法，不是使用父类的方法。

class Animal {
        public String name;
        public void Name(String name) {
         System.out.println("Animal的名字是"+name);
    }
        
    }
    
    class Cat extends Animal {
       
          public void Name(String name) {
         System.out.println("Cat的名字是"+name);
    }
    }
    public class Test {
        public static void main(String[] args) {
       Cat cat = new Cat();
       cat.Name("小黑");
    }
    }

该代码的结果是Cat的名字是小黑，由此可见，使用的Cat类的Name方法，而不是Animal类的Name方法。

### 3.4向上（向下）转型 ###

向上转型和向下转型都是在继承的**基础上**

class Animal {
        public String name;
        public Animal(String name) {
            this.name = name;
    
        }
        public void eat(String food) {
            System.out.println(this.name + "不喜欢吃" + food);
        }
    }
    class Cat extends Animal {
        public int age;
        public Cat(String name) {
            // 使用 super 调用父类的构造方法.
            super(name);
        }
        public void eat(String food) {
            System.out.println(this.name + "正在吃" + food);
        }
    }
    class Test {
        public static void main(String[] args) {
            Animal cat = new Cat("小黑");
            cat.eat("鱼");
        }
    }

从上面代码中，我们可以发现cat是Animal的引用变量，而它指向了子类的对象，这就是**向上转型**。

注：

1.  cat是Animal类型的引用变量，而对于Animal类型的引用变量来说，实例化的对象只能访问父类中存在的方法和属性，所以无法使用cat.age=22;进行赋值的。
2.  由于cat实际上指向Cat的对象，所以当调用eat()方法时；依然还能显示子类成员方法的信息。注：必须父类也存在该方法，才会调用子类的方法

public class Animal {
        protected String name;
        public Animal(String name) {
            this.name = name;
        }
        public void eat(String food) {
            System.out.println("我是一只小动物");
            System.out.println(this.name + "正在吃" + food);
        }
    }
    public class Bird extends Animal {
        public Bird(String name) {
            super(name);
        }
    
        public void eat(String food) {
            System.out.println("我是一只小鸟");
            System.out.println(this.name + "正在吃" + food);
        }
    
        public void fly() {
            System.out.println(this.name + "正在飞");
        }
    
        public static void main(String[] args) {
            Animal animal = new Bird("圆圆");
            //强制转换为Bird类型
              Bird bird = (Bird)animal;
              bird.fly();
        }
    }

从上面代码中，我们可以很明显的发现**向下转型需要通过强制类型转换完成**。虽然animal是Animal父类的引用变量，但是将animal强制转换为Bird类型便为向下转型。但是并不安全，因为向下转型可能会不正确，例如原本向下转型为Cat类，但却转型为了Bird类，这便会产生危险性。

解决方法：

Animal animal = new Cat("小猫");
    if (animal instanceof Bird) {
    Bird bird = (Bird)animal;
    bird.fly();
    }

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。

**结论：**1.向上转型时，是父类的引用变量指向了子类的对象，当然，无法使用子类的新增成员（变量和方法），但是如果使用父类的成员方法，如果子类有该方法的重写，则使用重写的方法，若无，则使用父类方法。

2.向下转型时，则需要强制类型转换。

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

## 四.抽象 ##

### 4.1抽象的概述和定义 ###

> 抽象类，关键字为abstract，如果所有的子类都要重写父类的某个方法时，父类的方法可以为抽象方法，直接声明，不需要结构体。而含有抽象方法的类，则为抽象类  
> 定义方法：
> 
> public **abstract** 类名\{
> 
> String name;
> 
> public **abstract** void 方法名();
> 
> \}

### 4.2抽象的使用 ###

抽象类存在的最大意义就是为了被继承.  
 抽象类不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类**重写**抽象类中的抽象方法。

abstract class  Animal {
        public String name;
        public Animal(String name) {
        this.name = name;
    }
        public abstract void eat(String food); //抽象方法，子类一定要重写
    }
    
    class Cat extends Animal {
        public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
       //重写父类的抽象方法
       public abstract void eat(String food){
         System.out.println("猫吃"+food);
        }
        }
    }
    
    class Bird extends Animal {
        public Bird(String name) {
        super(name);
    }
       //重写父类的抽象方法
        public abstract void eat(String food){
         System.out.println("鸟吃"+food);
        }
    }
    public class Test {
        public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
    }

**抽象的重点知识：**

1.  抽象类不能直接实例化。
2.  抽象方法不能是 private 的。
3.  抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用。

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

## 五.接口 ##

### 5.1接口的意义 ###

接口是为了弥补代码无法多继承，只能单继承的问题。例如定义了一个Animal的父类，和Cat、Bird、Dog、Wolf的子类，可是你想啊，狗和猫是宠物，或许有共同的方法，定义一个宠物类，那么可以通过接口**实现不相关类的相同行为**。

好处：

1.  利于代码的规范，目的是给开发人员一个清晰的指示，告诉他们哪些业务需要实现；同时防止由于开发人员随意命名而导致命名不清晰和代码混乱，影响开发效率。
2.  是有利于对代码进行维护，定义一个接口，把功能菜单放在接口里，然后定义类时实现这个接口。
3.  是保证代码的安全和严密。

### 5.2接口的定义 ###

> 定义方法：
> 
> public interface 接口名\{ \}
> 
> 使用接口：
> 
> class 类名 implements 接口名\{ 方法体 \}；

代码实现：

class Animal {
        public String name;
        public Animal(String name) {
        this.name = name;
        }
        
    }
       //定义接口
    public interface Eat {
         public void eat(String food);
    }
                          //使用接口
    class Dog extends Animal implements Eat{
        public int age;
        public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
        }
        public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
        }
    }
                            //使用接口
    class Cat extends Animal implements Eat{
        public int age;
        public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
        }
        public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
        }
    }
    public class Test {
        public static void main(String[] args) {
        Animal cat = new Cat("小黑");
       cat.eat();
    }
    }

接口的重点：

1.  接口的方法体若为空，则为空实现。
2.  一个类可以有多个接口。
3.  接口里所有的方法都是public和抽象的，所以可以省略public和抽象的。
4.  接口无法被实例化。
5.  接口可以被继承

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

## 总结 ##

继承是多态、抽象的基础，而学会了抽象，才能理解接口。而这些知识都是Java最为重要的面向对象三大特征的。只有细心学习，才能更近一步，在Java上才能算正式起步。

[b00a056748e248a8a45bda703cd490ee.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/2ebdd3312a724669abdced0c17a6ab24.jpeg
[tq02]: http://t.csdn.cn/qJrfU
[Link 1]: https://so.csdn.net/so/search?q=%E5%A4%96%E9%83%A8%E7%B1%BB&spm=1001.2101.3001.7020
[7c953f46386145c4a83ce8a8c9175b06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/10a7466709414e208b6d812b2687e481.png
[e1506c1cedbb48e8b0d76adfce054b75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/2b81d64e474f4882afab107fdc099a49.png
[37e1db0cfab44a09ba4503ba5896b22a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/29747acb000348959e46744303ab7ccd.png
[a5668663a8944e5a9d31f91b6b7d07d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9a0eb6b3e97d45fe971bd5305bf7b158.png