Java 学习笔记

终于有机会系统地学习Java。在此记录Java及面向对象编程的一些特点概念以备以后面试之用。

1.深复制（Deep Copy） 浅复制(Shallow Copy)

浅复制：仅复制复合对象的根对象。若还有子对象，则将新复制的根对象中的子对象引用指向原对象的子对象。

深复制：复制整个复合对象的结构，递归复制对象中的每一次子对象。

深复制的两种方法：

1）重定义clone()。调用父类clone()获得根对象，再调用根对象的所有子对象的clone()进行逐一复制

2）借助串行化。通过writeOject()将对象图串行化，再通过readObject()从串行化结果复原到另一个对象。

2.重写（Overriding）与重载（Overloading）

两者的区别有两点，一是签名是否相同，二是作用域不同。

重写（Overriding）指在继承或实现接口时，对父类方法的重写。子类中重写方法的签名与父类一致。即参数列表、返回值一致。

重载（Overloading）指在同类当中，定义了多个同名的方法，它们参数列表，甚至返回值都可以不相同。

特别说明：Java中子类也可以重载父类中的方位，但是可以理解为子类首先重写了父类的方法，然后再在子类中重载了这个方法。

方法的重载是一个类中多态性的一种表现。

3.信息封装 信息隐蔽

封装：将相关的数据以及作用在这些数据上的操作组织在一起。

类的成员通过访问控制（access control）实现信息隐蔽。

类本身通过接口实现信息隐藏。

public: 公开。

protected:派生类及同一程序包中的类可以访问。

default(or friendly/package access):同一程序包中的类可以访问。

private:只有自身类可以访问。

尽可能保持私有性！

4.多态（Polymorphism）

通俗解释：一个名字具有多种含义。

多态提高程序的可扩展性和可复用性。

实现多态的途径：

数据：隐式类型转换，强制类型转换

操作：重载，类属，动态绑定

编译时的多态（静态）：重载（方法，操作符）+类属（模版）

运行时的多态（动态）：继承+重写+动态绑定

5.抽象类（Abstract）、接口（Interface）

抽象类：含有一个或多个抽象方法的类。

抽象的过程是提取共性的过程，有助于提高程序的可复用性。

抽象方法（有待于子类去重写）、抽象类（有待于子类去继承）

抽象方法不允许有方法体，不允许定义为final。

接口为所有方法都为抽象方法的类。

接口不允许继承类，且都是公有的。但是可以继承接口。

接口的继承是设计的继承，而类的继承是实现的继承。

接口与抽象类的区别：两者最大的不同为是否包含方法的实现。

抽象类表现为接口+实现的混合体。而接口不可以含有任何实现，是一种最抽象的抽象类。

抽象因为包含实现只支持单继承，而接口可以支持多继承而不会出现歧义因为只定义未实现，二义性由重载解决。

选择抽象类还是接口主要取决于是否可以从需求中提取实现的共性。如果实现包含共性则应选择抽象类，若不包含或包含较少则应选择接口。

抽象类与接口的设计主要用于多态性。

6.垃圾回收

Java的垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。

需要注意的是：垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身。

System.gc()
Runtime.getRuntime().gc()  

上面的方法调用时用于显式通知JVM可以进行一次垃圾回收，但真正垃圾回收机制具体在什么时间点开始发生动作这同样是不可预料的。

7.合成（Composition）和  继承（Inheritance） - 类型创建的两种方法

合成：has-a or part-of关系建模，无子类型关系。

继承：is-a关系建模，OOP特征，运行时多态的基础。

8.绑定（Blinding）

静态绑定：在编译就确定语义。

动态绑定：在运行过程中确定语义。如多态确认状态。

Java缺省情况下默认为动态绑定。

9.内部类，嵌套类，匿名类

嵌套类有成员类、匿名类、本地类

成员类分为内部类、静态类。

内部类中可以访问外围类的实例变量+类变量。

内部类的对象实例必须通过其外围类的对象实例创建。

内部类实例包含了外部类实例的状态。

内部类只能说明实例方法和实例变量，不能声明static成员。

主要应用于事件驱动程序。

通过内部类+接口实现对接口的信息隐藏。

如迭代器模式。

public interface Iterator{
    boolean hasNext();
    Object next();
}

public class ObjectSet{
    private Object[] objects;
    private int next = 0;
    public ObjectSet( int size ){
        objects = new Object[size];
    }

    public void add( Object element ){
        if( next < objects.length ) objects[next++] = element;
    }

    private class InternalIterator implements Iterator{
        int index = 0;
        public boolean hasNext(){
            return ( index < objects.length );
        }
        public Object next(){
            if( hasNext() ) return objects[index++];
            else return null;
        }
    }

    public Iterator getIterator(){
        return new InternalInterator();
    }

    public static void main(String[] args){
        ObjectSet set = new ObjectSet(10);
        for( int i = 1; i < 10; i++ ) set.add( "" + i );
        Iterator it = set.getIterator();
        while( it.hasNext() ){
            System.out.println( it.next() );
        }  
    }
}