Java 面向对象编程的三大特性（封装、继承、多态）以及重写和重载

版权声明：本文由吴仙杰创做整理，转载请注明出处：http://www.javashuo.com/article/p-olibxwhm-er.html

1. 面向对象编程的三大特性

Java 面向对象编程有三大特性：封装、继承、多态。

1.1 封装（Encapsulation）

封装
: 隐藏对象的属性和实现细节，仅对外公开访问方法，控制在程序中属性的读和写的访问级别。

1.1.1 封装的目的

加强安全性和简化编程，使用者没必要了解具体的实现细节，而只要经过对外公开的访问方法，来使用类的成员。

1.1.2 封装的基本要求

1. 把全部的属性私有化。

2. 对每一个属性提供 getter 和 setter 方法。

3. 若是有一个带参的构造函数的话，那必定要写一个不带参的构造函数。

4. 建议重写 toString 方法，但这不是必须的。

1.2 继承（Inheritance）

继承
: 能够理解为，在一个现有类的基础之上，增长新的方法或重写已有方法，从而产生一个新类。

咱们在编写 Java 代码时，每个类都是在继承。由于在 Java 中存在一个全部类的父类（基类、超类）：java.lang.Object。

1.2.1 继承和权限

子类不能继承父类中访问权限为 private 的成员变量和方法，也不能继承父类的构造方法。子类能够重写父类的方法，及命名与父类同名的成员变量。

有时候咱们会有这样的需求：咱们须要将某些事物尽量地对这个世界隐藏，可是仍然容许子类的成员来访问它们。这个时候就须要使用到 protected。

类成员访问修饰符与访问能力之间的关系：

类型	private	无修饰	protected	public
同一类	可访问	可访问	可访问	可访问
同一包中的子类	不可访问	可访问	可访问	可访问
同一包中的非子类	不可访问	可访问	可访问	可访问
不一样包中的子类	不可访问	不可访问	可访问	可访问
不一样包中的非子类	不可访问	不可访问	不可访问	可访问

1.2.2 Java 中类的划分

Java 中类可分为如下三种：

• 普通类：使用 class 定义且不含有抽象方法的类。

• 抽象类：使用 abstract class 定义的类，它能够含有或不含有抽象方法。

• 接口：使用 interface 定义的类。

上述三种类存在如下的继承规律：

• 普通类能够继承（extends）普通类，能够继承（extends）抽象类，能够继承（implements）接口。

• 抽象类能够继承（extends）普通类，能够继承（extends）抽象类，能够继承（implements）接口。

• 接口只能继承（extends）接口。

注意：

• 上述的继承规律中，每种继承都有各自使用的关键字 extends 和 implements，不可混淆使用。

• 上述描述中，咱们没有对 implements 关键字使用实现这种说法，是由于从概念上来说，它也是一种继承关系，并且对于抽象类 implements 接口而言，它并不要求必定要实现这个接口中定义的方法。

各继承规律中的约束：

• 一个普通类或一个抽象类，要么继承一个普通类，要么继承一个抽象类，即所谓的单继承。

• 一个普通类或一个抽象类或一个接口，能够继承任意多个接口。

• 一个普通类继承一个抽象类后，必须实现这个抽象类中定义的全部抽象（abstract）方法，不然就只能被定义为抽象类。

• 一个普通类继承一个接口后，必须实现这个接口中定义的全部方法，不然就只能被定义为抽象类。

• 抽象类继承抽象类，或者实现接口时，能够部分、所有或者彻底不实现父类抽象类的抽象（abstract）方法或父类接口中定义的方法。

1.2.3 继承的优势

继承给咱们的编程带来的好处就是对原有类的复用（重用）。除了继承以外，咱们还可使用组合的方式来复用类。

所谓组合就是把原有类定义为新类的一个属性，经过在新类中调用原有类的方法来实现复用。从抽象概念上来说，新定义类所表明的事物是原有类所表明的事物的一种，那么这时组合就是实现复用更好的选择。下面这个例子就是组合方式的一个简单示例：

/**
 * 宝马
 */
public class BMW {

    private Car car = new Car();
    
    public void driveBMW() {
        // 复用汽车类的通用驾驶方法
        car.drive();
        // 再写宝马车的特定驾驶方法
    }
}

/**
 * 汽车
 */
class Car {

    public void drive() {
        // 开车
    }
}

使用继承和组合复用原有的类，都是一种增量式的开发模式，这种方式带来的好处是不须要修改原有的代码，所以不会给原有代码带来新的 BUG，也不用由于对原有代码的修改而从新进行测试，这对咱们的开发显然是有益的。所以，若是咱们是在维护或者改造一个原有的系统或模块，尤为是对它们的了解不是很透彻的时候，就能够选择增量开发的模式，这不只能够大大提升咱们的开发效率，也能够规避因为对原有代码的修改而带来的风险。

1.3 多态（Polymorphism）

多态
: 相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不一样。

如下的例子，可帮助理解：

/**
 * 汽车接口
 */
interface Car {
    // 汽车名称
    String getName();
    // 得到汽车售价
    int getPrice();
}

// 宝马
class BMW implements Car {

    public String getName() {
        return "BMW";
    }

    public int getPrice() {
        return 300000;
    }
}

// 奔驰
class BENZ implements Car {

    public String getName() {
        return "BENZ";
    }

    public int getPrice() {
        return 400000;
    }
}

// 汽车出售店
public class CarShop {
    // 售车收入
    private int money = 0;

    // 卖出一部车
    public void sellCar(Car car) {
        System.out.println("车型：" + car.getName() + "  单价：" + car.getPrice());
        // 增长卖出车售价的收入
        money += car.getPrice();
    }

    // 售车总收入
    public int getMoney() {
        return money;
    }

    public static void main(String[] args) {
        CarShop carShop = new CarShop();
        // 卖出一辆宝马
        carShop.sellCar(new BMW());
        // 卖出一辆奔驰
        carShop.sellCar(new BENZ());
        System.out.println("总收入：" + carShop.getMoney());
    }
}

运行结果：

车型：BMW  单价：300000
车型：BENZ  单价：400000
总收入：700000

继承是多态得以实现的基础。针对上面的示例，多态就是一种类型（都是 Car 类型）表现出多种状态（宝马汽车的名称是 BMW，售价是 300000；奔驰汽车的名称是 BENZ，售价是 400000）。

绑定
: 将一个方法调用同这个方法所属的主体（也就是对象或类）关联起来，分前期绑定和后期绑定两种。

• 前期绑定：在程序运行以前进行绑定，由编译器和链接程序实现，又叫作静态绑定。好比 static 方法和 final 方法，注意，这里也包括 private 方法，由于它是隐式 final 的。

• 后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，所以又叫作动态绑定，或者运行时绑定。除了前期绑定外的全部方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。

多态给咱们带来的好处是消除了类之间的耦合关系，使程序更容易扩展。好比在上例中，新增长一种类型汽车的销售，只须要让新定义的类继承 Car 类并实现它的全部方法，而无需对原有代码作任何修改，CarShop 类的 sellCar(Car car) 方法就能够处理新的车型了。

1.3.1 实现多态的三个必要条件

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

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

3. 向上转型：在多态中须要将子类的引用赋给父类对象，只有这样该引用才可以具有技能调用父类的方法和子类的方法。

只有知足了上述三个条件，咱们才可以在同一个继承结构中使用统一的逻辑实现代码处理不一样的对象，从而达到执行不一样的行为。

1.3.2 多态的实现方式

基于继承实现的多态
: 主要表如今父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写能够表现出不一样的行为。

基于接口实现的多态
: 在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。

接口是多继承多实现，它可以利用一组相关或者不相关的接口进行组合与扩充，可以对外提供一致的服务接口。因此它相对于继承来讲有更好的灵活性。

2. 重载（overloading）重写（overriding）

重载和重写都是针对方法的概念，在弄清楚这两个概念以前，咱们先来了解一下什么叫方法的型构（signature）。

型构
: 指方法的组成结构，具体包括方法的名称和参数，涵盖参数的数量、类型以及出现的顺序，可是不包括方法的返回值类型，访问权限修饰符，以及 abstract、static、final 等修饰符。

示例1、下面两个是具备相同型构的方法：

public void method(int i, String s) {
    // do something   
}

public String method(int i, String s) {
    // do something   
}

注意：在同一个类中，是不容许定义多于一个的具备相同型构的方法。

示例2、下面两个是具备不一样型构的方法：

public void method(int i, String s) {
    // do something   
}

public void method(String s, int i) {
    // do something   
}

了解完型构的概念后咱们再来看看重载和重写：

重写（overriding）
: 指在继承状况下，子类中定义了与其父类中方法具备相同型构的新方法，就称为子类把父类的方法重写了。这是实现多态必须的步骤。

重载（overloading）
: 指在同一个类中定义了一个以上具备相同名称，可是型构不一样的方法。

为了加深理解，咱们来考虑一个有趣的问题：构造器能够被重载吗？

答案固然是能够的，咱们在实际的编程中也常常这么作。实际上构造器也是一个方法，构造器名就是方法名，构造器参数就是方法参数，而它的返回值就是新建立的类的实例。可是构造器却不能够被子类重写，由于子类没法定义与父类具备相同型构的构造器。

3. 参考

• JAVA面试题解惑系列（九）——继承、多态、重载和重写

• java 面向对象三大特性（封装，继承，多态）以及抽象、接口的介绍