封装
封装也叫作信息隐藏或者数据访问保护。类通过暴露有限的访问接口，授权外部仅能通过类提供的方式来访问内部信息或者数据。它需要编程语言提供权限访问控制语法来支持，例如 Java 中的 private、protected、public 关键字。封装特性存在的意义，一方面是保护数据不被随意修改，提高代码的可维护性；另一方面是仅暴露有限的必要接口，提高类的易用性。
/**
* 用户info
* 存储用户id，爱好
* 用户ID是初始化中已经赋值的，不允许外部修改，只允许获取
* 爱好属性允许外部修改和获取
*/
class UserInfo {
private String id;//用户id
private String hobby;//爱好
public UserInfo() {
id = DB.getID();
}
public String getId() {
return id;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
用户id是唯一属性，不允许外部修改，它是需要被保护的数据，所以只提供了get方法。而爱好属性，允许外部修改，所以我们可以暴露方法对其进行修改。
当然，我们也可以使用public、protected、private等关键字来修饰变量和方法，达到外部安全操作内部变量的效果。
封装保证了数据的安全性，也减少了代码的暴露，进而提高了类的易用性。
抽象
抽象就是讲如何隐藏方法的具体实现，让使用者只需要关心方法提供了哪些功能，不需要知道这些功能是如何实现的。抽象可以通过接口类或者抽象类来实现，但也并不需要特殊的语法机制来支持。抽象存在的意义，一方面是提高代码的可扩展性、维护性，修改实现不需要改变定义，减少代码的改动范围；另一方面，它也是处理复杂系统的有效手段，能有效地过滤掉不必要关注的信息。
interface IPictureHelper{
boolean savePicture();//保存照片
boolean delPicture();//删除照片
}
class PictureHelper implements IPictureHelper{
@Override
public boolean savePicture() {
//doTask
return false;
}
@Override
public boolean delPicture() {
//doTask
return false;
}
}
在demo中，我们用一个interface类即可实现抽象。对于外部调用者来说，他们完全没必要关注内部方法的具体实现，只需要了解提供的哪些方法。
其实，抽象的实现不仅仅只是interface，同时还有abstract类。不过，对于抽象的思想，如果我们仔细观察“函数”这一语法机制，我们就能发现，“函数”包裹具体的实现逻辑，开发者在开发过程中只需要通过“函数”的命名、注释、文档等手段，都可以了解到其功能，而不必关注具体实现。这恰恰也是一种抽象的思想。
所以很多时候，我们只会讲面向对象三大特性，把抽象这一特性从中移除。
继承
继承是用来表示类之间的 is-a 关系，分为两种模式：单继承和多继承。单继承表示一个子类只继承一个父类，多继承表示一个子类可以继承多个父类。为了实现继承这个特性，编程语言需要提供特殊的语法机制来支持。继承主要是用来解决代码复用的问题。
class BaseClass {
public String tag;
}
class Sun extends BaseClass {
}
继承的好处是代码复用，子类可以重用父类中的代码。不过这也产生了弊端，过多的继承导致了层次结构的复杂，而且父类中代码有所修改，直接影响到了子类。所以有时候也会提倡“多组合少继承”的思路。
多态
多态是指子类可以替换父类，在实际的代码运行过程中，调用子类的方法实现。多态这种特性也需要编程语言提供特殊的语法机制来实现，比如继承、接口类、duck-typing。多态可以提高代码的扩展性和复用性，是很多设计模式、设计原则、编程技巧的代码实现基础。
// 父类 = 子类的实现
class BaseArray {
ArrayList<String> arrayList = new ArrayList<String>();
//父类添加value是放在数据尾部
public void add(@NotNull String value) {
if (value.equals(“”)) {
return;
}
arrayList.add(value);
}
}
class FirstArray extends BaseArray {
@Override
public void add(String value) {
if (value.equals("")) return;
//子类添加value是放在数据头部
arrayList.add(0, value);
}
}
public class Polymorphism {
public static void main(String[] args){
BaseArray array=new FirstArray();
array.add("1");
array.add("2");
//打印 ：2，1
}
}
以上代码中，在调用add的方法时，实际是子类代替了父类的实现，执行了子类的add方法，达到了多态的特性。
我把他理解为：父类等于子类的实现。
//接口=接口实现类
interface IPerson {
void say();
}
class Man implements IPerson {
@Override
public void say() {
System.out.println(“男的！！！”);
}
}
class Woman implements IPerson {
@Override
public void say() {
System.out.println(“女的～～～”);
}
}
class Demo {
public static void test(IPerson person) {
person.say();
}
}
public class Polymorphism {
public static void main(String[] args) {
Man man = new Man();
Demo.test(man);
Woman woman = new Woman();
Demo.test(woman);
//打印：
//男的！！！
//女的～～～
}
}
以上代码中，我们使用interface来实现多态。Man类和Woman类都实现了IPerson接口类，而在test方法中，我们只需要知道接口类的方法。当传入不同的实现类，调用的便是实现类的方法。
我把他理解为：接口等于接口实现类。
