面向对象编程三大特性------封装、继承、多态(概念理解，应用举例)

1.面向对象&面向过程

面向过程思想

• 步骤清晰简单，第一步做什么，第二步做什么....
  
• 面向过程适合处理一些简单的问题。
  

面向对象思想

• 物以类聚，在思考问题解决方案时会先将问题进行分类，然后对这些分类的问题进行深入思考。最后才是对问题的实现细节进行面向过程的思考。
  
• 面向对象适合对大型项目的构建，对复杂问题的解决，适合处理需要多人协作的问题。
  

对于复杂问题从宏观上通过面向对象进行解析，在实现细节上面进行面向过程的分析。

什么是面向对象

从面向对象编程的本质而言：以类的形式组织代码，以对象的组织(封装)数据。
从代码运行的角度上来看，是先有类后有对象，类是对象的模板。

封装

1.概念理解

在OOP中，封装（encapsulation）是指对于某个对象，Java隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节，但可以通过该对象对外的提供的接口来访问该对象。
对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有三大好处：
①良好的封装能够减少耦合。
②类内部的结构可以自由修改。
③可以对成员变量进行更精确的控制。
④隐藏信息，实现细节。

2.应用举例

1. class Member {
2.     public String name;//公共属性name
3.     public int salary;//公共属性salary
4.     private String sex;//私有属性sex
5.     public String hobby;
6.     public void setSex(String sex) {//定义一个公共的方法来设置sex属性
7.         this.sex=sex;
8.     }
9.     public String getSex() {//定义一个公共的方法来获取sex属性
10.         return this.sex;
11.     }
12.     public void setHobby(String hobby) {//定义一个公共的方法来设置hobby属性
13.         this.hobby=hobby;
14.     }
15.     public String getHobby() {//定义一个公共的方法来获取hobby属性
16.         return this.hobby;
17.     }
18.     public void behavior() {//定义一个公共的方法talk
19.         System.out.println(name+"在王者峡谷嘎嘎乱杀！");
20.     }
21. }
22. public class 封装 {
23.     public static void main(String[] args) {
24.         Member m=new Member();
25.         m.name="xiaowang";//对公共属性name直接赋值
26.         m.salary=8000;//对公共属性salary也可以直接赋值
27.         m.setSex("男");//对私有属性操作，要通过get来访问、set来更改的方法
28.         m.setHobby("打游戏");//同上
29.         System.out.println("姓名:"+m.name+",性别:"+m.getSex()
30.                 +",薪水:"+m.salary+",爱好:"+m.getHobby()+"!");
31.         m.behavior();//可以调用Member类中的公共方法talk
32.     }
33. }

复制代码

运行结果如下：


继承

1.概念理解

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

继承所描述的是“is-a”的关系，如果有两个对象A和B，若可以描述为“A是B”，则可以表示A继承B，其中B是被继承者称之为父类或者超类，A是继承者称之为子类或者派生类。

实际上继承者是被继承者的特殊化，它除了拥有被继承者的特性外，还拥有自己独有得特性。例如猫有抓老鼠、爬树等其他动物没有的特性。同时在继承关系中，继承者完全可以替换被继承者，反之则不可以，例如我们可以说猫是动物，但不能说动物是猫就是这个道理，其实对于这个我们将其称之为“向上转型”。

继承的本质：是对一批类的抽象，从而实现对现实世界更好的建模。
2.继承的关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
extends：意思是“扩展”，子类是父类的扩展。而Java中只有单继承没有多继承(但一个父类可以有多个子类)，所以说extends只能继承一个父类。
implements关键字：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

this和super的区别：
①super关键字：代表的是父类空间的引用。this关键字：代表的是所属函数的调用者对象。
②super关键字：必须要有继承关系才能使用。this关键字：不需要存在继承关系也可以使用。
③super关键字：调用父类的构造函数。this关键字：调用本类的构造函数。

super：也可以继承父类中被子类覆盖的方法

3.应用举例

1. class Animals {//定义父类Animals
2.     public void getEat() {//定义一个公共方法
3.         System.out.println("很多动物正在吃饭!");
4.     }
5.     public void getEating(){
6.         System.out.println("wkkk");
7.     }
8. }
9. class Dog extends Animals {//定义子类Dog，继承了父类Animals
10.     public void getEat() {
11.         System.out.println("它是狗,正在吃骨头!");
12.     }
13.     public void getEating() {
14.         this.getEat();//调用本类的方法getEat()
15.         super.getEat();//调用父类的方法getEat()
16.     }
17. }
18. class Cat extends Animals {//这个与子类Dog是完全一样的
19.     public void getEat() {
20.         System.out.println("它是猫,正在喝牛奶!");
21.     }
22.     public void getEating() {
23.         super.getEating();
24.         this.getEat();
25.         super.getEat();
26.     }
27. }
28. public class 继承 {
29.     public static void main(String[] args){
30.         Animals a=new Animals();
31.         a.getEat();
32.         Dog b=new Dog();
33.         b.getEating();
34.         Cat c=new Cat();
35.         c.getEating();
36.     }
37. }

复制代码

多态

1.概念理解

多态是同一个行为具有多个不同表现形式或形态的能力，多态性是对象多种表现形式的体现。
多态实质上就是同一个接口，使用不同的实例而执行不同操作。

多态的优点

①消除类型之间的耦合关系。
②可替换性。
③可扩充性。
④接口性。
⑤灵活性。
⑥简化性。

多态存在的三个条件

①继承。（子类继承父类，也可以是非抽象子类继承抽象父类）
②重写。 （子类对父类中方法的重写）
③父类引用子类对象。（向上转型，也可以通过向下转型再转换回来）
当使用多态方式调用某个方法时，首先检查父类中是否有该方法，如果没有，则编译的时候会报错；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

2.应用举例

1. class Animal {
2.         public void hobby() {
3.                 System.out.println("动物的叫声有很多种！");
4.         }
5. }
6. class Cat extends Animal {
7.         public void hobby() { //子类重写父类的 hobby 方法
8.                 super.hobby(); //要想调用父类中被重写的方法，必须使用 super 关键字
9.                 System.out.println("猫：喵喵喵！");
10.         }
11. }
12. class Dog extends Animal { //Dog 子类的理解和上面的 Cat 子类是一样的
13.         public void hobby() {
14.                 super.hobby();
15.                 System.out.println("狗：汪汪汪！");
16.         }
17. }
18. public class Study {
19.         public static void main(String[] args) {
20.                 Animal a=new Cat(); //父类声明对象，子类实例化对象，即向上转型
21.                 a.hobby();
22.                 Animal b=new Dog(); //父类声明对象，子类实例化对象，即向上转型
23.                 b.hobby();
24.         }
25. }

复制代码

以上是我个人对面向对象的三个特点的理解，结合一些网课课程的笔记，如有错误，欢迎大佬指点。

以下是网课的地址，需要的可以自行提取
网课地址