目录
一、前言
今天总结一下关于Java的三大特性，封装，继承，多态。其实关于三大特性对于从事编程人员来说都是基本的了，毕竟只要接触Java这些都是先要认识的，接下来就系统总结一下。
二、封装
1.什么是封装？
封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
- 将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。
- 通过该类提供的方法来实现对隐藏信息的操作和访问。
- 隐藏对象的信息。
- 留出访问的对外接口。
举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。
2.封装的特点
- 对成员变量实行更准确的控制。
- 封装可以隐藏内部程序实现的细节。
- 良好的封装能够减少代码之间的耦合度。
- 外部成员无法修改已封装好的程序代码。
- 方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
- 便于修改，体高代码的可维护性。
3.封装的使用
使用 private 关键字来修饰成员变量。对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。private是一个权限修饰符，代表最小权限， 可以修饰成员变量和成员方法， 被private修饰后的成员变量和成员方法，只在本类中才能访问。代码示例：
public class Student { private String name; private int age; public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; }}分析：对于上面的一个实体对象，我想大家都已经很熟悉了。将对象中的成员变量进行私有化，外部程序是无法访问的。但是我们对外提供了访问的方式，就是set和get方法。而对于这样一个实体对象，外部程序只有赋值和获取值的权限，是无法对内部进行修改，因此我们还可以在内部进行一些逻辑上的判断等，来完成我们业务上的需要。
三、继承
1.什么是继承？
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。
2.继承的特点
1 只支持单继承，一个子类只允许有一个父类
2 子类可以拥有父类的属性和方法
3 子类可以拥有自己的属性和方法
4 子类可以重写父类的方法
5 可以声明父类，创建子类（又称作为父类装载子类）
例如：Person p=new Teacher();
(1) 声明什么样的类型，就只能调用什么类型的属性和方法
(2) 创建什么样的类型，就真正运行的什么类型的方法
提示： (1)和(2)称为向上转型， 例如：Person p=new Teacher();那么p只能调用Person类中的方法和属性，但实际上运行的是Teacher中所重写的方法，无法调用Teacher中的私有的方法
(3) 创建什么样的类型，就可以强转为什么类型
提示：例如： Person p=new Teacher();
Teacher t=(Teacher) p;
这种叫做向下转型，此时t调用的是创建的Teacher类型的相应属性和方法。
3.继承的优点
- 提高代码发复用性
- 父类的属性方法可以用于子类
- 可以轻松定义子类
- 使设计应用程序变得简单
4.继承的使用
4.1 继承的格式
class 父类 { ...} class 子类 extends 父类 {...}4.2 继承的演示
class Employee { String name; // 定义name属性 // 定义员工的工作方法 public void work() { System.out.println("尽心尽力地工作");}} class Teacher extends Employee {// 定义一个打印name的方法public void printName() {System.out.println("name=" + name); }} public class ExtendDemo01 {public static void main(String[] args) {// 创建一个讲师类对象Teacher t = new Teacher();// 为该员工类的name属性进行赋值t.name = "小明";// 调用该员工的printName()方法t.printName(); // name = 小明// 调用Teacher类继承来的work()方法t.work(); // 尽心尽力地工作 }}4.3 成员变量
当成员变量不重名时，对代码的访问是没有影响的，但是当成员的变量重名时，这个时候访问就会出现问题，例如：
class Fu {// Fu中的成员变量。int num = 5;} class Zi extends Fu {// Zi中的成员变量int num = 6;public void show() {// 访问父类中的numSystem.out.println("Fu num=" + num);// 访问子类中的numSystem.out.println("Zi num=" + num);}} class ExtendsDemo03 {public static void main(String[] args) {// 创建子类对象Zi z = new Zi();// 调用子类中的show方法z.show();}} 演示结果：Fu num = 6Zi num = 6子父类中出现同名的成员变量时，在子类中访问父类中的非私有成员变量时，需要使用super关键字来修饰父类成员变量，类似于this。例如：
class Zi extends Fu {// Zi中的成员变量int num = 6;public void show() {//访问父类中的numSystem.out.println("Fu num=" + super.num);//访问子类中的numSystem.out.println("Zi num=" + this.num);}} 演示结果：Fu num = 5Zi num = 64.4 成员方法
当成员方法出现重名时，我们则需要用到方法重写（Override）。
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
class Phone {public void sendMessage(){System.out.println("发短信");} public void call(){System.out.println("打电话");} public void showNum(){System.out.println("来电显示号码"); }}//智能手机类class NewPhone extends Phone {//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能public void showNum(){//调用父类已经存在的功能使用supersuper.showNum();//增加自己特有显示姓名和图片功能System.out.println("显示来电姓名");System.out.println("显示头像");}} public class ExtendsDemo06 {public static void main(String[] args) {// 创建子类对象NewPhone np = new NewPhone()；// 调用父类继承而来的方法np.call();// 调用子类重写的方法np.showNum();}}注意：这里在重写时，用到了super.父类成员方法，表示调用父类成员的方法。
4.5 构造方法
首先我们要回忆两个事情，构造方法的定义格式和作用。
1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
class Fu { private int n; Fu(){ System.out.println("Fu()"); }} class Zi extends Fu { Zi(){ // super（），调用父类构造方法 super(); System.out.println("Zi（）"); }} public class ExtendsDemo07{ public static void main (String args[]){ Zi zi = new Zi(); }} 输出结果：Fu（）Zi（）五、多态
1.什么是多态？
多态是同一个行为具有多个不同表现形式或形态的能力。
2.多态的特点
- 消除类型之间的耦合关系，实现低耦合
- 灵活性
- 可扩充性
- 可替换性
3.多态的使用
多态体现的格式：
父类类型 变量名 = new 子类对象；
变量名.方法名();
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
定义父类：
public abstract class Animal { public abstract void eat();}定义子类：
class Cat extends Animal { public void eat() { System.out.println("吃鱼"); }} class Dog extends Animal { public void eat() { System.out.println("吃骨头"); }}定义测试类：
public class Test { public static void main(String[] args) { // 多态形式，创建对象 Cat c = new Cat(); Dog d = new Dog(); // 调用showCatEat showCatEat(c); // 调用showDogEat showDogEat(d); showAnimalEat(c); showAnimalEat(d); } public static void showCatEat (Cat c){ c.eat(); } public static void showDogEat (Dog d){ d.eat(); } public static void showAnimalEat (Animal a){ a.eat(); }} 由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
4.引用类型转型
多态的转型分为向上转型与向下转型两种：
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
使用格式
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
使用格式：
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;
5.为什么要做转型？
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
定义类：
abstract class Animal { abstract void eat();} class Cat extends Animal { public void eat() { System.out.println("吃鱼"); } public void catchMouse() { System.out.println("抓老鼠"); }} class Dog extends Animal { public void eat() { System.out.println("吃骨头"); } public void watchHouse() { System.out.println("看家"); }}定义测试类：
public class Test { public static void main(String[] args) { // 向上转型 Animal a = new Cat(); a.eat(); // 调用的是 Cat 的 eat // 向下转型 Cat c = (Cat)a; c.catchMouse(); // 调用的是 Cat 的 catchMouse }}注意：此处在转换时，有时会出现转换异常的情况，例如：
public class Test { public static void main(String[] args) { // 向上转型 Animal a = new Cat(); a.eat(); // 调用的是 Cat 的 eat // 向下转型 Dog d = (Dog)a; d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】 }}这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
所以在转换前我们可以先做一个判断
public class Test { public static void main(String[] args) { // 向上转型 Animal a = new Cat(); a.eat(); // 调用的是 Cat 的 eat // 向下转型 if (a instanceof Cat){ Cat c = (Cat)a; c.catchMouse(); // 调用的是 Cat 的 catchMouse } else if (a instanceof Dog){ Dog d = (Dog)a; d.watchHouse(); // 调用的是 Dog 的 watchHouse } }}六、总结
以上就是小编收集的关于java的封装、继承、多态的知识点了，有问题的地方欢迎评论交流呀，期待和各位一起变强呀！！！
来源地址：https://blog.csdn.net/wct040923/article/details/130528785
