知识点复习1

//一个延迟实例化的内部类的单例模式
public final class Singleton {
    //一个内部类的容器, 调用getInstance时, JVM加载这个类
    private static final class SingletonHolder {
        static final Singleton singleton =  new Singleton();
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return SingletonHolder.singleton;
    }
 }

//使用反射破坏单例模式
Class c = Class.forName(Singleton.class.getName());  
Constructor constructor = c.getDeclaredConstructor();  
constructor.setAccessible(true);  
Singleton singleton = (Singleton)ct.newInstance(); 

import java.io.Serializable;
/**
 * Created by hollis on 16/2/5.
 * 使用双重校验锁方式实现单例
 */
public class Singleton implements Serializable{
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

public class SerializableDemo1 {
    //为了便于理解, 忽略关闭流操作及删除文件操作. 真正编码时千万不要忘记
    //Exception直接抛出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(Singleton.getSingleton());
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        //判断是否是同一个对象
        System.out.println(newInstance == Singleton.getSingleton());
    }
}

private Object readResolve() {
        return singleton;
    }

/**
* Singleton pattern example using Java Enumj
*/
public enum EasySingleton{
    INSTANCE;
}

protected final Object clone() throws CloneNotSupportedException {  
    throw new CloneNotSupportedException();  
}  

private void readObject(ObjectInputStream in) throws IOException,  
        ClassNotFoundException {  
            throw new InvalidObjectException("can't deserialize enum");  
}  
private void readObjectNoData() throws ObjectStreamException {  
        throw new InvalidObjectException("can't deserialize enum");  
} 

int i = 0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

String i = "0";
String j = new String("0");
System.out.println(i==j); // 比值
System.out.println(j.equals(i)); // 比内容

//强引用 
User strangeReference=new User();  

public class SoftReference<T> extends Reference<T> {

  /**
    * Timestamp clock, updated by the garbage collector
    */
  static private long clock;

  /**
    * Timestamp updated by each invocation of the get method.  The VM may use
    * this field when selecting soft references to be cleared, but it is not
    * required to do so.
    */
  private long timestamp;

  /**
    * Creates a new soft reference that refers to the given object.  The new
    * reference is not registered with any queue.
    *
    * @param referent object the new soft reference will refer to
    */
  public SoftReference(T referent) {
      super(referent);
      this.timestamp = clock;
  }

  /**
    * Creates a new soft reference that refers to the given object and is
    * registered with the given queue.
    *
    * @param referent object the new soft reference will refer to
    * @param q the queue with which the reference is to be registered,
    *          or <tt>null</tt> if registration is not required
    *
    */
  public SoftReference(T referent, ReferenceQueue<? super T> q) {
      super(referent, q);
      this.timestamp = clock;
  }

  /**
    * Returns this reference object's referent.  If this reference object has
    * been cleared, either by the program or by the garbage collector, then
    * this method returns <code>null</code>.
    *
    * @return   The object to which this reference refers, or
    *           <code>null</code> if this reference object has been cleared
    */
  public T get() {
      T o = super.get();
      if (o != null && this.timestamp != clock)
          this.timestamp = clock;
      return o;
  }
}

//软引用
SoftReference<User>softReference=new SoftReference<User>(new User());
strangeReference=softReference.get();//通过get方法获得强引用

public class WeakReference<T> extends Reference<T> {
  /**
    * Creates a new weak reference that refers to the given object.  The new
    * reference is not registered with any queue.
    *
    * @param referent object the new weak reference will refer to
    */
  public WeakReference(T referent) {
      super(referent);
  }

  /**
    * Creates a new weak reference that refers to the given object and is
    * registered with the given queue.
    *
    * @param referent object the new weak reference will refer to
    * @param q the queue with which the reference is to be registered,
    *          or <tt>null</tt> if registration is not required
    */
  public WeakReference(T referent, ReferenceQueue<? super T> q) {
      super(referent, q);
  }
}

//弱引用
WeakReference<User>weakReference=new WeakReference<User>(new User());

public class PhantomReference<T> extends Reference<T> {

  /**
    * Returns this reference object's referent.  Because the referent of a
    * phantom reference is always inaccessible, this method always returns
    * <code>null</code>.
    *
    * @return  <code>null</code>
    */
  public T get() {
      return null;
  }

  /**
    * Creates a new phantom reference that refers to the given object and
    * is registered with the given queue.
    *
    * <p> It is possible to create a phantom reference with a <tt>null</tt>
    * queue, but such a reference is completely useless: Its <tt>get</tt>
    * method will always return null and, since it does not have a queue, it
    * will never be enqueued.
    *
    * @param referent the object the new phantom reference will refer to
    * @param q the queue with which the reference is to be registered,
    *          or <tt>null</tt> if registration is not required
    */
  public PhantomReference(T referent, ReferenceQueue<? super T> q) {
      super(referent, q);
  }
}

//虚引用
PhantomReference<User> phantomReference=new PhantomReference<User>(new User(),

import java.lang.ref.*;
import java.util.HashSet;
import java.util.Set;

class User {

    private String name;

    public User()
    {}

    public User(String name)
    {
        this.name=name;
    }

    @Override
    public String toString() {
        return name;
    }

    public void finalize(){
        System.out.println("Finalizing ... "+name);
    }
}

/**
 * Created by jinxu on 15-4-25.
 */
public class ReferenceDemo {

    private static ReferenceQueue<User> referenceQueue = new ReferenceQueue<User>();
    private static final int size = 10;

    public static void checkQueue(){
       /* Reference<? extends User> reference = null;
        while((reference = referenceQueue.poll())!=null){
            System.out.println("In queue : "+reference.get());
        }*/
        Reference<? extends User> reference = referenceQueue.poll();
        if(reference!=null){
            System.out.println("In queue : "+reference.get());
        }
    }

    public static void testSoftReference()
    {
        Set<SoftReference<User>> softReferenceSet = new HashSet<SoftReference<User>>();
        for (int i = 0; i < size; i++) {
            SoftReference<User> ref = new SoftReference<User>(new User("Soft " + i), referenceQueue);
            System.out.println("Just created: " + ref.get());
            softReferenceSet.add(ref);
        }
        System.gc();
        checkQueue();
    }

    public static void testWeaKReference()
    {
        Set<WeakReference<User>> weakReferenceSet = new HashSet<WeakReference<User>>();
        for (int i = 0; i < size; i++) {
            WeakReference<User> ref = new WeakReference<User>(new User("Weak " + i), referenceQueue);
            System.out.println("Just created: " + ref.get());
            weakReferenceSet.add(ref);
        }
        System.gc();
        checkQueue();
    }

    public static void testPhantomReference()
    {
        Set<PhantomReference<User>> phantomReferenceSet = new HashSet<PhantomReference<User>>();
        for (int i = 0; i < size; i++) {
            PhantomReference<User> ref =
                    new PhantomReference<User>(new User("Phantom " + i), referenceQueue);
            System.out.println("Just created: " + ref.get());
            phantomReferenceSet.add(ref);
        }
        System.gc();
        checkQueue();
    }

    public static void main(String[] args) {
        testSoftReference();
        testWeaKReference();
        testPhantomReference();
    }
}