面向对象

面向对象概述

面向对象和面向过程的区别

面向过程：

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式

开发、Linux/Unix等一般采用面向过程开发，能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象：

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系

统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低

面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步

一步的实现。

1 public static void main(String[] args) {

2 ok:

3 for (int i = 0; i < 10; i++) {

4 for (int j = 0; j < 10; j++) {

5 System.out.println("i=" + i + ",j=" + j);

6 if (j == 5) {

7 break ok;

8 }

9

10 }

11 }

12 }面向对象是模型化的，你只需抽象出一个类，这是一个封闭的盒子，在这里你拥有数据也拥有解决问题

的方法。需要什么功能直接使用就可以了，不必去一步一步的实现，至于这个功能是如何实现的，管我

们什么事？我们会用就可以了。

面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用的就是面向对象

了。

面向对象三大特性

面向对象的特征有哪些方面

面向对象的特征主要有以下几个方面：

抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行 为抽象两方面。抽象只

关注对象有哪些属性和行为，并不关注这些行为的细节是 什么。

封装 : 封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如 果属性不想

被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没 有提供给外界访问的方法，那

么这个类也没有什么意义了。

继承 : 继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新 的数据或新

的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用 继承我们能够非常方便地复用

以前的代码。

关于继承如下 3 点请记住：

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

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

3.子类可以用自己的方式实现父类的方法。

多态 : 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出 的方法调用

在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到 底会指向哪个类的实例对象，

该引用变量发出的方法调用到底是哪个类中实现的 方法，必须在由程序运行期间才能决定。

在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口 （实现接口并覆盖

接口中同一方法）。

其中Java 面向对象编程三大特性：封装 继承 多态

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便 于使用，提高复用性和

安全性。

继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以 增加新的数据或新的功

能，也可以用父类的功能，但不能选择性地继承父类。通 过使用继承可以提高代码复用性。继承是多态

的前提。

关于继承如下 3 点请记住：

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

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

3. 子类可以用自己的方式实现父类的方法。

多态性：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提 高了程序的拓展性。

在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口 （实现接口并覆盖接口

中同一方法）。

方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重 写（override）实现的是

运行时的多态性（也称为后绑定）。一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是 哪个类中实现的方法，

必须在由程序运行期间才能决定。运行时的多态是面向对 象精髓的东西，要实现多态需要做两件事：

方法重写（子类继承父类并重写父类中已有的或抽象的方法）；

对象造型（用父类型引用子类型对象，这样同样的引用调用同样的方法就会根据 子类对象的不同而

表现出不同的行为）。

什么是多态机制？Java语言是如何实现多态的？

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出 的方法调用在编程时并

不确定，而是在程序运行期间才确定，即一个引用变量倒 底会指向哪个类的实例对象，该引用变量发出

的方法调用到底是哪个类中实现的 方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具

体的类，这 样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而 导致该引用

调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时 所绑定的具体代码，让程序可以选

择多个运行状态，这就是多态性。 多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要

是指方法的 重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不 同的函数，

在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来 实现的，也就是我们所说的多态性

多态的实现

Java实现多态有三个必要条件：继承、重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的 方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具 备技能调用父类的方法

和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现 代码处理不同的对象，

从而达到执行不同的行为。

对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类 对象时，被引用对象的

类型而不是引用变量的类型决定了调用谁的成员方法，但 是这个被调用的方法必须是在超类中定义过

的，也就是说被子类覆盖的方法。

面向对象五大基本原则是什么（可选）

单一职责原则SRP(Single Responsibility Principle)类的功能要单一，不能包罗万象，跟杂货铺似

的。

开放封闭原则OCP(Open－Close Principle)

一个模块对于拓展是开放的，对于修改是封闭的，想要增加功能热烈欢迎，想要修改，哼，

一万个不乐意。

里式替换原则LSP(the Liskov Substitution Principle LSP)子类可以替换父类出现在父类能够出现的

任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~

依赖倒置原则DIP(the Dependency Inversion Principle DIP)高层次的模块不应该依赖于低层次的

模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。就是你出

国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx

市，xx县。你要依赖的抽象是中国人，而不是你是xx村的。

接口分离原则ISP(the Interface Segregation Principle ISP)

设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有

打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的

多。

类与接口参

数

抽象类

接口

声

明

抽象类使用abstract关键字声明

接口使用interface关键字声明

实

现

子类使用extends关键字来继承抽象类。如果子类

不是抽象类的话，它需要提供抽象类中所有声明

的方法的实现

子类使用implements关键字来实现

接口。它需要提供接口中所有声明的

方法的实现

构

造

器

抽象类可以有构造器

接口不能有构造器

访

问

修

饰

符

抽象类中的方法可以是任意访问修饰符

接口方法默认修饰符是public。并且

不允许定义为 private 或者

protected

多

继

承

一个类最多只能继承一个抽象类

一个类可以实现多个接口

字

段

声

明

抽象类的字段声明可以是任意的

接口的字段默认都是 static 和 final

的

抽象类和接口的对比

抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。

从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

相同点

接口和抽象类都不能实例化

都位于继承的顶端，用于被其他实现或继承

都包含抽象方法，其子类都必须覆写这些抽象方法

不同点

备注：Java8中接口中引入默认方法和静态方法，以此来减少抽象类和接口之间 的差异。

现在，我们可以为接口提供默认实现的方法了，并且不用强制子类来实现它。 接口和抽象类各有优缺

点，在接口和抽象类的选择上，必须遵守这样一个原则：

行为模型应该总是通过接口而不是抽象类定义，所以通常是优先选用接口，尽量 少用抽象类。

选择抽象类的时候通常是如下情况：需要定义子类的行为，又要为子类提供通用 的功能。

普通类和抽象类有哪些区别？

普通类不能包含抽象方法，抽象类可以包含抽象方法。

抽象类不能直接实例化，普通类可以直接实例化。抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承， 这样彼此就会产生矛

盾，所以 final 不能修饰抽象类

创建一个对象用什么关键字？对象实例与对象引用有何不同？

new关键字，new创建对象实例（对象实例在堆内存中），对象引用指向对象实 例（对象引用存放在栈

内存中）。一个对象引用可以指向0个或1个对象（一根 绳子可以不系气球，也可以系一个气球）;一个

对象可以有n个引用指向它（可以 用n条绳子系住一个气球）