面试时被问到什么是面向对象OOP？看这篇就够了

什么是面向对象？这个问题经常是面试自我介绍之后的开场问题。面试官问这个问题的时候主要是看你对编程基本思路的了解，顺便在你答题的时候整理自己之后的面试思路。刚入行的同学们常常答不好这个问题，觉得这个问题大而空，网上看的介绍也比较抽象，往往会不重视这个问题，导致面试时一开始就处于被动局面。

1. 概念

面向对象程序设计(Object Oriented Programming)作为一种新方法，其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征，只能对事物特征和变化规律的一种抽象，且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。

面向对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。
面向对象程序设计方法是尽可能模拟人类的思维方式，使得软件的开发方法与过程尽可能接近人类认识世界、解决现实问题的方法和过程，也即使得描述问题的问题空间与问题的解决方案空间在结构上尽可能一致，把客观世界中的实体抽象为问题域中的对象。
面向对象程序设计以对象为核心，该方法认为程序由一系列对象组成。类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。在面向对象的程序设计中，对象是组成程序的基本模块。

2. 例子

是不是觉得概念抽象不好理解？没错OOP的特点就是抽象~

在面向对象编程中有着万物皆对象的说法。相对于面向过程，面向对象需要把事物抽象成对象也就是类，类由属性和方法组成，每个类有着自己的功能，外部只需要调用类的方法就能完成相应逻辑，比较符合人类思维。而面向过程是按照顺序一步一步执行逻辑，就像是解数学题。举个具体栗子来帮助了解。比如我们需要用程序装配一辆车行驶，分别使用面向过程和面向对象的方式来编写。

面向过程：

	void addChassis()
	{
		System.out.print("添加底盘");
	}
	void addWheel()
	{
		System.out.print("添加车轮");
	}
	void addBody()
	{
		System.out.print("添加车身");
	}	
	void addEngine()
	{
		System.out.print("添加发动机");
	}
	void addTransmissionCase()
	{
		System.out.print("添加变速箱");
	}	
	
	void assemble()
	{
		addChassis();
		addWheel();
		addBody();
		addEngine();
		addTransmissionCase();
	}
	void drive()
	{
		assemble();
		System.out.print("行驶");
	}

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。他的缺点在于不易维护，不易复用，不易拓展，比如我们需要换一种发动机，又或者换一种车来组装，就需要修改之前写过的源码。

面向对象：

public class Car {
    private String mChassis;
    private String mWheel;
    private String mBody;
    private String mEngine;
    private String mTransmissionCase;

    public String getmChassis() {
        return mChassis;
    }

    public void setmChassis(String mChassis) {
        this.mChassis = mChassis;
    }

    public String getmWheel() {
        return mWheel;
    }

    public void setmWheel(String mWheel) {
        this.mWheel = mWheel;
    }

    public String getmBody() {
        return mBody;
    }

    public void setmBody(String mBody) {
        this.mBody = mBody;
    }

    public String getmEngine() {
        return mEngine;
    }

    public void setmEngine(String mEngine) {
        this.mEngine = mEngine;
    }

    public String getmTransmissionCase() {
        return mTransmissionCase;
    }

    public void setmTransmissionCase(String mTransmissionCase) {
        this.mTransmissionCase = mTransmissionCase;
    }
    
    public void drive(){
        System.out.println("行驶");
    }
}

public static void main(String[] args) {
	String chassis = "底盘"；
	String wheel = "车轮";
	String body = "车身";
	String engine = "发动机";
	String transmissionCase = "变速箱";
 	Car car = new Car();
 	car.setmChassis(chassis);
 	car.setmWheel(wheel);
 	car.setmBody(body);
 	car.setmEngine(engine );
 	car.setmTransmissionCase(transmissionCase);
	car.drive();
}

使用面向对象的编程思想我们将车抽象为了一个Car类，这个类中有chassis,wheel,body,engine, transmissionCase这四个属性，并且提供了这些属性的get/set方法与drive方法。看上去代码比面向过程的代码要多出不少，但是易于维护，拓展和修改。如果我们需要换一种轮胎只需要调用setmWheel()就可以了，完全不需要动Car类中的代码。如果我们需要组装特定种类的车，我们还可以创建一个Car类的子类，如果是面向过程的话就需要重新写一遍所有代码来创建新的车子，所用的代码比面向对象要多得多。这里只是举例，其实我们还可以使用Build模式来重构这段代码，使其更符合面向对象思想，这里就不展开了。

可以看出面向对象相比与面向过程易维护，易扩展，易修改，而且更加符合人类的思维方式。那为什么面向过程还没有被淘汰呢？这就要说到面向对象的缺点了，类调用时需要实例化，开销比较大，比较消耗资源，因此从效率上来说面向过程要比面向对象的性能要高。单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

3. 三大特性

上面说的都是虚的，面试时各人由各人的说法，说出自己的理解就好，而面向对象三大特性则是实打实的知识点，如果你说不出来这关可过不去。

3.1 封装

将描述事物的数据和操作封装在一起，形成一个类；被封装的数据和操作只有通过提供的公共方法才能被外界访问（封装隐藏了对象的属性和实施细节），私有属性和方法是无法被访问的，表现了封装的隐藏性，增加数据的安全性。

还是用举例来理解，比如一个简单的计算功能，一个数和另外一个数相加，如果不封装那么每次使用相加功能都需要写逻辑

int a = 1 + 4;//计算1+4
int b = 3 + 2;//计算3+2
int c = 6 + 7;//计算6+7
System.out.print(a);
System.out.print(b);
System.out.print(c);

如果把这个相加的逻辑封装成一个类

public class Calculator(){
    public int add(a,b){
		return a+b;
	}
}

那么每次只需要调用add方法就行了，不需要每次都写一段逻辑，而且外部调用add方法并不知道具体实现逻辑，只需要关心返回结果就行。

3.2 继承

继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。

继承和封装一样可以减少重复代码。用之前举过的例子汽车来说，轿车和SUV都是汽车，它们的大体结构都相同，但是又有各自的特性。那么我们就可以把他们相同的部分也就是作为汽车都有的特性封装成一个父类Car，而各自独特的部分则放在轿车子类和SUV车子类中实现。

继承让类与类之间产生关系，为多态打下基础。

3.3 多态

态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

多态可以分为编译时多态和运行时多态，编译时多态是指方法的重载，运行时多态是指方法的重写。

3.3.1 重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   @Override
   /**
   * 重写父类Animal中的move方法
   */
   public void move(){
      System.out.println("狗可以跑");
   }
}
class Fish extends Animal{
   @Override
   /**
   * 重写父类Animal中的move方法
   */
   public void move(){
      System.out.println("鱼可以游");
   }
}

在这个例子中鱼和狗都重写了父类动物的move方法，鱼可以游，狗可以跑。当我们调用父类动物的move方法时，如果指向狗，那么move就是跑，指向鱼，move就是游，这就是父类move同一种方法的不同表现形式。

Animal animal = new Dog();
animal.move();//输出结果为狗可以跑
animal = new Fish();
animal.move();//输出结果为鱼可以游

3.3.2 重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

规则：

1. 被重载的方法必须改变参数列表(参数个数或类型不一样)；
2. 被重载的方法可以改变返回类型；
3. 被重载的方法可以改变访问修饰符；
4. 被重载的方法可以声明新的或更广的检查异常；
5. 方法能够在同一个类中或者在一个子类中被重载。
6. 无法以返回值类型作为重载函数的区分标准。

用之前的Car对象的构造方法举例重载

    public Car() {
    	//没有参数的构造
    }

    public Car(String mChassis) {
    	//只有地盘的构造
        this.mChassis = mChassis;
    }

    public Car(String mWheel, String mBody, String mEngine, String mTransmissionCase) {
    	//包含所有组件的构造
        this.mWheel = mWheel;
        this.mBody = mBody;
        this.mEngine = mEngine;
        this.mTransmissionCase = mTransmissionCase;
    }

3.3.3 重写和重载的区别

1. 重写是子类与父类之间的关系，是一种垂直关系；重载是同一个类中方法之间的关系，是水平关系
2. 重写只能由一个方法或者只能由一对方法产生关系；重载是多个方法之间的关系
3. 重写要求参数列表要相同；重载要求参数列表不同
4. 重写关系中，调用方法体是根据对象的类型（对象对应存储空间类型）决定，重载是根据调用的时候实参表和形参表来选择方法

4. 七大基本原则

面向对象除了三大特性还有七大基本原则。以前也说五大基本原则或者六大基本原则，迪米特法则和组合/聚合利用原则是后加的。

4.1 单一职责原则

单一职责原则的英文名称是Single Responsibility Principle,缩写为SRP。SRP的定义为：就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。

每一个职责都是变化的一个轴线，如果一个类有一个以上的职责，这些职责就耦合在了一起。这会导致脆弱的设计。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起，会影响复用性。例如：要实现逻辑和界面的分离。需要说明的一点是单一职责原则不只是面向对象编程思想所特有的，只要是模块化的程序设计，都需要遵循这一重要原则。

4.2 开闭原则

开闭原则的英文全称是Open Close Principle，缩写OCP。他是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的，灵活的系统。开闭原则的定义是：软件中的对象（类/模块/函数等）应该对于扩展是开放的，但是对于修改是关闭的。在软件生命周期内，因为变化、升级和维护等原因需要对软件原有代码修改时，可能会将错误引入原本已经经过测试的旧代码中，破坏原有系统。因此，当软件需要变化时，我们应该尽量通过扩展的方式来实现变化而不是通过修改原有代码来实现。我们面向对象的开发，我们最根本的任务就是解耦合。

4.3 里氏替换原则

里氏替换原则英文全称时Liskov Substitution Principle,缩写LSP。LSP的第一种定义是：如果对每一个类型为S的对象O1，都有类型为T的对象O2，使得以T定义的所有程序P在所有的对象O1都替换为O2时，程序P的行为没有发生变化，那么类型S是类型P的子类型。因为这种说话不太好理解，于是有了人话版本第二种定义：所有引用基类的地方必须能透明地使用其子类的对象。

所有引用父类的地方必须能透明地使用其子类的对象。子类可以扩展父类的功能，但不能改变父类原有的功能，即：子类可以实现父类的抽象方法，子类也中可以增加自己特有的方法，但不能覆盖父类的非抽象方法。当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

4.4 依赖倒置原则

依赖倒置原则英文全称是Dependence Inversion Principle,缩写是DIP。依赖倒置原则指代了一种特定的解耦形式，使得高层次的模块不依赖于低层次模块实现细节的目的，依赖模块被颠倒了。
几个关键点：

1. 高层次模块不应该依赖低层次模块，两者都应该依赖其抽象。
2. 抽象不应该依赖细节。
3. 细节应该依赖抽象。

在Java语言中，抽象就是指接口和抽象类，两者都是不能直接被实例化的，细节就是实现类，实现接口或继承抽象类而产生的类就是细节，其特点是可以直接被实例化。高层模块就是调用端。底层模块就是具体实现类。依赖倒置原则在Java中的表现就是：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。 如果类与类之间直接依赖于细节，那么他们之间就有了直接的耦合，当具体实现需要变化时，意味着要同时修改依赖者的代码，这限制了系统的可扩展性。

4.5 接口隔离原则

接口隔离原则英文全称是InterfaceSeregation Principles，缩写是ISP。ISP的定义是：客户端不应该依赖它不需要的接口。另一种定义是：类之间的依赖关系应该建立在最小的接口之上。接口隔离原则将非常庞大、臃肿的接口拆分成更小和更具体的接口，这样客户端将会只需要它们感兴趣的方法。接口隔离原则的目的是系统解开耦合，从而容易重构/更改和重新部署。

4.6 迪米特原则

迪米特原则英文全称Law of Demeter，缩写LOD，也称为最小知识原则。虽然名字不同，但描述的是同一个原则：一个对象应该对其他对象有着最小的了解。通俗的讲，一个类应该对自己需要耦合或调用的类知道的最少，类的内部如何实现与调用者或者依赖者没有关系，调用者或者依赖者只需要知道它需要的方法即可，其他一概不管。类与类之间的关系越密切，耦合度越大，当一个类发生改变时对另一个类的影响也就越大。

4.7 合成/聚合原则

合成/聚合原则英文全称Composite/Aggregate Reuse Principle，简称CARP。也称为合成复用原则，及尽量使用合成/聚合，尽量不要使用类继承。换句话说，就是能用合成/聚合的地方，绝不用继承。其实整个设计模式就是在讲如何类与类之间的组合/聚合。在一个新的对象里面通过关联关系（包括组合关系和聚合关系）使用一些已有的对象，使之成为新对象的一部分，新对象通过委派调用已有对象的方法达到复用其已有功能的目的。也就是，要尽量使用类的合成复用，尽量不要使用继承。

如果为了复用，便使用继承的方式将两个不相干的类联系在一起，违反里氏代换原则，哪是生搬硬套， 忽略了继承了缺点。继承复用破坏数据封装性，将基类的实现细节全部暴露给了派生类，基类的内部细节常常对派生类是透明的，白箱复用；虽然简单，但不安全，不能在程序的运行过程中随便改变；基类的实现发生了改变，派生类的实现也不得不改变；从基类继承而来的派生类是静态的，不可能在运行时间内发生改变，因此没有足够的灵活性。所以合成/聚合复用原则可以使系统更加灵活，类与类之间的耦合度降低，一个类的变化对其他类造成的影响相对较少，因此一般首选使用组合/聚合来实现复用；其次才考虑继承，在使用继承时，需要严格遵循里氏代换原则，有效使用继承会有助于对问题的理解，降低复杂度，而滥用继承反而会增加系统构建和维护的难度以及系统的复杂度，因此需要慎重使用继承复用。

以上就是面向对象7大原则，这其实也是设计模式的基本原则，23种常见设计模式都是按照这几个原则来设计的。

5. 总结

在简述什么是面向对象时从概念讲起，并举例说明。之后要阐述清楚三大特性和七大基本原则。从此可以衍生到设计模式的问题，常用的设计模式需要了解清楚，建议在学习三大特性七大原则的同时学习设计模式相互印证，光背概念是不行的，一定要知道在什么场景下适用于什么设计模式。自己模拟这些场景并且用相应的设计模式重构代码才能有助理解。这样在面试官问道这个问题的时候就可以不慌不忙的和他掰扯半小时，而不是说了一句OOP的概念后就陷入尴尬的沉默~