黑马程序员-Java的设计模式

                                            -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

                                                                               Java中设计模式的初步学习

一、设计模式（范式）：
    解决某一类问题的最行之有效的方法。
   （1）从高效合理开发的思想考虑；   （2）框架：复杂的设计模式；
   （3）java中已经总结了23中设计模式；

二、单例设计模式：解决一个类在内存只存在一个对象。
    当在不同的地方想操作同一个对象时，这种单子的设计模式相当的棒。
    例如：不同的两个类A和B，都要操作配置文件，就可以利用单子的C类的设计模式实现。

1、对象唯一性：
  （1）为了避免其他程序过多建立该类的对象，禁止其他程序建立该类对象；
  （2）为了让其他程序可以访问该类的对象，在本类中，自定义一个对象；
  （3）为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

2、单例模式的实现
  （1）将构造函数私有化；
  （2）在类中创建一个本类对象；
  （3）提供一个方法可以获取到对象。
  （4）对事物用类正常描述，当需要将该事物保证在内存中唯一使，
       就将以上的三步加上即可。

3、饿汉式和懒汉式
       虽然对象的的创建时间不一样，但是，都是为了要使用这个唯一的
   对象，所以差别不是特别大。
        但是，懒汉式在判断创建对象时，不是原子操作，容易引起两个程序
   同时调用时，创建不同的对象，所以一般使用饿汉式。

 

/*饿汉式：先初始化对象；SingleMode一进内存，就已经创建好了方法区中sm指向的堆内存中对象；*/class SingleMode {private int num;private SingleMode(){}private static SingleMode sm = new SingleMode();public static SingleMode getInstance() {return sm;}public void setNum(int num){this.num = num;}public int getNum(){return num;}}public class SingleModeDemo{public static void main(String[] args){SingleMode s1 = SingleMode.getInstance();SingleMode s2 = SingleMode.getInstance();s1.setNum(30);System.out.println(s2.getNum());System.out.println(s1==s2);}}

 

/*懒汉式：延迟加载,对象是方法被调用时才初始化；  SingleMode类进内存，对象还没有存在，只有调用  getImstance()方法时，才在堆中建立对象。*/class SingleMode {private int num;private SingleMode(){}private static SingleMode sm = null;public static  SingleMode getInstance() {if(sm == null)//A和B两个线程同时调用时，容易产生问题，创建不同的对象sm = new SingleMode();return sm;}/*    public static  synchronized SingleMode getInstance() //每次判断，效率比较低{if(sm == null)sm = new SingleMode();return sm;}*//*public static  synchronized SingleMode getInstance(){ -->C线程执行到这里if(sm == null){-->B线执行到这里，因为锁，停在了这里synchronized (SingleMode.class){ //减少了读锁的次数if(sm == null)//防止B进来后，判断出现错误                    -->A线程停在了这里sm = new SingleMode();}}return sm;}*/public void setNum(int num){this.num = num;}public int getNum(){return num;}}public class SingleModeDemo2{public static void main(String[] args){SingleMode s1 = SingleMode.getInstance();SingleMode s2 = SingleMode.getInstance();s1.setNum(30);System.out.println(s2.getNum());System.out.println(s1==s2);}}

4、通过继承简化单例模式

class Student {private int age;private String name;public  Student(){System.out.println("Student construtor() 1");}public  Student(String name ,int age){System.out.println("Student construtor() 2");this.name = name;this.age  = age;}public void  setAge(int age){this.age = age;}public int  getAge(){return age;}public void setName(String name){this.name = name;}public String getName(){return name;}public static void main(String[] args) {System.out.println("Hello World!");}}class SpecialStudent extends Student{private SpecialStudent(){super("li",30);}private static  SpecialStudent ss = new SpecialStudent();public static SpecialStudent getInstance(){return ss;}}public class  SingleModeDemo3{public static void  main(String[] args){SpecialStudent s1 = SpecialStudent.getInstance();SpecialStudent s2 = SpecialStudent.getInstance();//s1.setAge(20);System.out.println(s2.getAge());}}

 

三、抽象工厂模式
        为了解决工厂方法模式中，如果想要拓展程序功能，就必须对工厂类直接进行
    修改，这个违反了闭包原则的问题.
        利用工厂类接口实现创建多个不同功能的工厂类，当需要增加一个功能时，
    只需要做一个实现类和基于工厂类接口的实现的工厂类，就可以在不改变原有代码
    的基础上，实现功能拓展。

      

//抽象工厂模式public interface Sender {      public void Send();  }    //两个实现类：public class MailSender implements Sender {  @Override  public void Send() {  System.out.println("this is mailsender!");      }   }   public class SmsSender implements Sender {   @Override  public void Send() {  System.out.println("this is sms sender!");  }  }  //新的功能实现类public class WeChatSender implements Sender {   @Override  public void Send() {  System.out.println("this is wechat sender!");  }  } //在提供一个接口：public interface Provider {       public Sender produce();  } //两个工厂类：public class SendMailFactory implements Provider {       @Override  public Sender produce(){  return new MailSender();      }   }   public class SendSmsFactory implements Provider{  @Override      public Sender produce() {  return new SmsSender();      }  } //新的功能的实现类的工厂类public class SendWeChatFactory implements Provider{  @Override      public Sender produce() {  return new WeChatSender();      }  } //测试类：public class AbstractFactroyModeTest {        public static void main(String[] args) {          Provider provider = new SendWeChatFactory();          Sender sender = provider.produce();          sender.Send();      }  }  

 

四、模板方法模式
        在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，
    那么就将不确定的部分划分出去，有该类的子类去完成。

 

/*需求：获取一段程序运行的时间。思路：获取程序开始和结束的时间并相减即可。当前时间获取：System.currentTimeMillis();*/abstract class RunTimeCount{//模板方法public  final  long  getTime(){long startTime = System.currentTimeMillis();        runCode();long endTime = System.currentTimeMillis();return  (endTime-startTime);}    //不确定的功能处理成一个方法public abstract void runCode();}class CodeRun extends RunTimeCount{public void runCode(){for(int i=0;i<1000;i++){System.out.print(i+" ");}System.out.println();}}public class  TemplateDemo{public static void main(String[] args) {CodeRun cr = new CodeRun();long rt = cr.getTime();System.out.println("runtie = "+rt);}}

        总结，其他继承、组合和装饰器等也是一种设计合理类，可以使你对项目的扩展更佳
    容易和合理，通过重构从整体上重新优化项目内整体的结构；还有其他常用的设计模式，
    如工厂方法模式等等，应用这些都可以使用的开发更佳的高效和合理。

 

五、参考
    1、Java开发中的23种设计模式详解(转) http://blog.csdn.net/tansuozhey/article/details/50116047；
    2、《设计模式：可复用面向对象软件的基础》 Erich Gamma、Richard Helm、Ralph Johnson和JohnVlissides著。