黑马程序员技术交流社区

标题: 设计模式整理——陆续增加 [打印本页]
作者: wisely    时间: 2014-7-21 22:29
标题: 设计模式整理——陆续增加
本帖最后由 wisely 于 2014-7-21 22:31 编辑

设计模式，是指解决某一类问题最行之有效的方法。
1、单例设计模式
单例设计模式，解决一个类在内存中只有一个对象。


想要保证对象唯一。
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象，只好在本来中，自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现？
1、将构造方法私有化。
2、在类中创建一个本类对象
3、提供一个方法可以获取到该类对象。

单例设计模式有两种方式，饿汉式和懒汉式。

  1. //饿汉式，类加载时就进行创建单例对象
复制代码

建议使用饿汉式。

  1. //懒汉式，延迟加载，线程不安全
复制代码
为了解决线程安全问题，使用双重判断并加锁

  1. class Single{
  2.         int num;
  3.         private static Single s=null;
  4.         private Single(){}
  5.         public static Single getInstance(){
  6.                 if(s==null)
  7.                         synchronized(Single.class){
  8.                                 if(s==null)
  9.                                         return s=new Single();
  10.                         }
  11.                 return s;
  12.         }
  13.         public void setNum(int num){
  14.                 this.num=num;
  15.         }
  16.         public int getNum(){
  17.                 return num;
  18.         }
  19. }

  21. public class Sunday{
  22.         public static void main(String[] args){
  23.                 Single ss=Single.getInstance();
  24.                 Single s=Single.getInstance();
  25.                 ss.setNum(10);
  26.                 System.out.println(s.getNum());
  27.         }
  28. }
复制代码








作者: wisely    时间: 2014-7-21 22:31
饿汉式

  1. class Single{
  2.         int num;
  3.         private Single(){}
  4.         private static Single s=new Single();
  5.         public static Single getInstance(){
  6.                 return s;
  7.         }
  8.         public void setNum(int num){
  9.                 this.num=num;
  10.         }
  11.         public int getNum(){
  12.                 return num;
  13.         }
  14. }
  15. public class Sunday{
  16.         public static void main(String[] args){
  17.                 Single ss=Single.getInstance();
  18.                 Single s=Single.getInstance();
  19.                 ss.setNum(10);
  20.                 System.out.println(s.getNum());
  21.         }
  22. }
复制代码
作者: wisely    时间: 2014-7-21 22:32
wisely 发表于 2014-7-21 22:31
饿汉式

懒汉式
  1. class Single{
  2.         int num;
  3.         private static Single s=null;
  4.         private Single(){}
  5.         public static Single getInstance(){
  6.                 if(s==null)
  7.                         return s=new Single();
  8.                 return s;
  9.         }
  10.         public void setNum(int num){
  11.                 this.num=num;
  12.         }
  13.         public int getNum(){
  14.                 return num;
  15.         }
  16. }

  18. public class Sunday{
  19.         public static void main(String[] args){
  20.                 Single ss=Single.getInstance();
  21.                 Single s=Single.getInstance();
  22.                 ss.setNum(10);
  23.                 System.out.println(s.getNum());
  24.         }
  25. }
复制代码


作者: 掌柜的--刘饮    时间: 2014-7-21 23:16
好,定时来看看!!
作者: 楚风★憧憬    时间: 2014-7-21 23:37
class Single{
        int num;
        private static Single s=null;
        private Single(){}
        public static Single getInstance(){
                if(s==null)
                        return s=new Single();
                return s;
        }
        public void setNum(int num){
                this.num=num;
        }
        public int getNum(){
                return num;
        }
}

public class Sunday{
        public static void main(String[] args){
                Single ss=Single.getInstance();
                Single s=Single.getInstance();
                ss.setNum(10);
                System.out.println(s.getNum());
        }
}
作者: baiiiu    时间: 2014-7-21 23:40
好整理，我还没看到那块
作者: wisely    时间: 2014-7-22 18:01
本帖最后由 wisely 于 2014-7-22 18:02 编辑
wisely 发表于 2014-7-21 22:31
饿汉式

2、模板设计模式
模板设计模式，在定义功能时，功能的一部分是确定的(如下面的getTime中除runcode外的部分)，但有一部分功能是不确定的(如runcode)，而确定的部分在使用不确定的部分，那么这时就要将不确定的部分暴露出去，由该类的子类去完成。


  2. abstract class GetTime{
  3.         public final void getTime(){    //加final，此方法不希望被复写
  4.                 long start=System.currentTimeMillis();
  5.                 runcode();
  6.                 long end=System.currentTimeMillis();
  7.                 System.out.println("运行时间为"+(end-start)+"毫秒");
  8.         }
  9.         public abstract void runcode();
  10. }

  12. class SubTime extends GetTime{
  13.         public void runcode(){
  14.                 for(int i=0;i<1000;i++){
  15.                         System.out.print(i);
  16.                 }
  17.         }
  18. }

  20. public class Sunday{
  21.         public static void main(String[] args){
  22.                 SubTime gt=new SubTime();
  23.                 gt.getTime();
  24.         }
  25. }
复制代码

注意：runcode()方法不一定必须是抽象的。
作者: 357016138    时间: 2014-7-22 18:35
说是32种，有的总结了
作者: wisely    时间: 2014-7-22 18:45
357016138 发表于 2014-7-22 18:35
说是32种，有的总结了

可能是23种，慢慢搞吧
作者: LYP    时间: 2014-7-22 19:44
学习了，呵呵
作者: 想做开发    时间: 2014-7-22 19:49
357016138 发表于 2014-7-22 18:35
说是32种，有的总结了

23吧好像



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2