精华内容
参与话题
问答
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
    本文继续介绍23种设计模式系列之单例模式。 概念:  java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类...

    本文继续介绍23种设计模式系列之单例模式。

    概念:
      java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。
      单例模式有以下特点:
      1、单例类只能有一个实例。
      2、单例类必须自己创建自己的唯一实例。
      3、单例类必须给所有其他对象提供这一实例。
      单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态,避免政出多头。


    一、懒汉式单例

     

    //懒汉式单例类.在第一次调用的时候实例化自己 
    public class Singleton {
        private Singleton() {}
        private static Singleton single=null;
        //静态工厂方法 
        public static Singleton getInstance() {
             if (single == null) {  
                 single = new Singleton();
             }  
            return single;
        }
    }

     

    Singleton通过将构造方法限定为private避免了类在外部被实例化,在同一个虚拟机范围内,Singleton的唯一实例只能通过getInstance()方法访问。

    (事实上,通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。此问题在此处不做讨论,姑且掩耳盗铃地认为反射机制不存在。)

    但是以上懒汉式单例的实现没有考虑线程安全问题,它是线程不安全的,并发环境下很可能出现多个Singleton实例,要实现线程安全,有以下三种方式,都是对getInstance这个方法改造,保证了懒汉式单例的线程安全,如果你第一次接触单例模式,对线程安全不是很了解,可以先跳过下面这三小条,去看饿汉式单例,等看完后面再回头考虑线程安全的问题:

     

    1、在getInstance方法上加同步

     

    public static synchronized Singleton getInstance() {
             if (single == null) {  
                 single = new Singleton();
             }  
            return single;
    }

     

     

     

    2、双重检查锁定

     

    public static Singleton getInstance() {
            if (singleton == null) {  
                synchronized (Singleton.class) {  
                   if (singleton == null) {  
                      singleton = new Singleton(); 
                   }  
                }  
            }  
            return singleton; 
        }

     

    3、静态内部类

     

    public class Singleton {  
        private static class LazyHolder {  
           private static final Singleton INSTANCE = new Singleton();  
        }  
        private Singleton (){}  
        public static final Singleton getInstance() {  
           return LazyHolder.INSTANCE;  
        }  
    }  

    这种比上面1、2都好一些,既实现了线程安全,又避免了同步带来的性能影响。

     

     

     

     

     

     

    二、饿汉式单例

     

    //饿汉式单例类.在类初始化时,已经自行实例化 
    public class Singleton1 {
        private Singleton1() {}
        private static final Singleton1 single = new Singleton1();
        //静态工厂方法 
        public static Singleton1 getInstance() {
            return single;
        }
    }

    饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。

     

     

     

     

    三、登记式单例(可忽略)

    //类似Spring里面的方法,将类名注册,下次从里面直接获取。
    public class Singleton3 {
        private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
        static{
            Singleton3 single = new Singleton3();
            map.put(single.getClass().getName(), single);
        }
        //保护的默认构造子
        protected Singleton3(){}
        //静态工厂方法,返还此类惟一的实例
        public static Singleton3 getInstance(String name) {
            if(name == null) {
                name = Singleton3.class.getName();
                System.out.println("name == null"+"--->name="+name);
            }
            if(map.get(name) == null) {
                try {
                    map.put(name, (Singleton3) Class.forName(name).newInstance());
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
            return map.get(name);
        }
        //一个示意性的商业方法
        public String about() {    
            return "Hello, I am RegSingleton.";    
        }    
        public static void main(String[] args) {
            Singleton3 single3 = Singleton3.getInstance(null);
            System.out.println(single3.about());
        }
    }

     登记式单例实际上维护了一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从Map直接返回,对于没有登记的,则先登记,然后返回。 

    这里我对登记式单例标记了可忽略,我的理解来说,首先它用的比较少,另外其实内部实现还是用的饿汉式单例,因为其中的static方法块,它的单例在类被装载的时候就被实例化了。

     

    饿汉式和懒汉式区别

    从名字上来说,饿汉和懒汉,

    饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了,

    而懒汉比较懒,只有当调用getInstance的时候,才回去初始化这个单例。

    另外从以下两点再区分以下这两种方式:

     

    1、线程安全:

    饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,

    懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。


     

    2、资源加载和性能:

    饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,

    而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。

    至于1、2、3这三种实现又有些区别,

    第1种,在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能,毕竟99%的情况下是不需要同步的,

    第2种,在getInstance中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗

    第3种,利用了classloader的机制来保证初始化instance时只有一个线程,所以也是线程安全的,同时没有性能损耗,所以一般我倾向于使用这一种。

     

    什么是线程安全?

    如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。

    或者说:一个类或者程序所提供的接口对于线程来说是原子操作,或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题,那就是线程安全的。

     

    应用

    以下是一个单例类使用的例子,以懒汉式为例,这里为了保证线程安全,使用了双重检查锁定的方式:

     

    public class TestSingleton {
    	String name = null;
    
            private TestSingleton() {
    	}
    
    	private static volatile TestSingleton instance = null;
    
    	public static TestSingleton getInstance() {
               if (instance == null) {  
                 synchronized (TestSingleton.class) {  
                    if (instance == null) {  
                       instance = new TestSingleton(); 
                    }  
                 }  
               } 
               return instance;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public void printInfo() {
    		System.out.println("the name is " + name);
    	}
    
    }

    可以看到里面加了volatile关键字来声明单例对象,既然synchronized已经起到了多线程下原子性、有序性、可见性的作用,为什么还要加volatile呢,原因已经在下面评论中提到,

    还有疑问可参考http://www.iteye.com/topic/652440
    和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

     

     

     

    public class TMain {
    	public static void main(String[] args){
    		TestStream ts1 = TestSingleton.getInstance();
    		ts1.setName("jason");
    		TestStream ts2 = TestSingleton.getInstance();
    		ts2.setName("0539");
    		
    		ts1.printInfo();
    		ts2.printInfo();
    		
    		if(ts1 == ts2){
    			System.out.println("创建的是同一个实例");
    		}else{
    			System.out.println("创建的不是同一个实例");
    		}
    	}
    }
    

     运行结果:

    结论:由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点,不管它实现何种功能,整个应用程序都会同享一个实例对象。

    对于单例模式的几种实现方式,知道饿汉式和懒汉式的区别,线程安全,资源加载的时机,还有懒汉式为了实现线程安全的3种方式的细微差别。

    更多设计模式:23种设计模式系列

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

    展开全文
  • 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你...

     在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”,不仅是一个操作,像一部大机器中的一个齿轮传动。

     

    模式的问题:你如何能轻松方便地构造对象实例,而不必关心构造对象实例的细节和复杂过程呢?

    解决方案:建立一个工厂来创建对象

    实现:

    一、引言
        1)还没有工厂时代:假如还没有工业革命,如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车,然后拿来用。
        2)简单工厂模式:后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车,这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。
        3)工厂方法模式时代:为了满足客户,宝马车系列越来越多,如320i,523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。

       4)抽象工厂模式时代:随着客户的要求越来越高,宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

       最终是客户只要对宝马的销售员说:我要523i空调车,销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.

       这就是工厂模式。

    二、分类 
            工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。 
    工厂模式可以分为三类: 

    1)简单工厂模式(Simple Factory) 
    2)工厂方法模式(Factory Method) 
    3)抽象工厂模式(Abstract Factory) 

     这三种模式从上到下逐步抽象,并且更具一般性。 
            GOF在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。

            将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。 

    三、区别 
    工厂方法模式:
    一个抽象产品类,可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类只能创建一个具体产品类的实例。
    抽象工厂模式:
    多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类可以创建多个具体产品类的实例。   
    区别:
    工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。   
    工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
    两者皆可。 

     四、简单工厂模式 
    建立一个工厂(一个函数或一个类方法)来制造新的对象。
    分布说明引子:从无到有。客户自己创建宝马车,然后拿来用。

     

     

    public class BMW320 {
    	public BMW320(){
    		System.out.println("制造-->BMW320");
    	}
    }
    
    public class BMW523 {
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
    
    public class Customer {
    	public static void main(String[] args) {
    		BMW320 bmw320 = new BMW320();
    		BMW523 bmw523 = new BMW523();
    	}
    }
    

    客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了:简单工厂模式

    即我们建立一个工厂类方法来制造新的对象。如图:

    产品类:

    abstract class BMW {
    	public BMW(){
    		
    	}
    }
    
    public class BMW320 extends BMW {
    	public BMW320() {
    		System.out.println("制造-->BMW320");
    	}
    }
    public class BMW523 extends BMW{
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
    

    工厂类:

    public class Factory {
    	public BMW createBMW(int type) {
    		switch (type) {
    		
    		case 320:
    			return new BMW320();
    
    		case 523:
    			return new BMW523();
    
    		default:
    			break;
    		}
    		return null;
    	}
    }


    客户类:

    public class Customer {
    	public static void main(String[] args) {
    		Factory factory = new Factory();
    		BMW bmw320 = factory.createBMW(320);
    		BMW bmw523 = factory.createBMW(523);
    	}
    }
    

       简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。 
          先来看看它的组成: 
             1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑,用来创建产品
             2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。         
             3) 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 
            
            下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当客户不再满足现有的车型号的时候,想要一种速度快的新型车,只要这种车符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为每增加一种新型车,都要在工厂类中增加相应的创建业务逻辑(createBMW(int type)方法需要新增case),这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类,我们称它为全能类或者上帝类。 
            我们举的例子是最简单的情况,而在实际应用中,很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了,也累坏了我们这些程序员。
            于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。
    五、工厂方法模式 
            工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 
    工厂方法模式组成: 
           1)抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
           2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
           3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
           4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 
           工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说,这样便分担了对象承受的压力;而且这样使得结构变得灵活 起来——当有新的产品产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的! 

    代码如下: 

    产品类:

    abstract class BMW {
    	public BMW(){
    		
    	}
    }
    public class BMW320 extends BMW {
    	public BMW320() {
    		System.out.println("制造-->BMW320");
    	}
    }
    public class BMW523 extends BMW{
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }


    创建工厂类:

    interface FactoryBMW {
    	BMW createBMW();
    }
    
    public class FactoryBMW320 implements FactoryBMW{
    
    	@Override
    	public BMW320 createBMW() {
    
    		return new BMW320();
    	}
    
    }
    public class FactoryBMW523 implements FactoryBMW {
    	@Override
    	public BMW523 createBMW() {
    
    		return new BMW523();
    	}
    }
    


    客户类:

    public class Customer {
    	public static void main(String[] args) {
    		FactoryBMW320 factoryBMW320 = new FactoryBMW320();
    		BMW320 bmw320 = factoryBMW320.createBMW();
    
    		FactoryBMW523 factoryBMW523 = new FactoryBMW523();
    		BMW523 bmw523 = factoryBMW523.createBMW();
    	}
    }


     工厂方法模式仿佛已经很完美的对对象的创建进行了包装,使得客户程序中仅仅处理抽象产品角色提供的接口,但使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。

    参考http://blog.csdn.net/hguisu/article/details/7505909

     

    以上就是简单工厂模式,工厂方法模式,抽象工厂模式在这里

     

    更多设计模式:23种设计模式系列

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

     

    展开全文
  • java设计模式-命令模式

    万次阅读 2019-08-02 18:35:40
    java设计模式-命令模式 1 背景 & 定义 软件开发过程中,常常出现“方法请求者”与“方法实现者”间存在紧密耦合;不利于软件功能的扩展和维护;例如,想对行为进行“撤销、重做、记录”等处理就很不方便,命令...

    java设计模式-命令模式

     

    公众号文章链接:

    https://mp.weixin.qq.com/s/g2VME0R5GOH9jyHPCHytfw

    1 背景 & 定义

    软件开发过程中,常常出现“方法请求者”与“方法实现者”间存在紧密耦合;不利于软件功能的扩展和维护;例如,想对行为进行“撤销、重做、记录”等处理就很不方便,命令模式就能很好的解决这个问题

     

    2 角色

    命令模式包含以下主要角色。

    抽象命令类(Command)角色:声明执行命令的接口,如: execute()。

    具体命令角色(Concrete Command)角色:是抽象命令类的具体实现类,它拥有接收者对象,并通过调用接收者的功能来完成命令要执行的操作。

    实现者/接收者(Receiver):执行命令功能的相关操作,是具体命令对象业务的真正实现者。

    调用者/请求者(Invoker):是请求的发送者,它通常拥有很多的命令对象,并通过访问命令对象来执行相关请求,它不直接访问接收者。

     

    3 特点

    命令模式的主要优点如下。

    1 降低系统耦合,命令模式能将调用与实现的对象解耦

    2 增加或删除命令非常方便,增加与删除命令不会影响其他类,它满足“开闭原则”,对扩展比较灵活

    3 可以实现宏命令,与组合模式结合,将多个命令装配成一个组合命令,即宏命令

    4 方便实现 Undo 和 Redo 操作,命令模式可以与后面介绍的备忘录模式结合,实现命令的撤销与恢复

     

    4 结构图

    5 简单实现

     

     

    唠唠?微信搜索:DeanKano

    展开全文
  • 桥接模式: Bridge

    万次阅读 2019-08-21 18:08:17
    桥接模式是结构型模式 (Structural Patterns) 的一种. Making even a simple change to a monolithic codebase is pretty hard because you must understand the entire thing very well. Making changes to smaller...

    简介

    桥接模式是结构型模式 (Structural Patterns) 的一种.

    Making even a simple change to a monolithic codebase is pretty hard because you must understand the entire thing very well. Making changes to smaller, well-defined modules is much easier.
    

    如果软件系统中某个类存在多个独立变化的维度, 通过该模式可以将这多个维度分离出来, 使他们可以独立扩展, 让系统更加符合"单一职责原则 (SRP)". 与多层继承方案不同, 它将多个独立变化的维度设计为多个独立的继承等级结构, 并且在抽象层建立一个抽象关联, 该关联关系类似一条连接多个独立继承结构的桥, 故名桥接模式.

    桥接模式用一种巧妙的方式处理多层继承存在的问题, 用抽象关联取代了多层继承,将类之间的静态继承关系转换为动态的对象组合关系, 使得系统更加灵活, 并易于扩展, 同时有效控制了系统中类的个数.

    在这个例子中, 无论增加形状, 还是增加颜色, 都会导致子类数量快速增加. 解决方案是划分成两个独立变化的维度: Type 和 Color.

    84qp.gdhongkong.com|tdzdj.cn

    https|https

    abstract Shape(val shapeColor: ShapeColor) {
        abstract val shapeType: ShapeType
    }
    
    class Circle(val shapeColor: ShapeColor) : Shape(ShapeColor) {
        val shapeType = TypeCircle
        ...
    }
    
    class Square(val shapeColor: ShapeColor) : Shape(ShapeColor) {
        val shapeType = TypeSquare
        ...
    }
    

    Abstraction:拥有一个 Implementation 类型的对象引用
    Implementation:Implementation 和 Abstraction 接口并不一定完全一致,实际上这两个接口可以完全不一样, Implementation 提供具体操作方法,而 Abstraction 提供更高层次的调用
    Concrete Implementation:实现 Implementation 接口,给出具体实现
    Refined Abstraction:扩展 Abstraction 中的接口定义
    Client: 连接 Abstraction 和 Implementation

    应用场景

    一个应用/类越大, 弄清楚或改动的的代价就越大. 对于一个变体的改动可能会导致整个应用/类内的大量改动, 这经常会导致各种问题. Bridge 模式可以把应用/类拆分成多个独立的结构, 之后的改动就在各自的结构中, 让代码的改动影响最小化.

    展开全文
  • PHPWAMP站点管理的“域名模式”和“端口模式”详解、均支持无限自定义版本:phpwamp站点管理,站点管理使用,域名模式,端口模式,站点管理教程
  • 5种创建型模式之:抽象工厂模式

    万次阅读 2017-04-07 23:11:25
    抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,...
  • 原型模式的使用总结

    万次阅读 2020-05-12 16:46:00
    备注:后续会逐步补齐
  • 单例模式的使用总结

    万次阅读 2020-04-21 11:15:59
    一、单例模式的定义和应用场景 (一)定义及基本要点 (二)应用场景 二、饿汉式单例模式 (一)基本代码展示分析 (二)基本分析和建议 三、懒汉式单例模式(双重检查锁) (一)基本代码展示分析 (二)...
  • 常用设计模式总结

    万次阅读 多人点赞 2019-07-31 19:13:12
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结,是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 ...
  • 类型:创建类模式 类图: 原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件: 实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,...
  • 装饰器模式的使用总结

    万次阅读 2020-04-19 12:36:44
    一、装饰器模式的概念及怎么用? 1.基本概念和功能: 装饰器模式能够实现从一个对象的外部来给对象添加功能,有非常灵活的扩展性,可以在对原来的代码毫无修改的前提下,为对象添加新功能。除此之外,装饰器模式还...
  • 定义:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个...类型:创建类模式 类图: 工厂方法模式代码 [java]view plaincopy interfaceIProduct{ publicvoidproductMethod(); } c
  • 建造者模式(Builder)
  • 先来介绍如何切换到霸体模式,然后再来介绍霸体模式的作用与推出原因。
  • 史上最全设计模式导学目录(完整版)

    万次阅读 多人点赞 2013-12-24 23:15:16
    2012年-2013年,Sunny在CSDN技术博客中陆续发表了100多篇与设计模式相关的文章,涵盖了七个面向对象设计原则和24个设计模式(23个GoF设计模式 + 简单工厂模式),为了方便大家学习,现将所有与设计模式学习相关文章...
  • 大话设计模式

    万次阅读 2019-10-27 21:54:33
    设计模式简介 设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过...
  • 23种设计模式汇总整理

    万次阅读 多人点赞 2015-04-09 10:57:11
    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类:并发型模式和线程池模式。 ...
  • PHPWAMP集成环境Zend组件的相关介绍,站点管理默认已经全部安装Zend解密
  • java策略模式典型案例

    万次阅读 多人点赞 2019-05-25 00:32:21
    以一个顾客价格计算策略为背景,写一个策略模式的demo 参考代码 :https://github.com/zhang-xiaoxiang/DesignPatterns23 没有用策略模式我们一般是下面的写法,直接写一个类,在类里面直接写策略算法(功能实现) //...
  • 简单工厂模式

    万次阅读 2019-10-27 23:16:23
    简单工厂模式又称为静态工厂方法模式,它属于类创建型模式,在这种模式中,可以根据参数的不同,返回不同类的实例,被创建的实例通常都具有共同的父类或实现了相同的接口。 业务场景 在某糕点定制APP中,需要根据...
  • 前言:策略模式和工厂模式看着很像,经常让人混淆不清
  • 设计模式之单例模式(创建型模式)

    万次阅读 2019-04-02 18:21:32
    单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,任务管理器、线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。在项目当中,系统启动读取...
  • 设计模式之原型模式(创建型模式)

    万次阅读 2020-04-30 17:05:58
    这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 模式结构 由于 Java 提供了对象的 clone() 方法,所以用 Java 实现原型模式很简单,只需要实现Cloneable接口并重写clone()方法 模式的结构 ...
  • 设计模式-外观模式

    万次阅读 2019-12-03 22:56:22
    外观模式(Facade Pattern)门面模式,隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式,它向现有的系统添加一个接口,来隐藏系统的复杂性。 这种模式涉及到一...
  • 设计模式-原型模式

    万次阅读 2019-12-07 22:36:42
    原型模式是一个创建型的模式。原型二字表明了改模式应该有一个样板实例,用户从这个样板对象中复制一个内部属性一致的对象,这个过程也就是我们称的“克隆”。被复制的实例就是我们所称的“原型”,这个...
  • 设计模式-装饰模式

    万次阅读 2019-12-07 22:41:22
     装饰器模式,也成为包装模式,顾名思义,就是对已经存在的某些类进行装饰,以此来扩展一些功能。其结构图如下: Component为统一接口,也是装饰类和被装饰类的基本类型。 ConcreteComponent为具体实现类,也是...
  • 设计模式-适配器模式

    万次阅读 2019-12-03 22:34:55
    目录 知识点1:什么是适配器 知识点2:适配器分类 知识点3:适配器案例 1、定义日本和中国两种接口及其实现 ...在设计模式中,适配器模式(英语:adapter pattern)有时候也称包装样式或者包...
  • 设计模式-工厂模式

    万次阅读 2019-12-02 22:40:03
    知识点1:什么是工厂模式 知识点2:工厂模式好处 知识点3:工厂模式分类 1、简单工厂模式 (1)单工厂的优点/缺点 2、工厂方法模式 (1)什么是工厂方法模式 3、抽象工厂模式 (1)什么是抽象工厂模式 知识...
  • 设计模式-代理模式

    万次阅读 2019-12-03 07:50:03
    知识点1:什么是代理模式 知识点2:代理模式应用场景 知识点3:代理的分类 知识点4:静态代理 1、什么是静态代理 2、静态代理代码 知识点5:动态代理 1、什么是动态代理 2、JDK动态代理 3、CGLIB动态代理 ...
  • 设计模式-单例模式

    万次阅读 2019-12-02 22:26:53
    知识点1:设计模式分类 知识点2:设计模式的原则 1、开闭原则(Open Close Principle) 2、里氏代换原则(Liskov Substitution Principle) 3、依赖倒转原则(Dependence Inversion Principle) 4、迪米特法则...

空空如也

1 2 3 4 5 ... 20
收藏数 1,349,134
精华内容 539,653
关键字:

模式