封装

信息隐藏或者数据保护，类通过暴露有限的对外访问接口提供访问或修改的功能，
现状问题，lombok太方便，其实不该使用的
1.id，gmt_create
2.钱包余额只会加减，不回设置
如果不做访问限制，那任何代码都可以随意访问或者修改属性，灵活性高但是可控性降低，比如新人无意修改id

public class Wallet {
    
    
  private String id;
  private long createTime;
  private BigDecimal balance;
  private long balanceLastModifiedTime;
  // ...省略其他属性...

  public Wallet() {
    
    
     this.id = IdGenerator.getInstance().generate();
     this.createTime = System.currentTimeMillis();
     this.balance = BigDecimal.ZERO;
     this.balanceLastModifiedTime = System.currentTimeMillis();
  }

  // 注意：下面对get方法做了代码折叠，是为了减少代码所占文章的篇幅
  public String getId() {
    
     return this.id; }
  public long getCreateTime() {
    
     return this.createTime; }
  public BigDecimal getBalance() {
    
     return this.balance; }
  public long getBalanceLastModifiedTime() {
    
     return this.balanceLastModifiedTime;  }

  public void increaseBalance(BigDecimal increasedAmount) {
    
    
    if (increasedAmount.compareTo(BigDecimal.ZERO) < 0) {
    
    
      throw new InvalidAmountException("...");
    }
    this.balance.add(increasedAmount);
    this.balanceLastModifiedTime = System.currentTimeMillis();
  }

  public void decreaseBalance(BigDecimal decreasedAmount) {
    
    
    if (decreasedAmount.compareTo(BigDecimal.ZERO) < 0) {
    
    
      throw new InvalidAmountException("...");
    }
    if (decreasedAmount.compareTo(this.balance) > 0) {
    
    
      throw new InsufficientAmountException("...");
    }
    this.balance.subtract(decreasedAmount);
    this.balanceLastModifiedTime = System.currentTimeMillis();
  }
}

抽象

隐藏方法的具体实现，让调用者只需要关心关心方法提供了哪些功能，而不需要直到这些功能是如何实现的
实现：接口、抽象类
现实案例，有一个方法实现了提交转码服务，底层无论是通过阿里云实现转码亦或是腾讯云转码，调用者都无感知，无需关心。

public interface IPictureStorage {
    
    
  void savePicture(Picture picture);
  Image getPicture(String pictureId);
  void deletePicture(String pictureId);
  void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo);
}

public class PictureStorage implements IPictureStorage {
    
    
  // ...省略其他属性...
  @Override
  public void savePicture(Picture picture) {
    
     ... }
  @Override
  public Image getPicture(String pictureId) {
    
     ... }
  @Override
  public void deletePicture(String pictureId) {
    
     ... }
  @Override
  public void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo) {
    
     ... }
}

继承

继承是用来表示类之间is - a的关系，比如猫是一种哺乳动物；从继承关系上讲，继承可以分为两种模式，单继承和多继承。单继承表示只继承一个父类，多继承表示一个子类可以继承多个父类，比如猫即使哺乳也是爬行动物，java只支持单继承，通过extends关键字来实现。

使用继承的好处是代码复用，比如两个类有一些相同的属性和方法就可以把公共方法抽象到父类中，两个子类继承父类。
注：通过组合方式也可以解决这个代码复用功能，多用组合少用继承，原因是继承层级越高，可读性和可维护性会变差

多态

多态是指，子类可以替换父类，实际运行过程中，通过传入不同子类，实现不同功能。

public class DynamicArray {
    
    
  private static final int DEFAULT_CAPACITY = 10;
  protected int size = 0;
  protected int capacity = DEFAULT_CAPACITY;
  protected Integer[] elements = new Integer[DEFAULT_CAPACITY];
  
  public int size() {
    
     return this.size; }
  public Integer get(int index) {
    
     return elements[index];}
  //...省略n多方法...
  
  public void add(Integer e) {
    
    
    ensureCapacity();
    elements[size++] = e;
  }
  
  protected void ensureCapacity() {
    
    
    //...如果数组满了就扩容...代码省略...
  }
}

public class SortedDynamicArray extends DynamicArray {
    
    
  @Override
  public void add(Integer e) {
    
    
    ensureCapacity();
    int i;
    for (i = size-1; i>=0; --i) {
    
     //保证数组中的数据有序
      if (elements[i] > e) {
    
    
        elements[i+1] = elements[i];
      } else {
    
    
        break;
      }
    }
    elements[i+1] = e;
    ++size;
  }
}

public class Example {
    
    
  public static void test(DynamicArray dynamicArray) {
    
    
    dynamicArray.add(5);
    dynamicArray.add(1);
    dynamicArray.add(3);
    for (int i = 0; i < dynamicArray.size(); ++i) {
    
    
      System.out.println(dynamicArray.get(i));
    }
  }
  
  public static void main(String args[]) {
    
    
    DynamicArray dynamicArray = new SortedDynamicArray();
    test(dynamicArray); // 打印结果：1、3、5
  }
}

面向对象比面向过程有哪些优势？
在实际开发中，很多人搞不清面向对象和面向过程的区别，总以为使用面向对象编程语言来做开发，就是在进行面向对象编程了；而实际上只是在用面向对象编程语言，编写面向过程风格的代码而已，没有发挥出面向对象编程的优势。

对于大规模复杂程序的开发，程序的处理流程并非单一的一条主线，而是错综复杂的网状结构。面向对象编程比起面向过程编程，更能应对这种复杂类型的程序开发。
面向对象编程相比面向过程编程，具有更加丰富的特性（封装、抽象、继承、多态）。利用这些特性编写出来的代码，更加易扩展、易复用、易维护。
从编程语言跟机器打交道的方式的演进规律中，我们可以总结出：面向对象编程语言比起面向过程编程语言，更加人性化、更加高级、更加智能。

个人一点总结：
两种范式最大区别是设计思路不同，面向对象设计从建模触发，建立对象，方法，领域等，面向过程偏向于功能实现。