设计模式

1.工厂模式(利用反射实现)

demo1：这是最原始的工厂方法

interface fruit{
    public abstract void eat();
}
 
class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}
 
class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}

// 构造工厂类
// 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了
class Factory{
    public static fruit getInstance(String fruitName){
        fruit f=null;
        if("Apple".equals(fruitName)){
            f=new Apple();
        }
        if("Orange".equals(fruitName)){
            f=new Orange();
        }
        return f;
    }
}

public class Hello18{
    public static void main(String[] a){
        fruit f=Factory.getInstance("Orange");
        f.eat();
    }
 
}

demo2：利用反射实现的工厂方法；当我们在添加一个子类的时候，就需要修改工厂类了。如果我们添加太多的子类的时候，改的就会很多。

class Factory1{
    public static fruit getInstance(String ClassName){
        fruit f=null;
        try{
            f=(fruit)Class.forName(ClassName).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}

public class Hello19{
    public static void main(String[] a){
        fruit f=Factory1.getInstance("Reflect.Apple");
        if(f!=null){
            f.eat();
        }
    }
}

上面的代码虽然可以通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过

属性文件的形式配置所需要的子类。

首先创建一个fruit.properties的资源文件，

内容为：
apple=Reflect.Apple
orange=Reflect.Orange
 */
//操作属性文件类
class init{
  public static Properties getPro() throws FileNotFoundException, IOException{
      Properties pro=new Properties();
      File f=new File("fruit.properties");
      if(f.exists()){
          pro.load(new FileInputStream(f));
      }else{
          pro.setProperty("apple", "Reflect.Apple");
          pro.setProperty("orange", "Reflect.Orange");
          pro.store(new FileOutputStream(f), "FRUIT CLASS");
      }
      return pro;
  }
}

public class Hello20{
  public static void main(String[] a) throws FileNotFoundException, IOException{
      Properties pro=init.getPro();
      fruit f=Factory1.getInstance(pro.getProperty("apple"));
      if(f!=null){
          f.eat();
      }
  }
}

类的生命周期
在一个类编译完成之后，下一步就需要开始使用类，如果要使用一个类，肯定离不开JVM。在程序执行中JVM通过装载，链接，初始化这3个步骤完成。
类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。 但是同一个类只会被类装载器装载以前
链接就是把二进制数据组装为可以运行的状态。
链接分为校验，准备，解析这3个阶段校验一般用来确认此二进制文件是否适合当前的JVM（版本），
准备就是为静态成员分配内存空间，。并设置默认值
解析指的是转换常量池中的代码作为直接引用的过程，直到所有的符号引用都可以被运行程序使用（建立完整的对应关系）
完成之后，类型也就完成了初始化，初始化之后类的对象就可以正常使用了，直到一个对象不再使用之后，将被垃圾回收。释放空间。
当没有任何引用指向Class对象时就会被卸载，结束类的生命周期将反射用于工厂模式

 

2.单例模式(double check问题)

http://www.cnblogs.com/limingluzhu/p/5156659.html

 

3.原型模式(注意浅克隆和深克隆的区别)

demo1：传统克隆模式(即浅克隆)步骤

 (1)实现Clonable接口
 (2)重写clone()方法
 (3)返回super.clone()

public class Prototype implements Cloneable {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public Object clone(){
        try {
            return super.clone();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        }
    }
    
}

public class ConcretePrototype extends Prototype {
    public ConcretePrototype(String name){
        setName(name);
    }
}

public class Test {
    public static void main(String[] args) {
        
        Prototype pro=new ConcretePrototype("prototype");
        Prototype pro2=(Prototype)pro.clone();
        System.out.println(pro.getName());
        System.out.println(pro2.getName());
        
    }
}

demo2：浅克隆

浅拷贝存在对象属性拷贝不彻底的问题，如果是基本类型变量，则拷贝其值，如果是实例对象，则拷贝引用地址，也就是说
新拷贝出来对象与原有对象共享该实例变量，不受访问权限的限制。
demo3：深克隆

步骤：

(1)实现java.io.Serializable接口

(2)序列化与反序列化

下面是序列化与反序列化核心方法：

public Object getObject(){
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();  
            ObjectOutputStream oos = new ObjectOutputStream(bos);  
            oos.writeObject(this);  
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
            ObjectInputStream ois = new ObjectInputStream(bis);  
            return ois.readObject();  
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        }
    }

transient是瞬态变量，不进行序列化变量

序列化时如果是文件类型就用FileInputStream和FileOutputStream，如果是直接的对象则用
ByteArrayInputStream和ByteArrayOutputStream