设计模式

1.单例模式
单例模式有两种实现方式，饿汉模式和懒汉模式。两种模式的主要区别在于创建对象的时机不同。
饿汉模式：在类加载的时候就创建了对象，存在资源浪费的问题。
懒汉模式：在使用的时候才创建对象，有线程安全问题。
使用场景:
开发工具类库中的很多工具类都应用了单例模式，
比例线程池、缓存、日志对象等，它们都只需要创建一个对象。

1)饿汉模式
实现步骤：
　　1.构造器私有化。
　　2.类的内部创建对象。
　　3.向外暴漏一个静态的公共方法。getInstance

public class FindGirlFriend {

    //将构造器是私有化。让外部无法创建该类的对象。new不了。
    private FindGirlFriend(){
        System.out.println("创建一个单例模式-饿汉");
    }
    //创建一个静态的本类的对象。（不是静态的话，没法在内部方法中调用）
   static FindGirlFriend FGF = new FindGirlFriend();

    //创建一个暴露给外部的方法，返回在内部创建的对象。
    static FindGirlFriend getInstance(){
        return FGF;
    }
}

 2)懒汉模式
实现步骤：
　　1.构造器私有化。
　　2.创建本类类型的成员属性(FBF)，不赋值。
　　3.向外暴漏一个静态的公共方法。getInstance
　　　在方法内部判断FBF不为null的化，创建本类的对象，赋给FBF。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class FindBoyFriend {     //定义一个FindBoyFriend类型的变量     private static FindBoyFriend FBF;       //重写构造函数     private FindBoyFriend(){     System.out.println("创建一个单例模式-懒汉");     }       //定义一个静态的公共方法     public static FindBoyFriend getInstance(){         if(FBF == null){//一旦使用一次，就不再允许被使用。             FBF = new FindBoyFriend();         }         return FBF;     } }

2.模板模式

多个类中都存在的共通处理部分，可以这样外理，
1.创建一个抽象类。
2.定义一个实体方法，把共同处理封装到该实体方法中。
3.定义一个抽象方法run()。继承该抽象方法的子类会重写该抽象方法。
※在实体方法中调用该run()方法。基于动态调用的原理，执行的时候会直接调用子类中的run()方法。

父子类的方法调用原则：子类有就调用子类方法，子类没有的话，就调用父类的方法。

注:不管调用程序写在子类还是父类(尽管调用程序写在父类中)，只要子类中有被调用的方法，就执行子类中的方法。

 

 3.面向接口编程

实现方式1(紧耦合)：

1.定义一个接口。目的是统一标准，做规范。

2.写具体的类，实现这两个接口。实体化接口中的方法。

本例中只写Phone、Camera两个商品类。因为有了规范，如果需要很多类似的类的话，都可以按照这个标准做。

3.在Computer类中定义方法，在方法中创建Phone或Camera类的对象，调用具体方法。

弊端：今后增加新商品类的话，需要修改Computer类。对原有程序造成影响。

 

实现方式2(面向接口编程)：
1和2，同上。

3.在computer类中定义work方法，该方法有UsbInterface接口类型的参数。在方法中调用UsbInterface接口的方法。

#在执行的时候，会把具体(phone或camera)对象作为参数给到computer.work内部，基于动态调用原则，会执行具体对象内部的实体方法。

优点：今后增加新商品类的时候，只需要参照phone类，创建该商品的类。之后在main方法中调用该类即可。

不需要修改computer类，对原有程序不造成任何影响。

该实现方式符合现实世界，phone和camera，通过USB接口和computer连接的方式。
今后有新的商品需要和computer连接的时候，不对phone和camera造成影响。
面向接口编程的优势：

针对超类型中的“契约方法来”编写程序，可以产生可靠性高的程序，也可以极大的减少程序间的依赖关系

 

 4.代理模式