Java 面向对象程序三大特性：封装、继承和多态

桃扇骨 2023-09-27 12:43 160阅读 0赞

![6588e5d7ba73419c96dabdbecdfe93eb.jpeg][]

**目录**

一、封装

1.1 封装的概念

1.2 权限关键字

1.3 包的引出

二、继承

2.1 继承的理解

2.2 继承的使用

2.3 super关键字

2.4 继承的方式

三、多态

3.1 多态的定义

3.2 实现多态的条件

3.3 多态的使用格式

3.3 重写的使用

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

###  ###

## 一、封装 ##

### 1.1 封装的概念 ###

封装就字面意思来理解，把某些事物装在盒子或者物体里面，不被其他人发现。

**在Java语言里面，封装指的是对数据和方法通过使用类和增加权限的关键字修饰来达到封装的目的，只留出数据接口来和对象进行交互。**

类的定义与使用在之前博客文章已经详解，查看此链接文章[Java类与对象详细讲解（上)][Java] 和[Java 类和对象详细讲解（下）][Java 1]，因此这里暂不多介绍。下面将重点介绍增加权限的关键字使用方法说明。

### 1.2 权限关键字 ###

Java语言中表示增加权限的有privata、默认类型（default、特别说明default不属于关键字）、protected、public

**privata表示权限范围：只能够在同一包中的同一类使用**

**default表示权限范围：能在同一包中的同一类或者不同类下使用，什么都不写时的默认权限**

**protected表示权限范围：能在同一包中的同一类或者不同类下使用，又可以在另一个包中的同一个子类使用**

**public表示权限范围：权限为公共的，任何对象都可以访问**

注意：一般情况下成员变量设置为private，成员方法设置为public

![cd6b100f815b4dc6aa8fe7a187a2ad52.png][]

### 1.3 包的引出 ###

由protected关键字表示的权限我们可以知道：能在同一包中的同一类或者不同类下使用，又可以在另一个包中的同一个子类使用，因此当我们在实际开发过程中，需要创建许多不同的包来调用其他不同包中的类和方法。

因此我们作为一个Java初学者在这里就需要去了解包的定义与使用，以及如何在我们的IDEA编译器上面去动手创建一个新的包。

首先包类似于我们在电脑本地盘里创建的文件夹，不同的文件夹名可以当做不同的包名，每个文件夹下可以去创建多个子文件夹，我们也可以在每个包里面可以去new不同的类名，这个时候我们可以通过使用public去调用其他包的方法和类来使用。

在IDEA中创建包的方法步骤如下：Package翻译为中文为包

![7c55febff55a43acbef9c613e38cc110.png][]

## 二、继承 ##

### 2.1 继承的理解 ###

继承在现实生活中理解为儿子继承爸爸的东西，这样儿子也就拥有了某些和爸爸共同的东西。在Java中，继承指的是当某些类具有一些共同的功能或者方法时，把这些共同的、重复的东西拎出来单独作为一个类，我们把这个新产生的类叫做父类、超类或者基类，原来的类叫做子类或者派生类。此时当子类需要用到父类功能时，可以直接去调用即可。

### 2.2 继承的使用 ###

在java中如果需要子类继承父类，我们可以使用关键字extends去继承父类。

使用格式如下：

public A extends B \{

方法体；

继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

子类继承父类之后，必须要新添加自己特有的成员，体现出与父类的不同，否则就没有必要继承了

class A {
       String name="小明";
       int age;
    public void run () {
      System.out.println("小明正在跑");
      } 
    }
    
    class B extends A { //子类B继承父类A
       double sore;
     public void eat () { //子类新增方法和成员变量
      System.out.println("小明在吃饭");
      } 
    }
    
    public class Test {
      public static void main (String[] args) {
       B b = new B();
        b.eat();  //运行结果为小明在吃饭
        b.run(); //子类调用父类方法  运行结果为小明正在跑
    }
    
    }

在子类继承父类后，新增自己的成员变量和成员方法时，成员变量名和成员方法名可以和父类中的成员变量名和成员方法名保持一致。那这里就有一个疑惑，最后去调用相同的成员方法时，是访问父类继承的，还是子类新增的？

我们在这里可以写一段代码看一下编译器如果遇到这种情况会怎么去访问

class A {
        String name="小明";
        int age = 10;
        public void run () {
            System.out.println("小明正在跑");
        }
    }
    class B extends A {
        double sore;
        int age =40 ;
        public void fun() {
            System.out.println("age="+age);
        }
        public void eat() {
            System.out.println("小红在吃饭");
        }
        public void run() {
            System.out.println("子类：小红正在跑");
        }
        
    }
    public class Test {
        public static void main (String[] args) {
            B b = new B();
            b.fun(); //运行结果为30，调用子类中的方法
            b.run(); //输出为子类：小红正在跑，调用的是子类方法
        }
    }

从上述代码，我们可以得出以下结论：

1、当子类与父类中成员变量名相同或者方法名相同时，则优先访问子类的，若子类找不到变量名则去父类中寻找，最后若父类也没有，编译器会提示错误。

2、当子类中存在与父类中相同的成员时，访问相同的成员变量或者方法时则只会访问子类的成员变量和方法，父类的不会进行访问

3、当子类中存在与父类中相同的成员时，如果明确想要在子类中访问父类相同名称的成员，那么可以借助关键字**super**来调用父类的成员。

class A {
        String name="小明";
        int age = 10;
        
        public void run () {
            System.out.println("小明正在跑");
        }
    }
    class B extends A {
        double sore;
        
        public void run() {
            System.out.println("小红正在跑");
        }
       
        public void fun() {
                  run();   //调用子类的run方法
            super.run();  //调用父类的run方法
        }
    }
    public class Test {
        public static void main (String[] args) {
            B b = new B();
            b.fun();
        }
    }
    
    
    运行结果：
             小红正在跑
             小明正在跑

### 2.3 super关键字 ###

**1、super用来访问父类继承下来的方法和属性**

**2、super关键字只能在类的非静态方法中使用，用来访问非静态成员方法和字段**

**3、在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。**

**4、super只能指代其直接父类，不能指代父类的父类**

### **2.4 继承的方式** ###

**在java中继承方式有单继承，多层继承和多个子类继承一个父类。**

![df080d5d07064408b46d226347d9c233.png][] ![f21a3913f34c454b80432f570ffb0bad.png][]

![affc31ebf4204024b45e4e211399178e.png][]

**1、一个子类只能继承一个父类，不能同时继承两个父类。**

**2、一个子类不能继承父类的父类**

## 三、多态 ##

### 3.1 多态的定义 ###

**多态：具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状** **态。**

1.多态是同一个行为具有多个不同表现形式或形态的能力 注意是同一种行为去发散，可以通过继承、接口等等去实现这样一个功能！**多态体现为父类引用变量可以指向子类对象**

2.多态就是同一个接口，使用不同的实例而执行不同操作 如多个不同子类对象这样的

### 3.2 实现多态的条件 ###

在J ava 中要实现多态，必须要满足如下几个条件，缺一不可：

**1. 必须在继承体系下**

**2. 子类必须要对父类中方法进行重写**  **（ 重写在3.4下一小节详细介绍）**

**3. 通过父类的引用调用子类重写的方法 （** 即在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。 **）**

注意：父类中成员变量不能重写，多态调用成员变量时会执行父类的

**多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。**

###  ###

### 3.3 多态的使用格式 ###

**使用格式：父类类型 变量名=new 子类类型();**  //父类引用指向子类对象

**多态成员方法特点：编译看左边，运行看右边** //编译看左边，需要使用的功能必须由父类提供

//运行看右边，子类重写父类方法后，右边必须是子类方法体

参考例子来说明多态的使用格式与注意点：

class Animal {
        String name = "Jack" ;
        public void eat() {
            System.out.println(name+"正在吃东西");
        }
        public static void run() {
            System.out.println("正在走");
        }
    }
    class Cat extends Animal {
        String name = "小咪" ;
        public void eat() {
            System.out.println(name+"正在吃小鱼");
        }
            public static void run() {
    
            System.out.println("正在跑步");
        }
    }
        public class Class {
        public static void main(String[] args) {
            Animal animal = new Cat(); //仍然是父类引用（Animal） 指向 子类对象（这里的 new Cat()）
                                      //编译看左边，需要使用的功能，必须是父类提供的。
                                      //运行看右边，子类重写父类方法后，右边必须是子类方法体
            animal.eat();   //调用子类的方法体
            animal.run();  //父类中run方法被static修饰，为静态成员方法，不存在重写，所以直接执行父类的方法声明和方法体。
                           // 即使子类有一个和父类一模一样的方法也不是重写！
            System.out.println(animal.name);//成员变量的使用，由于不存在重写，一定是使用父类的，所以执行的也是父类的。
        }
    }

### 3.4 重写的使用 ###

重写是子类对父类非静态、非 private 修饰，非 final 修饰，非构造方法等的实现过程进行重新编写,  **返回值和形参都不能改变** 。 **即外壳不变，核心重写！**

**重写注意事项：**

1、子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名  ( 参数列表 )  要完全一致

2、 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被 public 修饰，则子类中重写该方法就不能声明为 protected

3、父类被 static 、 private 修饰的方法、构造方法都不能被重写。

[6588e5d7ba73419c96dabdbecdfe93eb.jpeg]: https://img-blog.csdnimg.cn/6588e5d7ba73419c96dabdbecdfe93eb.jpeg
[Java]: https://mp.csdn.net/mp_blog/creation/editor/127823850
[Java 1]: https://mp.csdn.net/mp_blog/creation/editor/127855760
[cd6b100f815b4dc6aa8fe7a187a2ad52.png]: https://img-blog.csdnimg.cn/cd6b100f815b4dc6aa8fe7a187a2ad52.png
[7c55febff55a43acbef9c613e38cc110.png]: https://img-blog.csdnimg.cn/7c55febff55a43acbef9c613e38cc110.png
[df080d5d07064408b46d226347d9c233.png]: https://img-blog.csdnimg.cn/df080d5d07064408b46d226347d9c233.png
[f21a3913f34c454b80432f570ffb0bad.png]: https://img-blog.csdnimg.cn/f21a3913f34c454b80432f570ffb0bad.png
[affc31ebf4204024b45e4e211399178e.png]: https://img-blog.csdnimg.cn/affc31ebf4204024b45e4e211399178e.png