java工廠模式大雜燴,什麼是java工廠模式

本文目錄一覽：

• 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中工廠模式分為:

簡單工廠模式(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 {

/*

* Type t = Type.GetType(“SimpleFactory.” + type);

* Woman wm =

* (Woman)Activator.CreateInstance(t); return wm;

*/

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.抽象工廠模式

一、靜態工廠模式：用靜態的方法實現，其創建的對象具有一定的特性

舉例如下：

Vehicle類：

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;

}

}

Bus類：

public class Bus extends Vehicle

{

private String name;

public Bus(){}

public Bus(String name){

super(name);

}

@Override

public abstract void run(){

System.out.println(“Bus is running”);

}

}

Car類：

public class Car extends Vehicle

{

private String name;

public Car(){}

public Car(String name){

super(name);

}

@Override

public abstract 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.getParmeterTypes();

if(cs.length0){

boolean isConstructor=true;

for(int i=0;ics.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#checked[List|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