⑴ java的工廠模式有哪一些，分別有什麼作用，一般用在哪些地方
我簡單的說下，舉個例子，當我們的程序結構比較繁雜時，比如有100個類，而類中又有很多方法，這些方法之間都互相有依賴關系，也就是一個方法之間的某段邏輯處理需要用到另一個類中的代碼邏輯，這種時候對於整個程序而言是非常不利於開發的（我們需要考慮到很多類、方法之間的耦合問題），那麼就有一個概念了，也就是面對介面編程。通俗的說就是把類中的方法封裝起來，外部調用的人完全不需要考慮方法是如何實現的，但是這樣做也有一個不好的地方，我們的介面是不提供方法實現的，而需要在類中實現介面的方法。那麼問題產生了，我們在new介面對象的時候需要明確的知道他的實例類。
想像一下，如果程序在繼續龐大，介面非常多，介面實例類非常多，這樣又會產生我們之前的問題（我們需要考慮到很多類、方法之間的耦合問題）那麼這個時候就產生了一中設計思想，也就是工廠模式，這種模式的核心思想就是管理介面的實例對象，把介面和實例對象之間的關系封裝起來處理，外部需要用到某個介面的實例時，由工廠進行分配，而不需要關注具體是哪個實例。
如果你做到比較復雜的程序時你應該就能體會到了。
⑵ java中的工廠模式是什麼意思
工廠模式簡單的講就是用工廠方法代替了new的操作，
在通俗點就是說，你new一個對象的時候直接調用工廠方法就行了，
在編程時，需要定義一個工廠介面，由不同的的子類去實現，再定一個具體工廠類，定義一個產生實例的方法，我們通過這個方法來獲得實例就行了，
⑶ 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中 什麼是工廠
工廠是一種設計模式！
為何使用?
工廠模式是我們最常用的模式了,著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統可以說是隨處可見。
為什麼工廠模式是如此常用？因為工廠模式就相當於創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A() 工廠模式也是用來創建實例對象的，所以以後new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。
我們以類Sample為例， 如果我們要創建Sample的實例對象:
Sample sample=new Sample();
可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值 查詢資料庫等。
首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成:
Sample sample=new Sample(參數);
但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。
為什麼說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當於將很多雞蛋放在一個籃子里，是很危險的，這也是有背於Java 面向對象的原則，面向對象的封裝(Encapsulation)和分派(Delegation)告訴我們，盡量將長的代碼分派「切割」成每段，將每段再 「封裝」起來(減少段和段之間偶合聯系性)，這樣，就會將風險分散，以後如果需要修改，只要更改每段，不會再發生牽一動百的事情。
在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。
這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向介面編程,我們需要將Sample抽象成一個介面.現在Sample是介面,有兩個子類MySample 和HisSample .我們要實例化他們時,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
隨著項目的深入,Sample可能還會"生出很多兒子出來", 那麼我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入後來生出兒子的實例.這在傳統程序中是無法避免的.
但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.
工廠方法
你會建立一個專門生產Sample實例的工廠:
public class Factory{
public static Sample creator(int which){
//getClass 產生Sample 一般可使用動態類裝載裝入類。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
那麼在你的程序中,如果要實例化Sample時.就使用
Sample sampleA=Factory.creator(1);
這樣,在整個就不涉及到 Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會,這個原理可以用很通俗的話來比喻:就是具體事情做得越多,越容易范錯誤.這每個做過具體工作的人都深有體會,相反,官做得越高,說出的話越抽象越籠統,范錯誤可能性就越少.好象我們從編程序中也能悟出人生道理?呵呵.
使用工廠方法 要注意幾個角色，首先你要定義產品介面，如上面的Sample,產品介面下有Sample介面的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，如下圖，最右邊是生產的對象Sample：
進一步稍微復雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。
抽象工廠
工廠模式中有: 工廠方法(Factory Method) 抽象工廠(Abstract Factory).
這兩個模式區別在於需要創建對象的復雜程度上。如果我們創建對象的方法變得復雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品介面Sample2.
這里假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2
那麼，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什麼我不可以使用兩個工廠方法來分別生產Sample和Sample2?
抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯系，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特徵，也許製造過程是統一的，比如：製造工藝比較簡單，所以名稱叫SimpleFactory。
在實際應用中，工廠方法用得比較多一些，而且是和動態類裝入器組合在一起應用。
⑸ android,java裡面的工廠模式，反射模式是什麼意思
反射就是通過方法名類名去調用一些你沒有代碼,也沒有jar包的介面.
工廠模式是設計模式之一,他的思路就是通過一個工廠類去生產需要頻繁創建的對象, 問度娘詳情吧.
⑹ 用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.length>0){
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策略模式和工廠模式的區別
工廠模式是創建型模式
策略模式是行為性模式
一個關注對象創建
一個關注行為的封裝
策略模式就是定義一系列的演算法，這些演算法可以在需要的時候替換和擴展．工廠模式是生成型的模式，在你需要的時候構建具體的實例．
在下面的情況下應當考慮使用策略模式：
1. 如果在一個系統裡面有許多類，它們之間的區別僅在於它們的行為，那麼使用策略模式可以動態地讓一個對象在許多行為中選擇一種行為。
2.
一個系統需要動態地在幾種演算法中選擇一種。那麼這些演算法可以包裝到一個個的具體演算法類裡面，而這些具體演算法類都是一個抽象演算法類的子類。換言之，這些具體
演算法類均有統一的介面，由於多態性原則，客戶端可以選擇使用任何一個具體演算法類，並只持有一個數據類型是抽象演算法類的對象。
3. 一個系統的演算法使用的數據不可以讓客戶端知道。策略模式可以避免讓客戶端涉及到不必要接觸到的復雜的和只與演算法有關的數據。
4. 如果一個對象有很多的行為，如果不用恰當的模式，這些行為就只好使用多重的條件選擇語句來實現。此時，使用策略模式，把這些行為轉移到相應的具體策略類裡面，就可以避免使用難以維護的多重條件選擇語句，並體現面向對象設計的概念。
策略模式的優點和缺點
策略模式有很多優點和缺點。它的優點有：
1. 策略模式提供了管理相關的演算法族的辦法。策略類的等級結構定義了一個演算法或行為族。恰當使用繼承可以把公共的代碼移到父類裡面，從而避免重復的代碼。
2.
策略模式提供了可以替換繼承關系的辦法。繼承可以處理多種演算法或行為。如果不是用策略模式，那麼使用演算法或行為的環境類就可能會有一些子類，每一個子類提
供一個不同的演算法或行為。但是，這樣一來演算法或行為的使用者就和演算法或行為本身混在一起。決定使用哪一種演算法或採取哪一種行為的邏輯就和演算法或行為的邏輯
混合在一起，從而不可能再獨立演化。繼承使得動態改變演算法或行為變得不可能。
3. 使用策略模式可以避免使用多重條件轉移語句。多重轉移語句不易維護，它把採取哪一種演算法或採取哪一種行為的邏輯與演算法或行為的邏輯混合在一起，統統列在一個多重轉移語句裡面，比使用繼承的辦法還要原始和落後。
策略模式的缺點有：
1. 客戶端必須知道所有的策略類，並自行決定使用哪一個策略類。這就意味著客戶端必須理解這些演算法的區別，以便適時選擇恰當的演算法類。換言之，策略模式只適用於客戶端知道所有的演算法或行為的情況。
2. 策略模式造成很多的策略類。有時候可以通過把依賴於環境的狀態保存到客戶端裡面，而將策略類設計成可共享的，這樣策略類實例可以被不同客戶端使用。換言之，可以使用享元模式來減少對象的數量。
策略模式與很多其它的模式都有著廣泛的聯系。Strategy很容易和Bridge模式相混淆。雖然它們結構很相似，但它們卻是為解決不同的問題
而設計的。Strategy模式注重於演算法的封裝，而Bridge模式注重於分離抽象和實現，為一個抽象體系提供不同的實現。Bridge模式與
Strategy模式都很好的體現了"Favor composite over inheritance"的觀點。