java工厂模式大杂烩,什么是java工厂模式

发布时间：2022-11-22

本文目录一览：

  1. java中常用到得设计模式有哪几种？
  2. java中的工厂模式是什么意思？
  3. 用java 编写程序写出简单的工厂模式?
  4. Java的几个工厂方法解析
  5. java中几种常见的设计模式
  6. java 设计模式用了哪些

java中常用到得设计模式有哪几种？

Java中的23种设计模式： Factory（工厂模式）, Builder（建造模式）, Factory Method（工厂方法模式）, Prototype（原始模型模式）, Singleton（单例模式）, Facade（门面模式）, Adapter（适配器模式）, Bridge（桥梁模式）, Composite（合成模式）, Decorator（装饰模式）, Flyweight（享元模式）, Proxy（代理模式）, Command（命令模式）, Interpreter（解释器模式）, Visitor（访问者模式）, Iterator（迭代子模式）, Mediator（调停者模式）, Memento（备忘录模式）, Observer（观察者模式）, State（状态模式）, Strategy（策略模式）, Template Method（模板方法模式）, Chain Of Responsibleity（责任链模式） 工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

java中的工厂模式是什么意思？

工厂模式简单的讲就是用工厂方法代替了new的操作，在通俗点就是说，你new一个对象的时候直接调用工厂方法就行了。在编程时，需要定义一个工厂接口，由不同的的子类去实现，再定一个具体工厂类，定义一个产生实例的方法，我们通过这个方法来获得实例就行了。

用java 编写程序写出简单的工厂模式?

java中工厂模式分为:

  1. 简单工厂模式(Simple Factory)
  2. 工厂方法模式(Factory Method)
  3. 抽象工厂模式(Abstract Factory) 每种方法的实现不同。 提供一个简单工厂模式的案例：
public abstract class Woman {
    private String mySkill;
    public String getMySkill() {
        return mySkill;
    }
    public Woman() {
        // System.out.println("我是女人");
    }
    public void setMySkill(String mySkill) {
        this.mySkill = mySkill;
    }
}

public class LovelinessWoman extends Woman {
    /* 可爱型女人 */
    public LovelinessWoman() {
        String mySkill = "撒过娇、出过轨、勾引领导下过水";
        this.setMySkill(mySkill);
    }
}

public class SteelinessWoman extends Woman {
    /* 冷酷型女人 */
    public SteelinessWoman() {
        String mySkill = "装过神、弄过鬼，跟别人老公亲过嘴";
        this.setMySkill(mySkill);
    }
}

public class WomanMakeFactory {
    public Woman findWoman(int typeID) {
        switch (typeID) {
            case 1:
                return new LovelinessWoman();
            case 2:
                return new VirtuousWoman();
            case 3:
                return new SteelinessWoman();
            default:
                return null;
        }
    }
    public Woman findWoman(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        String string = "cn.jbit.design.simplefactory." + type;
        Class c = Class.forName(string);
        Woman wm = (Woman) c.newInstance();
        return wm;
    }
}

public class Test2 {
    /**
     * @param args
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws ClassNotFoundException
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Scanner input = new Scanner(System.in);
        boolean sel = false;
        do {
            System.out.println("请选择你要找的女人的类型");
            System.out.println("LovelinessWoman：可爱型女人 VirtuousWoman：善良型女人 SteelinessWoman：冷酷型女人");
            String typeid = input.next();
            WomanMakeFactory factory = new WomanMakeFactory();
            Woman wm = factory.findWoman(typeid);
            System.out.println("该类型女人的新标准：");
            System.out.println(wm.getMySkill());
            System.out.println("还想看看别的类型吗？y代表想，n代表再也不想了");
            sel = input.next().equals("y");
        } while (sel);
    }
}

Java的几个工厂方法解析

Java工厂模式可分为三种：

  1. 静态工厂模式
  2. 工厂方法模式
  3. 抽象工厂模式

一、静态工厂模式：用静态的方法实现，其创建的对象具有一定的特性

举例如下：

public abstract class Vehicle {
    private String name;
    public Vehicle() {
        super();
    }
    public Vehicle(String name) {
        super();
        this.name = name;
    }
    public abstract void run();
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class Bus extends Vehicle {
    private String name;
    public Bus() {}
    public Bus(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println("Bus is running");
    }
}

public class Car extends Vehicle {
    private String name;
    public Car() {}
    public Car(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println("Car is running");
    }
}

静态工厂类：

public class StaticFactory {
    public static Object getInstance(String className) {
        Object instance = null;
        try {
            Class c = Class.forName(className);
            instance = c.newInstance();
        } catch (Exception e) {}
        return instance;
    }
    public static Object getInstance(String className, Object... args) {
        Class c = null;
        try {
            c = Class.forName(className);
        } catch (Exception e) {}
        Constructor[] cons = c.getConstructors();
        Object instance = null;
        for (Constructor con : cons) {
            Class<?>[] cs = con.getParameterTypes();
            if (cs.length == args.length) {
                boolean isConstructor = true;
                for (int i = 0; i < cs.length; i++) {
                    Class t = cs[i];
                    if (!t.isInstance(args[i])) {
                        isConstructor = false;
                    }
                }
                if (isConstructor) {
                    try {
                        instance = con.newInstance(args);
                        break;
                    } catch (Exception e) {}
                } else {
                    continue;
                }
            }
        }
        return instance;
    }
}

二、工厂方法模式：主要是对各类东西分类生产，但分类生产的对象仍然具有某一特性。

如果说静态工厂是一个综合的交通工具建造工厂，那么工厂方法模式就是具体分工，分成Bus与Car的工厂，各自生产各自的产品，但是造出来的还是交通工具。 交通工具制造接口：

public interface VehicleMake {
    /** 制造交通工具 **/
    public Vehicle make();
}

Bus制造类：

public class BusMake implements VehicleMake {
    @Override
    public Vehicle make() {
        Vehicle bus = new Bus();
        System.out.println("Bus工厂制造了一辆Bus");
        return bus;
    }
}

Car制造类：

public class CarMake implements VehicleMake {
    @Override
    public Vehicle make() {
        Vehicle car = new Car();
        System.out.println("Car工厂制造了一辆Car");
        return car;
    }
}

三、抽象工厂模式：抽象工厂生产的对象可能是没有共同特性的。比如，一个制造工厂BusMake不仅能制造Bus还能生产轮胎wheel等配件，Bus是交通工具，wheel是配件（代码中有部分类没具体写出来只给了类名）

总工厂（抽象工厂总接口）：

public interface WheelVehicleMake extends VehicleMake {
    /** 制造轮胎 **/
    public Wheel makeWheel();
}

轮子BusMake：

public class WheelBusMake implements WheelVehicleMake {
    @Override
    public Vehicle make() {
        Vehicle bus = new Bus();
        System.out.println("WheelBusMake生产了一辆Bus");
        return bus;
    }
    @Override
    public Wheel makeWheel() {
        Wheel busWheel = new BusWheel();
        System.out.println("WheelBusMake生产了一个Bus轮子");
        return busWheel;
    }
}

轮子CarMake：

public class WheelCarMake implements WheelVehicleMake {
    @Override
    public Vehicle make() {
        Vehicle car = new Car();
        System.out.println("WheelCarMake生产了一辆Car");
        return car;
    }
    @Override
    public Wheel makeWheel() {
        Wheel carWheel = new CarWheel();
        System.out.println("WheelCarMake生产了一个Car轮子");
        return carWheel;
    }
}

java中几种常见的设计模式

一共23种设计模式！ 按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。 创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。 创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：

  • 工厂方法模式（Factory Method Pattern）
  • 抽象工厂模式（Abstract Factory Pattern）
  • 建造者模式（Builder Pattern）
  • 原型模式（Prototype Pattern）
  • 单例模式（Singleton Pattern） 结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
  • 适配器模式（Adapter Pattern）
  • 桥接模式（Bridge Pattern）
  • 组合模式（Composite Pattern）
  • 装饰者模式（Decorator Pattern）
  • 外观模式（Facade Pattern）
  • 享元模式（Flyweight Pattern）
  • 代理模式（Proxy Pattern） 行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
  • 责任链模式（Chain of Responsibility Pattern）
  • 命令模式（Command Pattern）
  • 解释器模式（Interpreter Pattern）
  • 迭代器模式（Iterator Pattern）
  • 中介者模式（Mediator Pattern）
  • 备忘录模式（Memento Pattern）
  • 观察者模式（Observer Pattern）
  • 状态模式（State Pattern）
  • 策略模式（Strategy Pattern）
  • 模板方法模式（Template Method Pattern）
  • 访问者模式（Visitor Pattern） 推荐你一本好书：《软件秘笈：设计模式那点事》，里面讲解的23中设计模式例子很生动，容易理解，还有JDK中设计模式应用情况，看了收获挺大的！百度里面搜“设计模式”，第一条中设计模式百度百科中就有首推该图书，浏览量在20几万以上的，不会错的。好东西大家一起分享！ 祝你早日学会设计模式！

java 设计模式用了哪些

在JDK(Java Development Kit)类库中，开发人员使用了大量设计模式，正因为如此，我们可以在不修改JDK源码的前提下开发出自己的应用软件，研究JDK类库中的模式实例也不失为学习如何使用设计模式的一个好方式。

创建型模式：

  1. 抽象工厂模式(Abstract Factory)
    • Java.util.Calendar#getInstance()
    • java.util.Arrays#asList()
    • java.util.ResourceBundle#getBundle()
    • java.NET.URL#openConnection()
    • java.sql.DriverManager#getConnection()
    • java.sql.Connection#createStatement()
    • java.sql.Statement#executeQuery()
    • java.text.NumberFormat#getInstance()
    • java.lang.management.ManagementFactory (所有getXXX()方法)
    • java.nio.charset.Charset#forName()
    • javax.xml.parsers.DocumentBuilderFactory#newInstance()
    • javax.xml.transform.TransformerFactory#newInstance()
    • javax.xml.xpath.XPathFactory#newInstance()
  2. 建造者模式(Builder)
    • java.lang.StringBuilder#append()
    • java.lang.StringBuffer#append()
    • java.nio.ByteBuffer#put() (CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer 和 DoubleBuffer与之类似)
    • javax.swing.GroupLayout.Group#addComponent()
    • java.sql.PreparedStatement
    • java.lang.Appendable的所有实现类
  3. 工厂方法模式(Factory Method)
    • java.lang.Object#toString() (在其子类中可以覆盖该方法)
    • java.lang.Class#newInstance()
    • java.lang.Integer#valueOf(String) (Boolean, Byte, Character, Short, Long, Float 和 Double与之类似)
    • java.lang.Class#forName()
    • java.lang.reflect.Array#newInstance()
    • java.lang.reflect.Constructor#newInstance()
  4. 原型模式(Prototype)
    • java.lang.Object#clone() (支持浅克隆的类必须实现java.lang.Cloneable接口)
  5. 单例模式(Singleton)
    • java.lang.Runtime#getRuntime()
    • java.awt.Desktop#getDesktop()

结构型模式：

  1. 适配器模式(Adapter)
    • java.util.Arrays#asList()
    • javax.swing.JTable(TableModel)
    • java.io.InputStreamReader(InputStream)
    • java.io.OutputStreamWriter(OutputStream)
    • javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
    • javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()
  2. 桥接模式(Bridge)
    • AWT (提供了抽象层映射于实际的操作系统)
    • JDBC
  3. 组合模式(Composite)
    • javax.swing.JComponent#add(Component)
    • java.awt.Container#add(Component)
    • java.util.Map#putAll(Map)
    • java.util.List#addAll(Collection)
    • java.util.Set#addAll(Collection)
  4. 装饰模式(Decorator)
    • java.io.BufferedInputStream(InputStream)
    • java.io.DataInputStream(InputStream)
    • java.io.BufferedOutputStream(OutputStream)
    • java.util.zip.ZipOutputStream(OutputStream)
    • java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap
  5. 外观模式(Facade)
    • java.lang.Class
    • javax.faces.webapp.FacesServlet
  6. 享元模式(Flyweight)
    • java.lang.Integer#valueOf(int)
    • java.lang.Boolean#valueOf(boolean)
    • java.lang.Byte#valueOf(byte)
    • java.lang.Character#valueOf(char)
  7. 代理模式(Proxy)
    • java.lang.reflect.Proxy
    • java.rmi.*

行为型模式：

  1. 职责链模式(Chain of Responsibility)
    • java.util.logging.Logger#log()
    • javax.servlet.Filter#doFilter()
  2. 命令模式(Command)
    • java.lang.Runnable
    • javax.swing.Action
  3. 解释器模式(Interpreter)
    • java.util.Pattern
    • java.text.Normalizer
    • java.text.Format
    • javax.el.ELResolver
  4. 迭代器模式(Iterator)
    • java.util.Iterator
    • java.util.Enumeration
  5. 中介者模式(Mediator)
    • java.util.Timer (所有scheduleXXX()方法)
    • java.util.concurrent.Executor#execute()
    • java.util.concurrent.ExecutorService (invokeXXX()和submit()方法)
    • java.util.concurrent.ScheduledExecutorService (所有scheduleXXX()方法)
    • java.lang.reflect.Method#invoke()
  6. 备忘录模式(Memento)
    • java.util.Date
    • java.io.Serializable
    • javax.faces.component.StateHolder
  7. 观察者模式(Observer)
    • java.util.Observer/java.util.Observable
    • java.util.EventListener (所有子类)
    • javax.servlet.http.HttpSessionBindingListener
    • javax.servlet.http.HttpSessionAttributeListener
    • javax.faces.event.PhaseListener
  8. 状态模式(State)
    • java.util.Iterator
    • javax.faces.lifecycle.LifeCycle#execute()
  9. 策略模式(Strategy)
    • java.util.Comparator#compare()
    • javax.servlet.http.HttpServlet
    • javax.servlet.Filter#doFilter()
  10. 模板方法模式(Template Method)
    • java.io.InputStream, java.io.OutputStream, java.io.Reader和java.io.Writer的所有非抽象方法
    • java.util.AbstractList, java.util.AbstractSet和java.util.AbstractMap的所有非抽象方法
    • javax.servlet.http.HttpServlet#doXXX()
  11. 访问者模式(Visitor)
    • javax.lang.model.element.AnnotationValue和AnnotationValueVisitor
    • javax.lang.model.element.Element和ElementVisitor
    • javax.lang.model.type.TypeMirror和TypeVisitor
推荐文章