Java中怎么理解面向对象

面向对象中有四个特性，封装，继承，多态，抽象，java利用这些特性来描述类和类与类的关系。

类

虽然java是模拟真实世界，但是java对类的定义是开放，程序员可以按照自己想象任意定义类，但是类的定义和现实世界又是一样的，我们在描述一个鸟类的时候，一般是说鸟有羽毛，五颜六色，会飞等等，但是归根结底是在阐述鸟的外观和技能，而在java中外观描述和技能对应的是类中的成员属性和成员方法。 

对象

java中通过new关键字创建的就是一个具体的对象，它具备所属类的所有属性和方法，它可以在适当的地方被操作。

面向对象的特性

封装

封装也叫作信息隐藏或者数据访问保护，我们用一个非常通俗的现实例子来说明下:

public class bank {
    private String id;
    private long createTime;
    private BigDecimal balance;
    private long balanceLastModifiedTime;
}

这是一个银行存款的例子，在存款的时候有存款时间，存款后的余额，余额更改时间，如果这几个属性是public修饰，那么其他类都可以访问这几个属性，并且对其任意修改，这是不安全的，封装的目的把属性的修改权限私有化，比如时间只有内部可以改动，不需要对外开放，对于余额的改动银行依赖于存款人存多少钱，所以可以提供一个带入参的函数入口，类似于存款人把钱给到银行，由银行人员进行余额的变动，这是把权限最小化，尽可能增强安全性，通过有限的方法暴露必要的操作，我们代码中的get set方法就是封装的最简体现。

继承

继承是指子类继承父类，语法机制：extends

public class A extends D

一旦达成继承关系，子类就会拥有父类非private修饰的属性和方法。 并且子类可以拥有自己独有的属性和方法，同时子类还可以用自己的方式实现父类的方法，即重写。

一个父类可以被多个子类继承，但是一个子类不能继承多个父类。

继承让代码可以复用，把子类共有的方法抽离到父类中实现，由子类来继承父类，从而达到代码精简。

关于继承还有两种特殊的继承：实现接口和继承抽象类。

我们先来了解下接口和抽象类。

抽象类

public abstract class A

一个普通的类如果被abstract修饰，就是一个抽象类，抽象类相对于普通类的特点如下：

• 可以存在abstract修饰的方法，即抽象方法，被abstract修饰的方法不能用private、static、synchronized、native等访问修饰符修饰，并且没有实现体。

• 不能实例化，只能被子类继承。

• 如果子类继承了抽象类，并且实现了抽象类的所有抽象方法，那么子类是一个具体的类，如果没有全部实现其抽象方法，则子类也是一个抽象类。

• 抽象类可以有构造方法，目的是让子类来调用构造方法初始化。

接口

接口是一种特殊的抽象类，语法机制：interface

public interface B

接口其实就是一种特殊的抽象类，相对于抽象类不同的地方是：

• 只能被实现，其实现也是一种特殊的继承，却别是继承只能单继承，而实现可以多实现。

• 接口中默认所有的方法都是抽象方法。

• 接口中定义的成员变量默认是public static final，即只能够有静态的不能被修改的数据成员，而且必须赋初值。

• 一个类可以实现多个接口，一定程度上弥补了不能多继承的问题。

• java中类可以继承类，也可以实现接口，接口也可以继承接口，而且接口继承接口可以多继承，即一个接口可以用关键字extends继承多个接口。

多态

多态是指子类可以替换父类，父类的引用可以指向子类，我们直接用代码来说明：

public class DynamicArray {
  
  private static final int DEFAULT_CAPACITY = 10;
  protected int size = 0;
  protected Integer[] elements = new Integer[DEFAULT_CAPACITY];

  public int size() {
   return this.size;
  }

  public Integer get(int index) {
   return elements[index];
  }

  public void add(Integer e) {
   elements[size++] = e;
  }

 }

 public class SortedDynamicArray extends DynamicArray {
  @Override
  public void add (Integer e) {
   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);
  }
 }

public interface Iterator {

  String hasNext();

  String next();

  String remove();

 }

 public class Array implements Iterator {
  
  private String[] data;

  public String hasNext() { ...}

  public String next() { ...}

  public String remove() { ...}

 }

 public class LinkedList implements Iterator {

  private LinkedListNode head;

  public String hasNext() { ...}

  public String next() { ...}

  public String remove() { ...}

 }

 public class Demo {
  private static void print(Iterator iterator) {
   while (iterator.hasNext()) {
    System.out.println(iterator.next());
   }
  }

  public static void main(String[] args) {
   Iterator arrayIterator = new Array();
   print(arrayIterator);
   Iterator linkedListIterator = new LinkedList();
   print(linkedListIterator);
  }
 }

上面两个案例中最关键的代码：

DynamicArray dynamicArray = new SortedDynamicArray();

Iterator arrayIterator = new Array();

这两行代码都是用父类来接收子类，其实这就是多态，但是要达到这样的目的是要依赖于“继承”或者“实现”，正如上面的代码一样。

多态特性能提高代码的可扩展性和复用性。

在那个例子中，我们利用多态的特性，仅用一个print()函数就可以实现遍历打印不同类型（Array、LinkedList）集合的数据。当再增加一种要遍历打印的类型的时候，比如HashMap，我们只需让HashMap实现Iterator接口，重新实现自己的hasNext()、next()等方法就可以了，完全不需要改动print()函数的代码。所以说，多态提高了代码的可扩展性。