面向对象、面向过程、抽象类和接口：简单易懂原理解析

灰太狼 2022-05-12 05:14 89阅读 0赞

首先说明这篇文章我借鉴了很多篇，然后通过自己的理解+抄袭总结了以下内容，感谢被我偷窥过的各位大大！

**面向对象和面向过程**

面向过程：以过程为中心，是一种按部就班的，程序员根据每一个步骤来编程的思维方式。遇到问题的时候，首先是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用。优点：**性能高**

面向对象：一切都是对象，用属性来描述对象的特征，用类来代表具有相同属性的对象。以对象为中心，是一种基于对象进行统筹规划，建立模型的思维方式。遇到问题的时候，首先把构成问题的事务分解成各个对象，然后通过对象去描述某个事务在解决问题的某一类行为，而不是某一个步骤。缺点：**性能比面向过程低**

通过例子来解释面向过程和面向对象，比如五子棋。面向过程的设计思路是先分析五子棋步骤：开始游戏--黑棋先走--绘制画面--判断输赢--轮到白棋--绘制画面--判断输赢，然后重复游戏步骤，把每个游戏步骤用不同的方法函数来实现。**面向过程需要关注每一个步骤，就相当于把代码写死了，缺少了灵活性，不容易扩展和维护**。

而面向对象针对五子棋的设计思路，分为三个对象：

①棋子行为对象：把五子棋分为黑白双方，因为黑白棋的行为是一样的

②棋盘对象：负责绘制下棋画面

③规则对象：负责判断黑白棋输赢

棋子行为对象产生了行为，棋盘对象就绘制棋子布局的变化画面，规则对象再判断输赢。**面向对象不用去关心每一步都做了什么，写出来的系统就很容易维护，代码也容易复用和扩展，而且由于面向对象的封装、继承、多态的特性，可以有效达到低耦合的目的**。

**面向对象四大特性之抽象**

忽略一个主题中和当前目标无关的东西,只关心和当前目标有关的方面。也就是说，把现实世界中的某一类东西，提取出来，用程序代码表示，抽象出来的一般叫做类或者接口。**抽象并不打算了解全部问题****，****而是选择其中的一部分**。

抽象包括两个方面：

数据抽象：世界中某一类事物的特征，也就是对象的属性

过程抽象：世界中某一类事物的行为，也就是对象的行为

**面向对象四大特性之封装**

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能的**隐藏对象内部的细节，用户通过该对象对外提供的接口来访问该对象****。**系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。比如封装一个实体类，setter()、getter()就是一种封装方式，如果不想它的一些属性被外界访问，就不提供getter()方法。如果想改变属性的赋值类型或者赋值格式，用户不需要在实现类里一个个改变，只需要在封装类的setter()方法里设置。

封装的**优点**：

①良好的封装能够减少耦合

②封装类内部的结构可以自由修改

③可以对封装类的成员进行更精确的控制

④隐藏对象的信息和实现细节

**面向对象四大特性之继承**

**继承的本质是在已有的类的基础上进行扩充或改造，得到新的方法，以满足新的需要**。当一个类A能够获取另一个类B中所有非私有的成员属性和行为时，就称这两个类之间具有继承关系。被继承的类B成为父类或超类（superclass）继承了父类或超类的属性和行为的类A成为子类（subclass）。继承定义了类如何相互关联，共享特性。

继承的优点：**代码复用，降低代码冗余度，提高效率**，缺点：

①父类改变了，子类也跟着改变

②继承破坏了封装，父类的实现细节对于子类来说都是透明的

③继承是一种强耦合关系

使用继承的注意点：

①子类拥有父类非private的属性和方法。

②子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

③子类可以用自己的方式实现父类的方法，即对父类重写。

关于继承，需要注意**构造器、protected关键字和向上转型**这三个词。

①对于构造器，它只能够被调用，而不能被继承。子类会调用父类的默认构造器，但是如果没有默认的父类构造器，子类必须要显示的指定父类的构造器，而且必须是在子类构造器中做的第一件事，在第一行就指定调用。

②protected关键字指明对于类用户来说，它是private私有的，但是对于继承这个类的子类或者同一个包的类来说，它却是可以访问的。可以使用protected访问修饰符来限制父类属性和方法的访问权限，但最好还是将属性保持为private，通过protected方法来控制。好处：保留更改底层的实现。

③向上转型就是将子类转换成父类，在继承关系上面是向上移动的。向上转型的父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在子类，父类没有的方法和属性，它就无法调用了。比如子类有属性A，方法B，而父类里没有，即子类没有重写父类的方法，那父类类型的引用就无法调用属性A和方法B了(方法被重载也无法调用)。而如果子类重写了父类里的方法，那么在调用同名方法的时候，必定是使用子类定义的方法，这就是动态连接、动态调用，即**当子类重写父类的方法被调用时，只有对象继承链中的最末端子类的方法才会被调用****。**向上转型有两种实现方式：

①父类调用自身的方法，传入子类对象的引用

public class Person {
    
        public void display(){
    
            System.out.println("Play Person...");
    
        }
    
       
    
        static void display(Person person){
    
            person.display();
    
        }
    
    }
    
    
    
    public class Husband extends Person{
    
        public static void main(String[] args) {
    
            Husband husband = new Husband();
    
            Person.display(husband); //向上转型，这里husband是person类型
    
        }
    
    }

②指向子类的父类引用，即实例化对象的时候使用父类的类名，但是new的时候使用的是子类的类名。

public class Wine {
    
        public void fun1(){
    
            System.out.println("Wine 的Fun.....");
    
            fun2();
    
        }
    
        
    
        public void fun2(){
    
            System.out.println("Wine 的Fun2...");
    
        }
    
    }
    
    
    
    public class JNC extends Wine{
    
    //子类重载了父类的fun1()方法，所以向上转型后，父类无法调用JNC的fun1()
    
        public void fun1(String a){
    
            System.out.println("JNC 的 Fun1...");
    
            fun2();
    
        }
    
        
    
    /* 子类重写了父类的fun2()方法，所以向上转型后， 指向子类的父类引用调用fun2()时，必定是调用JNC的fun2() */
    
        public void fun2(){
    
            System.out.println("JNC 的Fun2...");
    
        }
    
    }
    
    
    
    public class Test {
    
        public static void main(String[] args) {
    
            Wine a = new JNC();
    
            a.fun1();
    
        }
    
    }

控制台输出:

Wine的Fun......

JNC的Fun2......

**面向对象四大特性之多态**

**多态就是****指在父类中定义的方法被子类继承后，****子类重写父类的方法****表现出不同的行为****，****使得同一个方法在父类及其各个子类中具有不同的****含义。所以调用哪个类的实现方法在编程时无法确定，需要到运行期间才能知道**。

优点：不用修改源代码，子类通过重写就可以控制某个方法实现的行为。

实现条件：类之间有继承关系，子类重写了父类的方法

判断题：在java的多态调用中，new的是哪一个类就调用哪个类的方法。（ X ）

如果是重写进行的多态调用，运用的就是动态单分配，就是根据new的类型确定对象，从而确定调用的方法。说法正确。

如果是重载进行的多态调用，运用的就是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法。说法错误。

**抽象类和接口之抽象类**

**抽象类提供了继承的概念，定义的抽象类都是用来继承的，在一个以抽象类为节点的继承关系等级链中，叶子节点一定是具体的实现类**。如果一个抽象类是Animal动物，那么就可以创建子类Cat猫、Dog狗来继承它，子类并必须实现它的抽象方法。创建抽象类和抽象方法可以使类的抽象性明确起来，并告诉用户和编译器打算怎样使用他们。抽象类还是有用的重构器，使用抽象类可以很容易的将公共方法沿着继承层次结构向上移动。注意：

①抽象类不能被实例化，实例化的工作由子类完成，它只需要有一个引用即可

②子类必须重写抽象类的抽象方法

③只要包含了一个抽象方法，不管是否还包含其他方法，都必须把它定义成抽象类

④抽象类中可以包含具体的方法，也可以不包含抽象方法

⑤子类的抽象方法不能和父类的抽象方法同名

⑥关键字abstract不能和final并列修饰同一个类

⑦关键字abstract不能和private、static、final、native并列修饰同一个方法

**抽象类和接口之接口**

①接口中所有方法都是public的

②接口只有不可变的常量

③接口中的方法都是没有实现的

④实现接口的非抽象类必须实现该接口的所有方法，抽象类可以不用实现

⑤不能用new操作符实例化一个接口，但可以声明一个接口变量，该变量必须引用一个实现该接口的类的对象

**抽象类和接口的区别**

①抽象层次不同。抽象类是对类(属性、行为)抽象，而接口是对行为抽象

②跨域不同。抽象类体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在“**is-a**”关系，即父类和派生类在概念本质上应该是相同的。而接口并不要求接口的实现者和接口的定义在概念本质上一致，接口的实现者仅仅实现了接口定义的契约，是一个“**like-a**”关系。另一种说法是接口既然是对行为的抽象，那么应该是“**has-a**”关系。我个人比较倾向于“**like-a**”。

③设计层次不同。抽象类是自下而上设计的，要先知道子类才能抽象出父类。而接口是自上而下设计的，它不需要知道子类的存在，只需要定义一个规则，定义好一个需要的行为接口，不用关心怎么去实现。