java 几种常见模式理解

1.单例设计模式：只产生一个对象

一、实现步骤：
（1）构造方法私有化（private修饰）,为了不能在外部创建对象
（2）类内部创建对象，并用private static修饰
（3）写一个静态方法返回刚才创建对象
实例代码

Java代码

1. class Singleton {   
2.     private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象  
3.   
4.     public static Singleton getInstance() { // 通过静态方法返回instance对象  
5.         return instance;   
6.     }   
7.   
8.     private Singleton() { // 将构造方法封装为私有化  
9.     }   
10.   
11.     public void print() {   
12.         System.out.println("Hello World!!!");   
13.     }   
14. }   
15.   
16. public class SingletonDemo {   
17.     public static void main(String args[]) {   
18.         Singleton s1 = null; // 声明对象  
19.         Singleton s2 = null; // 声明对象  
20.         Singleton s3 = null; // 声明对象  
21.         s1 = Singleton.getInstance(); // 取得实例化对象  
22.         s2 = Singleton.getInstance(); // 取得实例化对象  
23.         s3 = Singleton.getInstance(); // 取得实例化对象  
24.         s1.print(); // 调用方法   
25.         s2.print(); // 调用方法   
26.         s3.print(); // 调用方法   
27.     }   
28. } 
29. 二、单例模式的实现
30. 饿汉模式（创建对象与引用在一行）
31. 1. /**  
    2.  *   
    3.  * 单例模式的实现：饿汉式,线程安全 但效率比较低  
    4.  */  
    5. public class SingletonTest {   
    6.   
    7.     private SingletonTest() {   
    8.     }   
    9.   
    10.     private static final SingletonTest instance = new SingletonTest();
    11.     public static SingletonTest getInstancei() {   
    12.         return instance;   
    13.     }   
    14.   
    15. }
    饱汉模式（创建对象在创建的静态方法）
33. public class SingletonTest {   
34.   
35.     private SingletonTest() {   
36.     }   
37.   
38.     private static final SingletonTest instance=null;
39. public static SingletonTest getInstancei() {  
40. instance=new SingletonTest();
41.         return instance;   
42.     }   
43.   
44. }

 2.工厂设计模式

生成对象交给工厂类，就像我想要一部手机，不是我自己生产，而是交给工厂生产

实例代码

1. interface Animal { // 定义一个动物的接口  
2.     public void say(); // 说话方法  
3. }   
4.   
5. class Cat implements Animal { // 定义子类Cat  
6.     @Override  
7.     public void say() { // 覆写say()方法  
8.         System.out.println("我是猫咪，喵呜！");   
9.     }   
10. }   
11.   
12. class Dog implements Animal { // 定义子类Dog  
13.   
14.     @Override  
15.     public void say() { // 覆写say()方法  
16.         System.out.println("我是小狗，汪汪！");   
17.     }   
18. }   
19.   
20. class Factory { // 定义工厂类  
21.     public static Animal getInstance(String className) {   
22.         Animal a = null; // 定义接口对象  
23.         if ("Cat".equals(className)) { // 判断是哪个子类的标记  
24.             a = new Cat(); // 通过Cat子类实例化接口  
25.         }   
26.         if ("Dog".equals(className)) { // 判断是哪个子类的标记  
27.             a = new Dog(); // 通过Dog子类实例化接口  
28.         }   
29.         return a;   
30.     }   
31. }   
32.   
33. public class FactoryDemo {   
34.   
35.     public static void main(String[] args) {   
36.         Animal a = null; // 定义接口对象  
37.         a = Factory.getInstance(args[0]); // 通过工厂获取实例  
38.         if (a != null) { // 判断对象是否为空  
39.             a.say(); // 调用方法   
40.         }   
41.     }   
42. }
    

 3.代理设计模式

代理设计模式就是比如访问网络，代理模式 完成访问网络，同时还完成其他的业务，访问权限

1. interface Network { // 定义Network接口  
2.     public void browse(); // 定义浏览的抽象方法  
3. }   
4.   
5. class Real implements Network { // 真实的上网操作  
6.     public void browse() { // 覆写抽象方法  
7.         System.out.println("上网浏览信息！");   
8.     }   
9. }   
10.   
11. class Proxy implements Network { // 代理上网  
12.     private Network network;   
13.   
14.     public Proxy(Network network) {// 设置代理的真实操作  
15.         this.network = network; // 设置代理的子类  
16.     }   
17.   
18.     public void check() { // 身份验证操作  
19.         System.out.println("检查用户是否合法！");   
20.     }   
21.   
22.     public void browse() {   
23.         this.check(); // 调用具体的代理业务操作  
24.         this.network.browse(); // 调用真实的上网操作  
25.     }   
26. }   
27.   
28. public class ProxyDemo {   
29.     public static void main(String args[]) {   
30.         Network net = null; // 定义接口对象  
31.         net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作  
32.         net.browse(); // 调用代理的上网操作   
33.     }   
34. }