面向对象

  • 面向对象是相对面向过程而言
  • 面向对象和面向过程都是一种思想
  • 面向过程强调的是功能、行为
  • 面向对象：将功能封装进对象，强调具备了功能的对象
  • 面向对象是基于面向过程的

面向过程例子：把大象放进冰箱里分为以下步骤：把冰箱门打开；把大象放进去；关上冰箱门（强调过程和过程中所涉及的行为（强调行为、动作、过程））。
用面向对象思想考虑：无论是打开冰箱，放进大象，关闭冰箱，所有操作都是操作冰箱这个对象，所以只需要将所有功能都定义在冰箱这个对象上，冰箱上就有打开、存储、关闭得所有功能 。
image.png

多态

多态是同一个方法，不同的对象调用呈现不同的结果。对象可以进行向上转型，也可以向下转型。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.       show(new Cat());  // 以 Cat 对象调用 show 方法
  4.       show(new Dog());  // 以 Dog 对象调用 show 方法
  6.       Animal a = new Cat();  // 向上转型  
  7.       a.eat();               // 调用的是 Cat 的 eat
  8.       Cat c = (Cat)a;        // 向下转型  
  9.       c.work();        // 调用的是 Cat 的 work
  10.   }  
  12.     public static void show(Animal a)  {
  13.       a.eat();  
  14.         // 类型判断
  15.         if (a instanceof Cat)  {  // 猫做的事情 
  16.             Cat c = (Cat)a;  
  17.             c.work();  
  18.         } else if (a instanceof Dog) { // 狗做的事情 
  19.             Dog c = (Dog)a;  
  20.             c.work();  
  21.         }  
  22.     }  
  23. }
  25. abstract class Animal {  
  26.     abstract void eat();  
  27. }  
  29. class Cat extends Animal {  
  30.     public void eat() {  
  31.         System.out.println("吃鱼");  
  32.     }  
  33.     public void work() {  
  34.         System.out.println("抓老鼠");  
  35.     }  
  36. }  
  38. class Dog extends Animal {  
  39.     public void eat() {  
  40.         System.out.println("吃骨头");  
  41.     }  
  42.     public void work() {  
  43.         System.out.println("看家");  
  44.     }  
  45. }

重写与重载

重写

子类对父类允许访问的方法进行重新编写，具有相同的形参和返回值，外壳不变，核心重写。

重载

重载时在一个参数里面，方法名相同，参数可以不同。返回值类型可以相同也可以不同。

反射

反射机制就是在程序的运行过程中被允许对程序本身进行操作，比如自我检查，进行装载，还可以获取类本身，类的所有成员变量和方法，类的对象，还可以在运行过程中动态的创建类的实例，通过实例来调用类的方法，这就是反射机制一个比较重要的功能了 。
利用反射机制可以获取类对象（也就是我们前面介绍的类对象，获取类对象之后我们便获取了类的模板，可以对类进行一些操作），有以下三种方法：

  1. 类名.class()
  2. 对象名.getClass()
  3. Class.forName(具体的类名)

获取类对象之后就可以对类进行一些创建对象、调用方法、访问成员变量的操作了

  1. Object obj = 类对象.newInstance();
  2. Method md = 类对象.getMethod(“类中的公有方法名”);

    抽象和接口

    在 Java 中，针对抽象有两种实现方式：一种是接口，一种是抽象类。
    接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。对“接口为何是约束”的理解，我觉得配合泛型食用效果更佳。
    而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。

    四种引用类型

    四种引用类型

    JDK1.2 之前，一个对象只有“已被引用”和”未被引用”两种状态，这将无法描述某些特殊情况下的对象，比如，当内存充足时需要保留，而内存紧张时才需要被抛弃的一类对象。所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。

    强引用

    1. Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收 obj = null; //手动置null
    只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了

    软引用

    软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。
    在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。

    弱引用

    弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。

    虚引用

    虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。

参考资料