Teknologian jakaminen

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Factory Pattern on suunnittelumalli, jota käytetään yleisesti olio-ohjelmoinnissaluova malli eräänlainen.Tehdasmallia käytetään pääasiassa objektien luomiseen, mutta se eroaa sen käyttämisestä suoraan koodissa.new Avainsanojen luonti eroaa siinä, että se luo objekteja yhteisen käyttöliittymän kautta, mikä erottaa objektin luontiprosessin asiakaskoodin käytöstä. Seuraavassa on yksityiskohtainen esittely tehdasmalliin:

1. Tehdasmallin pääominaisuudet

1. Kapseloitujen objektien luontiprosessi: Kapseloi objektin luontiprosessi tehdasluokkaan Asiakkaan tarvitsee vain määrittää luotavan objektin tyyppi, ja sitten se voi hankkia tarvittavan objektin tehdasluokan kautta välittämättä objektin luomisen yksityiskohdista.
2. Vähennä kytkentää: Eristämällä abstrakti tehdas ja betonitehdas, asiakkaan ja kohteen välinen kytkentä vähenee, jolloin asiakasohjelmaa on helpompi laajentaa ja ylläpitää.
3. Paranna ohjelman skaalautuvuutta: Kun haluat lisätä uuden tuotteen, sinun on lisättävä vain vastaava tuoteluokka ja vastaava tehdasluokka. Alkuperäistä koodia ei tarvitse muokata muokkausta varten), mikä parantaa koodin skaalautuvuutta.
4. Helppo huoltaa ja päivittää: Koska tehdasmenetelmä keskittää objektien luontiprosessin yhteen luokkaan, jos objektien luontitapaa on muutettava, tarvitsee vain muokata vastaavaa tehdasluokkaa, eikä sillä ole vaikutusta asiakkaaseen.
5. koodin uudelleenkäyttö: Tehdasmalli voi abstraktoida objektin luontiprosessin, toteuttaa koodin uudelleenkäytön ja lisätä koodin joustavuutta ja uudelleenkäytettävyyttä.

2. Tehdasmallin luokitus

Tehdaskuviot jaetaan pääasiassa kolmeen tyyppiin: yksinkertainen tehdaskuvio (staattinen tehdaskuvio), tehdasmenetelmäkuvio ja abstrakti tehdaskuvio.

1. Staattinen tehdasmenetelmä

1. Määrittele tehdasluokka palauttaaksesi eri luokkien esiintymät eri parametrien perusteella.
2. Tehdasluokat sisältävät yleensä useita staattisia menetelmiä, joista jokainen vastaa tietyn tuotteen luomista.
3. Edut: Yksinkertainen toteuttaa ja helppo ymmärtää.
4. Miinukset: Tehdasluokan vastuut ovat liian raskaat Uusia tuotteita lisättäessä tehdasluokan lähdekoodia on muutettava, mikä rikkoo avaus- ja sulkemisperiaatetta.

Yksinkertainen tehdaskuvioluokkakaavio

2. Tehdasmenetelmä (tehdasmenetelmä)

1. Määritä käyttöliittymä (abstrakti tehdas) objektien luomista varten,Mutta anna alaluokan päättää, mikä luokka instantoi。
2. Tehdasmenetelmät mahdollistavat luokan ilmentymisen lykkäämisen alaluokkiin.
3. Edut: Hyvä skaalautuvuus Kun uusia tuotteita on lisättävä, on lisättävä vain vastaavat tietyt tuotekategoriat ja tietyt tehdaskategoriat.
4. Haitat: Joka kerta kun tuote lisätään, on lisättävä tietty luokka- ja objektitoteutustehdas, mikä kaksinkertaistaa järjestelmän luokkien määrän ja lisää järjestelmän monimutkaisuutta.

Tehdasmenetelmän malli

3. Abstract Factory -kuvio (Abstract Factory)

1. Tarjoaa käyttöliittymän toisiinsa liittyvien tai toisistaan ​​riippuvaisten objektien sarjan luomiseen määrittelemättä niiden konkreettisia luokkia.
2. Abstrakti tehdaskuvio voidaan nähdä useiden tehdasmenetelmäkuvioiden yhteiskäytönä.
3. Edut: Tuoteperhe voidaan rajoittaa luokan sisällä Tietyn tehtaan on kyettävä valmistamaan kaikki tuoteperheen tuotteet.
4. Haitat: Se lisää abstraktiota ja järjestelmän ymmärtämisen vaikeutta, ja luokkien määrä järjestelmässä kasvaa merkittävästi.

abstrakti tehdaskuvio

3. Tehdasmallin sovellusskenaariot

Tehdasmallilla on laaja valikoima varsinaisia ​​sovelluksia, kuten tietokantayhteydet, käyttöliittymäohjaukset, tiedostojen käsittely, kirjaus, verkkoliikenne, viestijonot, tietorakenteet, salaus ja salauksen purku, viestien työntö ja tehtävien ajoitus. Näissä skenaarioissa tehdasmallin käyttö voi erottaa objektin luontiprosessin käyttöprosessista, mikä parantaa järjestelmän joustavuutta ja skaalautuvuutta.

4. Tehdasmalliesimerkki

1. Yksinkertainen tehdaskuvioesimerkki

Yksinkertaisessa tehdasmallissa määritämme tehdasluokan, joka voi palauttaa eri tyyppisiä esiintymiä annettujen parametrien perusteella.

Alla on esimerkki yksinkertaisesta Java-kielellä kirjoitetusta tehdaskuviosta. Luomme muototehtaan, joka voi tuottaa ympyröitä, suorakulmioita ja neliöitä. Ensin määritellään muotorajapinta (Shape) ja useita konkreettisia luokkia (Ympyrä, Suorakulmio, Neliö), jotka toteuttavat tämän rajapinnan.

// 形状接口  
interface Shape {  
    void draw();  
}  
  
// 圆形类  
class Circle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
}  
  
// 矩形类  
class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
// 正方形类  
class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Square::draw() method.");  
    }  
}

Seuraavaksi määrittelemme tehdasluokan (ShapeFactory), joka käyttää staattisia menetelmiä muotoobjektien luomiseen.

// 形状工厂类  
class ShapeFactory {  
  
    // 使用 getShape 方法获取形状类型的对象  
    public static Shape getShape(String shapeType){  
        if(shapeType == null){  
            return null;  
        }          
        if(shapeType.equalsIgnoreCase("CIRCLE")){  
            return new Circle();  
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){  
            return new Rectangle();  
        } else if(shapeType.equalsIgnoreCase("SQUARE")){  
            return new Square();  
        }  
          
        return null;  
    }  
}

Lopuksi voimme käyttää tehdasluokkaa muotoobjektien saamiseksi ja kutsua niitädrawmenetelmä.

public class FactoryPatternDemo {  
  
    public static void main(String[] args) {  
        // 获取 Circle 的对象，并调用它的 draw 方法  
        Shape shape1 = ShapeFactory.getShape("CIRCLE");  
        shape1.draw();  
  
        // 获取 Rectangle 的对象，并调用它的 draw 方法  
        Shape shape2 = ShapeFactory.getShape("RECTANGLE");  
        shape2.draw();  
  
        // 获取 Square 的对象，并调用它的 draw 方法  
        Shape shape3 = ShapeFactory.getShape("SQUARE");  
        shape3.draw();  
    }  
}

Tässä esimerkissäShapeFactoryluokka vastaa luomisestaShape Esimerkki käyttöliittymästä.Asiakaskoodi tekee tämän välittämällä tyyppitiedot (esim. merkkijono) käyttäjälleShapeFactorystaattinen luokkamenetelmägetShape saadaksesi halutun muodon esiintymän. Tällä tavalla asiakas irrotetaan tietyn luokan toteutuksesta ja noudattaa avaus- ja sulkemisperiaatetta, eli uusia muotoluokkia voidaan laajentaa asiakaskoodia muuttamatta. Yksinkertaisen tehdaskuvion suuri haitta on kuitenkin se, että jos järjestelmää on laajennettava uusilla tuoteperheillä (kuten väreillä muotojen lisäksi jne.), tehdasluokkaa on muutettava, mikä rikkoo osaa avoimesta. -suljettu periaate. Harkitse tässä tapauksessa Factory Method - tai Abstract Factory -kuvion käyttöä.

2. Tehdasmenetelmän malliesimerkki

Edelleen muotoaan esimerkkinä, käytämme suunnittelumenetelmiä sen luomiseen.

Määritä ensin muodon käyttöliittymä (Tuote) ja luo kolme toteutusluokkaa.

// 形状接口  
interface Shape {  
    void draw();  
}
 
// 圆形类  
class Circle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
}  
  
// 矩形类  
class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
// 正方形类  
class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Square::draw() method.");  
    }  
}

Määritä seuraavaksi luojan käyttöliittymä (Creator) ja konkreettinen luoja (Concrete Creator):

// 创建者接口  
interface ShapeFactory {  
    Shape getShape(String shapeType);  
}  
  
// 具体创建者类  
class RectangleFactory implements ShapeFactory {  
    @Override  
    public Shape getShape(String shapeType) {  
        if (shapeType == null) {  
            return null;  
        }  
        if (shapeType.equalsIgnoreCase("RECTANGLE")) {  
            return new Rectangle();  
        }  
        return null;  
    }  
}  
  
class CircleFactory implements ShapeFactory {  
    @Override  
    public Shape getShape(String shapeType) {  
        if (shapeType == null) {  
            return null;  
        }  
        if (shapeType.equalsIgnoreCase("CIRCLE")) {  
            return new Circle();  
        }  
        return null;  
    }  
}  
  
class SquareFactory implements ShapeFactory {  
    @Override  
    public Shape getShape(String shapeType) {  
        if (shapeType == null) {  
            return null;  
        }  
        if (shapeType.equalsIgnoreCase("SQUARE")) {  
            return new Square();  
        }  
        return null;  
    }  
}

Käytä lopuksi konkreettista luojaluokkaa saadaksesi muotoobjektit ja kutsua niitädrawmenetelmä:

public class FactoryMethodPatternDemo {  
  
    public static void main(String[] args) {  
        ShapeFactory shapeFactory = new CircleFactory();  
  
        // 获取 Circle 的对象，并调用它的 draw 方法  
        Shape shape1 = shapeFactory.getShape("CIRCLE");  
        shape1.draw();  
  
        // 使用 RectangleFactory 来获取 Rectangle 的对象  
        shapeFactory = new RectangleFactory();  
        Shape shape2 = shapeFactory.getShape("RECTANGLE");  
        shape2.draw();  
  
        // 使用 SquareFactory 来获取 Square 的对象  
        shapeFactory = new SquareFactory();  
        Shape shape3 = shapeFactory.getShape("SQUARE");  
        shape3.draw();  
    }  
}

Tässä esimerkissäLuomme kullekin muotoluokalle vastaavan tehdasluokan (Vaikka todellisissa sovelluksissa on yleensä yleisempi tehdasluokkarakenne, ehkä määritystiedostojen tai pohdinnan kautta, jotta vältytään kirjoittamasta erillisiä tehdasluokkia kullekin tuoteluokalle). Tämä auttaa esittelemään Factory Method -mallin perusperiaatteet,Eli anna tehtaan alaluokan päättää, mikä luokka instantoidaan . Tämän esimerkin yksinkertaisessa tapauksessa saatat kuitenkin olla taipuvaisempia käyttämään Simple Factory -mallia tai harkitsemaan muita suunnittelumalleja koodin päällekkäisyyden vähentämiseksi.

3. Abstrakti tehdasesimerkki

Tässä esimerkissä otetaan esimerkkinä matkapuhelimet, matkapuhelimiin liittyvät abstraktit tuotteet (kuten näytöt, akut, käyttöjärjestelmät jne.) ja luodaan erityisiä tuoteluokkia näiden rajapintojen toteuttamiseksi. Voimme sitten määritellä abstrakteja tehdasrajapintoja ja konkreettisia tehdasluokkia näiden tuotteiden valmistamiseksi. Tässä on yksinkertaistettu esimerkki siitä, kuinka Abstract Factory -kuviota käytetään osien (näytöt ja akut) tuottamiseen eri matkapuhelinmerkeille ja -malleille:

Määritä ensin tuotteen käyttöliittymä ja tietyt tuotteet:

// 屏幕接口  
interface Screen {  
    void display();  
}  
  
 
// 高端屏幕的实现  
class HighEndScreen implements Screen {  
    @Override  
    public void display() {  
        System.out.println("显示高清屏幕");  
    }  
}  
  
// 低端屏幕的实现  
class LowEndScreen implements Screen {  
    @Override  
    public void display() {  
        System.out.println("显示普通屏幕");  
    }  
}  
 
 
// 电池接口  
interface Battery {  
    void charge();  
}
 
  
// 高效电池的实现  
class HighEfficiencyBattery implements Battery {  
    @Override  
    public void charge() {  
        System.out.println("快速充电");  
    }  
}  
  
// 标准电池的实现  
class StandardBattery implements Battery {  
    @Override  
    public void charge() {  
        System.out.println("标准充电");  
    }  
}

Määritä seuraavaksi abstrakti tehdasliittymä ja betonitehdasluokka:

// 手机组件工厂接口  
interface PhoneFactory {  
    Screen createScreen();  
    Battery createBattery();  
}  
  
// 高端手机工厂  
class HighEndPhoneFactory implements PhoneFactory {  
    @Override  
    public Screen createScreen() {  
        return new HighEndScreen();  
    }  
  
    @Override  
    public Battery createBattery() {  
        return new HighEfficiencyBattery();  
    }  
}  
  
// 低端手机工厂  
class LowEndPhoneFactory implements PhoneFactory {  
    @Override  
    public Screen createScreen() {  
        return new LowEndScreen();  
    }  
  
    @Override  
    public Battery createBattery() {  
        return new StandardBattery();  
    }  
}

Lopuksi asiakaskoodi, joka käyttää abstraktia tehdasta konkreettisten tuoteobjektien luomiseen:

public class PhoneFactoryPatternDemo {  
    public static void main(String[] args) {  
        // 使用高端手机工厂  
        PhoneFactory highEndFactory = new HighEndPhoneFactory();  
        Screen highEndScreen = highEndFactory.createScreen();  
        Battery highEndBattery = highEndFactory.createBattery();  
  
        highEndScreen.display();  
        highEndBattery.charge();  
  
        // 使用低端手机工厂  
        PhoneFactory lowEndFactory = new LowEndPhoneFactory();  
        Screen lowEndScreen = lowEndFactory.createScreen();  
        Battery lowEndBattery = lowEndFactory.createBattery();  
  
        lowEndScreen.display();  
        lowEndBattery.charge();  
    }  
}

Tässä esimerkissä määrittelemme kaksi matkapuhelintehdasta (high-end ja lowend), jotka kumpikin pystyvät tuottamaan tietyntyyppisen näytön ja akun.Asiakaskoodi on vuorovaikutuksessa tietyn tehdasluokan kanssa abstraktin tehdasrajapinnan kautta, mikä saavuttaa irrotuksen tietystä tuoteluokasta. . Tällä tavalla, jos meidän on tulevaisuudessa lisättävä uusia puhelintyyppejä (esimerkiksi keskihintaisia ​​puhelimia), meidän tarvitsee vain lisätä uusia tuoteluokkia ja vastaavia tehdasluokkia ilman, että muutamme olemassa olevaa asiakaskoodia.

5. Yhteenveto

Tehdaskuvio on erittäin hyödyllinen suunnittelukuvio,Se kapseloi objektien luontiprosessin, vähentää kytkentää, parantaa ohjelman skaalautuvuutta ja ylläpidon helppoutta jne. , on käytetty laajasti ohjelmistokehityksessä.Siinä on kuitenkin myös joitainHaitat, kuten liialliset tehdasvastuut, vaikeudet järjestelmän laajentamisessa jne. . Siksi käytännön sovelluksissa kompromisseja ja valintoja on tehtävä erityisten skenaarioiden ja tarpeiden perusteella.

Jos tehdaskuvio (yksinkertainen tehdas, tehdasmenetelmä, abstrakti tehdas) on sinulle hyödyllinen, muista tykätä ja kerätä siitä.