精华内容
下载资源
问答
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
     java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例只能有一个实例。  2、单例必须自己创建自己的...

    本文继续介绍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(转载请说明出处)

    展开全文
  • 设计模式工厂模式Java实现和类设计图,包括简单工厂模式工厂方法模式和抽象工厂模式
  • JAVA设计模式分类

    2019-07-03 10:59:01
    JAVA设计模式分类 一、设计模式的分类 总体来说设计模式分为三大: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、...

    JAVA设计模式分类

    一、设计模式的分类

    总体来说设计模式分为三大类:

    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    其实还有两类:并发型模式和线程池模式。用一个图片来整体描述一下:

    在这里插入图片描述如果喜欢请关注我和留言点赞吧,后续会为你继续奉上干货只求一赞
    在这里插入图片描述

    展开全文
  • Java设计模式-工厂模式

    千次阅读 2021-08-06 09:27:36
    Java设计模式-工厂模式 什么是工厂模式工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会...

    Java设计模式-工厂模式

    什么是工厂模式?

    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
    在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    简单编写一个类:

    1、简单工厂模式

    interface IFruit{
    	public void eat();	//吃水果
    }
    class Apple implements IFruit{
    	public void eat(){
    		System.out.println("削皮吃苹果!");
    	}
    }
    class Orange implements IFruit{
    	public void eat(){
    		System.out.println("剥皮吃橘子!");
    	}
    }
    public class Factory{
    	public static void main(String args[]){
    		IFruit fruit = new Apple();
    		//削皮吃苹果!
    		fruit.eat();
    	}
    }
    

    本程序非常简单就是通过接口的子类为接口对象实例化,但是本操作存在什么样的问题呢?

    之前一直在强调,主方法或者是主类是一个客户端,客户端的操作应该越简单越好。但是在现在的程序之中,有一个最大的问题:客户端之中,一个接口和一个固定的子类绑在一起了。

    在本程序之中,最大的问题在于耦合上,发现在主方法之中一个接口和一个子类紧密耦合在一起,这种方法比较直接,可以简单的理解为:A→B,但是这种紧密的方式不方便于维护,所以后来使用了A→B→C,中间经历了一个过渡,这样一来B去改变,C去改变,但是A不需要改变,就好比JAVA的JVM一样:程序→JVM→操作系统。

    2、普通工厂模式

    UML图:

    源代码:

    ProjectFactory.java

    public interface ProjectFactory {
    	Project getname();
    }
    

    BlueFactory.java(ConcreteFactory1)

    public class BlueFactory implements ProjectFactory{
    
    	@Override
    	public Project getname() {
    		// TODO Auto-generated method stub
    		return new Bluepen();
    	}
    
    }
    

    RedFactory.java(ConcreteFactory2)

    public class RedFactory implements ProjectFactory{
    
    	@Override
    	public Project getname() {
    		// TODO Auto-generated method stub
    		return new redPen();
    	}
    
    }
    

    Project.java(产品类)

    public interface Project {
    	void name();
    }
    

    Bluepen.java(ConcreteProject1)

    public class Bluepen implements Project{
    
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("这是一个蓝色的笔");
    	}
    
    }
    

    RedFactory.java(ConcreteProject2)

    public class RedFactory implements ProjectFactory{
    
    	@Override
    	public Project getname() {
    		// TODO Auto-generated method stub
    		return new redPen();
    	}
    
    }
    

    测试类

    public class Client {
    	public static void main(String[] args) {
    		Project pen = new RedFactory().getname();
    		pen.name();
    		Project pen1 = new BlueFactory().getname();
    		pen1.name();
    	}
    }
    

    运行结果:

    image-20210805205221818

    这个时候发现客户端不在和一个具体的子类耦合在一起了,就算以后增加了新的子类,那么也只需要修改Factory类即可。

    总结:

    1. 以后如果是自己编写的接口如果想要取得接口的 实例化对象,第一反应写工厂类
    2. 简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中,根据参数的类型进行实例化,同时不存在抽象接口。而后者则增加了抽象工厂,通过实现不同的工厂方法来创建不同的产品,一个方法通常对应一个产品,这种方式相较于前者扩展性更高,在需求增加时完全符合开闭原则和依赖倒置原则

    使用场景:

    消费者不关心它所要创建对象的类(产品类)的时候。

    消费者知道它所要创建对象的类(产品类),但不关心如何创建的时候。

    例如:hibernate里通过sessionFactory创建session、通过代理方式生成ws客户端时,通过工厂构建报文中格式化数据的对象。

    3、抽象工厂模式

    定义:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。

    抽象工厂模式与工厂方法模式的区别

    ​ 抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

    ​ 在抽象工厂模式中,有一个产品族的概念:所谓的产品族,是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族;而工厂方法提供的一系列产品称为一个等级结构。.

    如果工厂的产品全部属于同一个等级结构,则属于工厂方法模式;如果工厂的产品来自多个等级结构,则属于抽象工厂模式。

    UML图:

    image-20210805210243478

    源代码:

    Factory.java(抽象工厂)

    public interface Factory {
    	PhoneProject projectPhone();
    	LaptopProject projectLaptop();
    }
    

    HuaWeiFactory.java(华为具体工厂)

    public class HuaWeiFactory implements Factory{
    
    	@Override
    	public PhoneProject projectPhone() {
    		// TODO Auto-generated method stub
    		return new HuaWeiPhone();
    	}
    
    	@Override
    	public LaptopProject projectLaptop() {
    		// TODO Auto-generated method stub
    		return new HuaWeiLaptop();
    	}
    
    }
    

    XiaomiFactory.java(小米具体工厂)

    public class XiaomiFactory implements Factory{
    
    	@Override
    	public PhoneProject projectPhone() {
    		// TODO Auto-generated method stub
    		return new XiaomiPhone();
    	}
    
    	@Override
    	public LaptopProject projectLaptop() {
    		// TODO Auto-generated method stub
    		return new XiaomiLaptop();
    	}
    
    }
    

    LaptopProject.java(笔记本产品)

    public interface LaptopProject {
    	void getId();
    	void printInfo();
    }
    

    HuaWeiLaptop.java(华为笔记本)

    public class HuaWeiLaptop implements LaptopProject{
    
    	@Override
    	public void getId() {
    		// TODO Auto-generated method stub
    		System.out.println("编号"+123);
    	}
    
    	@Override
    	public void printInfo() {
    		// TODO Auto-generated method stub
    		System.out.println("生产了华为电脑");
    	}
    
    }
    

    XiaomiLaptop.java(小米笔记本)

    public class XiaomiLaptop implements LaptopProject{
    
    	@Override
    	public void getId() {
    		// TODO Auto-generated method stub
    		System.out.println("编号"+213);
    	}
    
    	@Override
    	public void printInfo() {
    		// TODO Auto-generated method stub
    		System.out.println("生产小米电脑");
    	}
    
    }
    

    PhoneProject.java(手机产品)

    public interface PhoneProject {
    	void getId();
    	void printInfo();
    }
    

    HuaWeiPhone.java(华为手机)

    public class HuaWeiPhone implements PhoneProject{
    
    	@Override
    	public void getId() {
    		// TODO Auto-generated method stub
    		System.out.println("编号:"+123412);
    	}
    
    	@Override
    	public void printInfo() {
    		// TODO Auto-generated method stub
    		System.out.println("生产华为手机");
    	}
    
    }
    
    

    XiaomiPhone.java(小米手机)

    public class XiaomiPhone implements PhoneProject{
    
    	@Override
    	public void getId() {
    		// TODO Auto-generated method stub
    		System.out.println("编号:"+123412);
    	}
    
    	@Override
    	public void printInfo() {
    		// TODO Auto-generated method stub
    		System.out.println("生产了小米手机!!");
    	}
    }
    
    

    测试类:

    public class Client {
    	public static void main(String[] args) {
    		PhoneProject huawei = new HuaWeiFactory().projectPhone();
    		huawei.printInfo();
    		huawei.getId();
    		
    		PhoneProject xiaomi = new XiaomiFactory().projectPhone();
    		xiaomi.printInfo();
    		LaptopProject huawei1 = new HuaWeiFactory().projectLaptop();
    		huawei1.printInfo();
    	}
    }
    

    运行结果:

    image-20210805211054410

    总结:

    抽象工厂模式是工厂方法模式的升级版,后者面向单个产品,而前者面向的的是一个产品族。根据官方定义:为创建一组相关/互相依赖的对象提供一个接口而无需指定它们的具体类。
    比如一个汽车工厂要生成骑车,而每种汽车都有车门、车轮胎等一系列产品,这意味着每增加一款汽车就需要增加一个新的工厂来提供新产品的实现。这时候就可以使用抽象工厂模式来进行设计。抽象工厂模式适用于一系列产品族。

    优点:

    1. 抽象厂模式将产品族的依赖与约束关系放到抽象工厂中,便于管理。
    2. 职责解耦,用户不需要关心一堆自己不关心的细节,由抽象厂来负责组件的创建
    3. 切换产品族容易,只需要增加一个具体工厂实现,客户端选择另-个套餐就可以了

    缺点:

    1. 抽象工厂模式类增加的速度很快,有一个产品族就需要增加一一个具体工厂实现,比较繁琐
    2. 产品族难以扩展产品。当产品族中增加一个产品时,抽象工厂接口中需要增加一个函数,对应的所有具体工厂实现都需要修改,修改放大严重。
    3. 抽象厂并未完全屏蔽创建细节,给出的都是组件。对于这种情况可以结合工厂模式或简单工厂模式-起使用。

    使用场景:

    大家应该已经发现了,其实抽象工厂模式如果只有一个组件的话,其实是退化到工厂方法模式,也就是没有了产品族的概念,只剩一一个产品了,因此简单工厂,厂方法,抽象工厂这三者之间是有内在联系的,区别只产品的复杂度。抽象工厂的本质是选择产品族,因此大家可以根据这个特征来识别是否可以应用抽象厂。

    展开全文
  • 工厂模式: – 实现了创建者和调用者的分离。 – 详细分类: 简单工厂模式 工厂方法模式 抽象工厂模式 面向对象设计的基本原则: OCP(开闭原则,Open-Closed Principle):一个软件的实体应当对扩展开放,对修改...
  • 主要介绍了java设计模式之工厂模式,结合具有实例形式分析了java工厂模式的概念、原理、实现与使用方法,需要的朋友可以参考下
  • 实现方法我们将创建一个Shape接口和实现Shape接口的具体。一个工厂类ShapeFactory会在下一步中定义。FactoryPatternDemo这是一个演示,将使用ShapeFactory...实现工厂模式的结构如下所示-java-61.jpg第1步创建...

    实现方法

    我们将创建一个Shape接口和实现Shape接口的具体类。一个工厂类ShapeFactory会在下一步中定义。

    FactoryPatternDemo这是一个演示类,将使用ShapeFactory来获取一个Shape对象。它会将信息(CIRCLE/RECTANGLE/SQUARE)传递给ShapeFactory以获取所需的对象类型。

    实现工厂模式的结构如下图所示-

    java-61.jpg

    第1步

    创建一个接口-

    Shape.java

    publicinterfaceShape{

    voiddraw();

    }

    第2步

    创建实现相同接口的具体类。如下所示几个类-

    Rectangle.java

    publicclassRectangleimplementsShape{

    @Override

    publicvoiddraw(){

    System.out.println("InsideRectangle::draw()method.");

    }

    }

    Square.java

    publicclassSquareimplementsShape{

    @Override

    publicvoiddraw(){

    System.out.println("InsideSquare::draw()method.");

    }

    }

    Circle.java

    publicclassCircleimplementsShape{

    @Override

    publicvoiddraw(){

    System.out.println("InsideCircle::draw()method.");

    }

    }

    第3步

    创建工厂根据给定的信息生成具体类的对象。

    ShapeFactory.java

    publicclassShapeFactory{

    //usegetShapemethodtogetobjectoftypeshape

    publicShapegetShape(StringshapeType){

    if(shapeType==null){

    returnnull;

    }

    if(shapeType.equalsIgnoreCase("CIRCLE")){

    returnnewCircle();

    }elseif(shapeType.equalsIgnoreCase("RECTANGLE")){

    returnnewRectangle();

    }elseif(shapeType.equalsIgnoreCase("SQUARE")){

    returnnewSquare();

    }

    returnnull;

    }

    }

    第4步

    使用工厂通过传递类型等信息来获取具体类的对象。

    FactoryPatternDemo.java

    publicclassFactoryPatternDemo{

    publicstaticvoidmain(String[]args){

    ShapeFactoryshapeFactory=newShapeFactory();

    //getanobjectofCircleandcallitsdrawmethod.

    Shapeshape1=shapeFactory.getShape("CIRCLE");

    //calldrawmethodofCircle

    shape1.draw();

    //getanobjectofRectangleandcallitsdrawmethod.

    Shapeshape2=shapeFactory.getShape("RECTANGLE");

    //calldrawmethodofRectangle

    shape2.draw();

    //getanobjectofSquareandcallitsdrawmethod.

    Shapeshape3=shapeFactory.getShape("SQUARE");

    //calldrawmethodofcircle

    shape3.draw();

    }

    }

    第5步

    验证输出结果如下-

    InsideCircle::draw()method.

    InsideRectangle::draw()method.

    InsideSquare::draw()method.

    0a39f0cfeb8c8377ad9ab887b8860926.png

    本文转载自中文网

    展开全文
  • Java设计模式工厂模式 一、设计模式 1、什么是设计模式 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 2、应用设计模式有什么好处? 设计模式是优秀的使用案例,使用设计模式可...
  • 主要介绍了Java设计模式工厂模式实现方法,结合实例形式较为详细的分析了工厂模式的分类、原理、实现方法与相关注意事项,需要的朋友可以参考下
  • Java设计模式——工厂模式

    万次阅读 多人点赞 2015-12-10 09:37:55
    工厂模式是一种比较常见的创建模式。有时,可能你使用了工厂模式而你却还不知道你已经使用了它。至少我感觉下面说的第一种简单工厂模式,你是已经很熟悉了。并且是经常使用的。不信,就继续向下看。 版权说明 ...
  • java设计模式 - 工厂设计模式 概念:工厂设计模式java中应用最普通的应用模式之一,此设计模式属于创建型设计模式,它提供了一种创建对象的最佳方式。 意义:我们在创建对象的时候不会向用户暴露出创建的逻辑,...
  • java工厂模式实例(设计模式

    千次阅读 2021-01-26 19:20:35
    java工厂模式 开篇声明,此理解为作者自身理解,不一定正确,如有错误请大佬们指正。 工厂模式,在作者看来,从现实生活来说,就是一个工厂,里面有N个车间, 每个车间会生产不同的产品,而租户只需要告诉这个...
  • Java 设计模式-简单工厂模式

    千次阅读 2020-07-05 17:00:19
    Java 设计模式-简单工厂模式 文章目录Java 设计模式-简单工厂模式介绍简单工厂模式的结构与实现**简单工厂模式的优缺点和适用环境** 介绍 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method...
  • 主要为大家详细介绍了java设计模式之简单工厂模式,简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品的实例,感兴趣的小伙伴们可以参考一下
  • JAVA设计模式之抽象工厂模式

    万次阅读 多人点赞 2015-04-11 08:26:32
    本文属于23种设计模式系列。 继续前面简单工厂模式工厂方法模式的例子,以汽车配件制造介绍抽象工厂模式
  • 之所以需要引入工厂模式,是因为我们往往需要使用两个或两个以上的工厂。 public interface FoodFactory { Food makeFood(String name); } public class ChineseFoodFactory implements FoodFactory { @Override ...
  • Java设计模式工厂模式 1.简单工厂模式 实例化对象的时候不再...设计类图: 相关代码: Shape.java public interface Shape { void draw(); } Rectangle.java public class Rectangle implements Shape { @...
  • Java工厂设计模式

    2017-09-22 16:29:31
    工厂模式Java中最常用的设计模式之一。 这种类型的设计模式属于创建模式,因为此模式提供了创建对象的最佳方法之一。 在工厂模式中,我们没有创建逻辑暴露给客户端创建对象,并使用一个通用的接口引用新创建的...
  • JAVA设计模式--简单工厂模式

    万次阅读 2016-05-18 10:39:23
    简单工厂模式属于的创建型模式。提供一个创建对象实例的功能,而无须关心其具体实现。被创建实例的类型可以是接口、抽象,也可以是具体的。 简单工厂模式的本质:选择实现。 设计意图:通过专门定义一个来...
  • 上一篇我们学习了简单工厂...工厂方法模式和简单工厂模式的区别是,简单工厂模式只有一个工程类(对一个项目或一个模块),工厂方法模式有一组实现了相同接口的工程类。 下面看看工厂方法模式的具体实现 首先...
  •  简单工厂模式的UML  简单工厂模式代码  学习简单工厂模式的时候我用的是一个与人类有相关的例子。人类在世界分为男人和女人,首先定义一个Human产品的抽象接口 /** * This is factory patter package...
  • 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一...
  • 工厂模式在《Java模式》中分为三: 1)简单工厂模式(Simple Factory):不利于产生系列产品;2)工厂方法模式(Factory Method):又称为多形性工厂;3)抽象工厂模式(Abstract Factory):又称为工具箱,...
  • java 设计模式 抽象工厂模式 工厂方法模式
  • Java 设计模式分类

    2012-10-12 20:59:26
    设计模式在粒度和抽象层次上各不相同。由于存在众多的设计模式,所以我们可以用一种方式将它们组织起来。这里,我们根据两条准则对模式进行分类,如下表所示:   第一是目的准则,即模式是用来完成什么工作...
  • 设计模式工厂模式(简单工厂模式工厂方法模式,抽象工厂模式工厂模式介绍简单工厂模式工厂方法模式抽象工厂模式 工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 242,053
精华内容 96,821
关键字:

java工厂模式设计类图

java 订阅