面向对象三大特性的总结

一、封装

封装是一种对类的保护机制，防止该类的属性、方法及数据被外部类随意地访问。因此被封装的内容对外部类而言应该是隐藏的，如果外部类需要访问它们的话，必须通过该类提供的合法途径进行访问。如此，可以实现对类中数据的可控保护并且将内部的实现细节隐藏起来，外部只需要按要求使用即可，无需过于关心内部细节。

1.1 将成员私有化

最直观简洁的封装例子就是对类中成员变量使用private进行封装了，例子如下：

public class Animal {
    private String name;
    // 外部只能通过getter获取name的数据
    public String getName() {
        return name;
    }
    // 外部只能通过setter修改name的数据
    public void setName(String name) {
        this.name = name;
    }
}

1.2 使用package

使用package可以更好地组织类，通常也有以下的一些好处：

可以按照功能或者模块将相关的类或者接口组织在同一个包中，方便查找和使用，也使系统代码的逻辑易于区分。
包采用了树形目录的存储方式，同一个包中的类名一定不同，不同包中的类名可以相同，当需要使用相同的类名时可以在类名前面加上包名来指定使用哪一个。
包的存在具有访问权限，只有在同一包中类才能访问彼此的default类型的成员。

1.3 使用访问修饰符

访问修饰符	本类	同包	子类	其它
private	Y	N	N	N
default	Y	Y	N	N
protected	Y	Y	Y	N
public	Y	Y	Y	Y

关于protected需要重点说明一下，这里的子类可以访问指的是在子类的内部可以访问，main方法不算内部，而在非子类中，即使拥有父类或者子类的引用，也是不能访问父类的protected内容的。比如：

package cn.zx.test;

public class Animal {   
    private String name;
    String age;
    protected String legs;
    public String color;
}

package cn.zx.tset;

import cn.zx.test.Animal;

public class Dog extends Animal {
    public Dog(){
        // 可以访问到legs
        System.out.println(super.legs);
        System.out.println(this.legs);
    }
    public static void main(String[] args) {
        Animal a = new Dog();
        // 以下语句编译不通过，取不到legs
        System.out.println(a.legs);
    }
}

package cn.zx.tset;

import cn.zx.test.Animal;

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        // 以下语句编译不通过，取不到legs
        System.out.println(a.legs);
    }
}

1.4 使用this关键字

通过this指代当前对象，在当前对象内部，可以通过this来访问该对象的属性，获取数据并调用其方法。

比如setter和getter中的this的使用。

1.5 使用内部类

内部类也很好地实现了面向对象中关于封装的特性，由于内部类比较重要，单独写了一篇文章，请参考《内部类有哪些？它们存在的意义是什么？》

二、继承

2.1 继承的定义

继承是一种描述类与类之间通用到细分，抽象到具体的关联关系。子类与父类是一种is-a的关系，比如dog is a mammal,jack is a human等，继承可以更方便地描述物理世界中真实的父与子的关系，除此之外，还可以将多个子类中共同的部分抽离出来形成父类，实现代码稳定部分的封装，也大大提高了代码的复用性。

通常继承在使用过程中需要注意以下几点：

子类默认拥有父类中除了private以外的所有属性和方法。
子类可以额外增加自己的属性和方法。
子类可以重写父类的方法。
一个类只能继承一个父类。

2.2 重写父类方法

如果子类对从父类继承来的方法不满意，想在里面加入适合自己的一些操作时，就可以将方法进行重写。并且子类在调用方法中，优先调用子类自己的方法。

当然在方法重写时我们需要注意，重写的方法一定要与原父类的方法语法保持一致，比如返回值类型，参数类型及个数，和方法名都必须一致。

2.3 父类与子类的加载顺序

继承的初始化顺序是先初始化父类再初始化子类。

当你需要在子类中访问父类的属性或者调用父类的方法及父类的构造方法时，可以使用super。

2.4 使用final防止继承

final的用法非常多：

当其修饰类的时候，表示该类不能被继承。
当其修饰方法的时候，表示该方法不能被重写。
当其修饰类属性的时候，则该类属性不会被默认初始化，而是需要手动赋值。
当其修饰变量的时候，表示该变量只能赋值一次，为常量。

三、多态

多态也称为动态绑定，是指在执行期间才来判断所引用对象的实际类型，再根据其实际的类型调用相应的方法。通俗地讲，只通过父类就能够引用不同的子类，这就是多态，我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

3.1 向上转型

Animal a = new Dog()这就是一个向上转型，使用向上转型，有以下需要注意的事项：

我们可以使用一个父类的引用实际指向一个子类的对象，但不能反过来。
使用向上转型我们可以通过该引用来获取父类的所有属性和方法，以及子类扩展的属性。但无法再获取子类扩展的方法。
对于子类重写了父类的方法的情况，该引用会优先调用子类中重写的方法。

具体看个例子：

public class Animal {
    private String name = "plutor";
    public void bark(){
        System.out.println("I am " + name);
    }
}

public class Dog extends Animal {
    private String age = "4";
    @Override
    public void bark() {
        super.bark();
        System.out.println("my age is " + age);
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        // 优先使用子类中重写的方法
        a.bark();
        // 无法使用子类中扩展的方法，以下语句编译不通过
        a.sleep();
    }
}

3.2 抽象类和接口

什么时候使用抽象类？

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。
从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

抽象类的规则

用 abstract 修饰符定义抽象类。
用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
包含抽象方法的类就是抽象类。
抽象类中可以包含普通的方法，也可以没有抽象方法。
抽象类的对象不能直接创建，我们通常是定义引用变量指向子类对象。

接口比抽象类更进一步，完全不包含任何实现的方法体。

接口不能用于实例化对象。
接口中所有的方法是抽象方法。
接口中的成员变量只能是 static final 类型的。
接口支持多继承，比如public interface A extends B,C{}。