Java面向对象三大特性——封装、继承、多态

• 一、封装
• • 1.封装基本概念
  • 2.访问修饰符
  • 3.Java中封装的理解
  • 4.封装的优点
• 二、继承
• • 1.为什么需要继承
  • 2.继承层次结构
  • 3.super和this关键字
  • 4.继承语法与设计一个继承体系
• 三、多态
• • 1.多态的概念
  • 2.多态的实现条件
  • 3.多态的优缺点

一、封装

1.封装基本概念

封装（encapsulation，有时称为信息隐藏）是处理对象的一个重要概念。
从形式上看，封装就是将数据和行为组合在一个包中，并对对象的使用者
隐藏具体的实现细节。对象中的数据称为实例字段（instance field），
操作数据的过程称为方法（method）。作为一个类的实例，一个特定对象
就有一组特定的实例字段值。这些值的集合就是这个对象当前的状态（state）
只要在对象上调用一个方法，它的状态就有可能发生改变。

封装的关键：
绝对不能让其他类中的方法直接访问这个类的实例字段。程序只能通过对象的方法与对象的数据进行交互。

2.访问修饰符

下面是小编整理的访问限定符，这是一定要掌握的哦😊

3.Java中封装的理解

我们在设计程序的时候追求高内聚、低耦合
高内聚——类的内部数据的操作和细节自己完成，不允许外部干涉；
低耦合——对外提供少量的公共方法使用

我们在实现的一个类的时候隐藏类内部的复杂性、之对外提供简单的公开的接口。便于外界调用从而提高系统的可拓展性、可维护性，这里就要讲到Java中权限访问修饰符（private、默认（什么都不加）、protected、public）进行封装。

下面我们用封装的思想来编写一个员工类
属性——姓名、年龄、工资
行为——上班摸鱼

public class Employee {/*** 将特有的属性进行封装，并且不希望外界随意* 的对他进行修稿，这里我们就要用到私有的访* 问修饰符——private*/private String name;private int age;private double salary;//构造方法，供外界实例一个类对象来操作数据public Employee(String name,int age,double salary) {this.name = name;this.age = age;this.salary = salary;}/*** 对外提供少量的公共方法供实例对象来操作数据* 主要是get、set方法，就比如说有一天我的员工修* 改了姓名或者调薪*///set设置器public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}//get访问器public String getName() {return name;}public int getAge() {return age;}public double getSalary() {return salary;}//特有的行为public void work() {System.out.println("名字为" + name + "的员工正在上班摸鱼");}public void raiseSalary(double byPercent) {double raise = salary * byPercent / 100;salary += raise;}
}

4.封装的优点

最后我们再仔细看一下非常简单getName、getSalary方法

public String getName() {return name;
}public double getSalary() {return salary;
}

这些都是典型的访问器。由于他们只返回实例字段的值，因此又称为字段访问器（field accessor）。

如果将name、salary字段标记为公共，而不是编写单独的访问器方法，不是更容易一些吗？

不过name只是一个只读字段，一旦再构造器（构造方法）中设置，就没有办法能够修改这个字段。这样我们就可以确保name字段不会受到外界的破坏。

虽然salary不是只读字段，但是它只能用raiseSalary方法修改。具体的，如果这个值发生错误，那么只需要调试这个raiseSalary方法就可以了。如果salary字段是公共的，破坏这个字段的罪魁祸首就可以出现再任何地方（那就很难调试了）。

二、继承

1.为什么需要继承

让我们回忆一下上面讨论的employee类。假设你在某个公司工作，这个公司里经理的待遇与普通员工的待遇存在着一些差异。不过，当然他们当中也存在很多相同的地方，例如，他们都领取薪水。只是普通员工在完成本职任务后仅领取薪水，而经理在完成了预期的业绩之后还能得到奖金。这种情形就需要使用继承。
为什么呢？因为需要为经理定义一个新类Manager，并增加一些新功能，但可以重用Employee类中已经编写好的部分代码，并保留Employee类中的所有字段。

**继承机制：**是面向对象程序设计使代码可以复用的重要手段，它允许程序员在保持原有类特性的基础上进行拓展，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

2.继承层次结构

继承并不仅限于一个层次。例如，可以由Animal类派生出狗类、猫类、鸟类，再由猫类派生出中华田园猫、英国短毛猫、布偶猫等。由一个公共超类派生出来的所有类的集合称为继承层次结构（inheritance hierarchy），如下图所示。再继承层次结构中，从某个特定的类到其祖先的路径称为该类的继承链（inheritance chain）。

补充：
在C++中，一个类可以有多个超类。Java不支持多重继承，但支持多层继承。

3.super和this关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。
this关键字主要在本类访问本类成员成员变量，**该关键字的主要作用：**在本类方法中访问本类的成员
super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，他们之间有什么区别呢/？
【相同点】
1.都是Java中的关键字
2。只能在类的非静态方法中使用，用来访问非静态的成员方法和字段
3.在构造方法中调用时，必须时构造方法中的第一条语句，并且不能不能同时存在
【不同点】
1.this是当前对象的引用，当前对象即为调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造
方法中出现
4. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

4.继承语法与设计一个继承体系

4.1 继承语法：
Java中如果要表示类之间的继承关系，需借助extends关键字，具体如下：

修饰符 class 子类名 extends 父类名 {//...
}

4.2 设计一个继承体系
父类Employee类：
属性——姓名、年龄、工资
行为——上班摸鱼、调薪
子类Manager类：
属性——姓名、年龄、工资、奖金（特有的）
行为——看看谁摸鱼、调薪

class Employee {//属性private String name;private int age;private double salary;//构造方法public Employee(String name,int age,double salary) {/**this关键字的用法解释* 由于方法形参与成员变量同名，不适用this关键字就造成变量* 同名，不使用this关键字就遵循就近原则，影响不到成员变量* 故this.name指定了成员变量的name,而非形参的name*/this.name = name;this.age = age;this.salary = salary;}//set更改器public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}//get访问器public String getName() {return name;}public int getAge() {return age;}public double getSalary() {return salary;}//行为public void work() {System.out.println("名字为" + name + "的员工正在上班摸鱼！");}public void raiseSalary(double byPercent) {double raise = salary * byPercent / 100;salary += raise;}
}class Manager extends Employee {//属性，与父类相同的属性就不必写了，这就是继承的好处private double bonus;public Manager(String name, int age, double salary) {/**super关键字用法的解释* 因为这个类继承了Employee类，必须帮助父类构造* 这里的super是调用了父类的构造方法*/super(name, age, salary);//这里的奖金并不是构造对象时马上给出的，根据业绩的给定的this.bonus = 0;}/*由于父类的访问器已经不能满足子类的需求了，故需要重写父类的getSalary()方法,这里不加拓展重写，有关内容期待博主更新或者网上查阅资料哦！！！*/public double getSalary() {//这里super关键字的用法时调用父类的成员方法double baseSalary = super.getSalary();return baseSalary + bonus;}public void setBonus(double bonus) {this.bonus = bonus;}public void superviseWork() {System.out.println("名为" + super.getName() + "正在看看谁上班摸鱼！");}
}

三、多态

1.多态的概念

在Java程序设计语言中，对象变量时多态的（polymorphic）。一个Employee类型的变量既可以引用一个Employee类型的对象，也可以引用Employee类的任何一个子类的对象（例如：Manager）。
那就意味着我们可以这样用，接上面的继承篇

Manager boss = new Manager("张三",24,12000);
Employee[] staff = new Employee[3];
staff[0] = boss;
boss.setBonus(5000)//OK
staff[0].setBonus(5000)//ERROR

为什么会发生错误呢？这是因为staff声明是Employee类型，Employee类中并没有setBonus()方法，boss则是声明为Manager类型，类中有setBonus()方法，所以调用时正确的。

**多态的概念：**通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生不同的状态。

2.多态的实现条件

在Java中要想完成多态，必须要满足如下几个条件，缺一不可：

• 必须在继承体系下
• 子类必须要对父类中的方法进行重写
• 通过父类的引用调用重写的方法

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

Employee boss = new Manager("张三",24,12000);
/**
*此时父类和子类中都有setSalary()方法，编译器在编译代码时并不知道
*要调用Employee中的方法还是Manager中的方法，等程序运行起来后，变量
*boss引用的具体对象确定后，才知道要调用那个方法。明显这里boss引用
*Manager，所以回调用Manager类中的getSalary方法。
*/
boss.getSalary();

3.多态的优缺点

1.多态的优点

• 能够降低代码的复杂度，避免大量使用if-else
• 拓展能力更强

2.多态的缺陷

• 属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己
的成员属性

• 构造方法没有多态性

结语：每个人的成长和进步都离不开点点滴滴的积累，如果小编的内容对您有所帮助，希望友友们三连加关注哦，你的支持是小编创作的最大动力。