Cara menggunakan corak kilang Java untuk mencipta objek dan meningkatkan penggunaan semula dan fleksibiliti kod

Pengenalan

Corak reka bentuk kilang Java terutamanya terbahagi kepada tiga jenis:

Corak Kilang Mudah: Gunakan kelas kilang untuk merangkum proses penciptaan objek, dan pelanggan hanya perlu Dapatkan yang berbeza objek produk dengan melepasi parameter yang berbeza, dengan itu mengelakkan penciptaan objek produk secara langsung oleh pelanggan

Corak Kaedah Kilang: Abstrak kelas kilang, dan setiap kelas produk tertentu sepadan dengan Kelas kilang tertentu menghasilkan objek produk yang sepadan melalui polimorfisme. Pelanggan hanya perlu mengetahui antara muka kilang dan kelas pelaksanaannya Ia boleh menukar pelaksanaan kilang secara dinamik mengikut keperluan, dan kebolehskalaan adalah lebih baik.

Corak Kilang Abstrak: Berdasarkan corak kaedah kilang. , kelas kilang disarikan semula, dan berbilang antara muka kilang dimasukkan ke dalam satu antara muka kilang Setiap produk tertentu sepadan dengan kelas kilang tertentu Melalui berbilang Ia mempunyai skala yang lebih baik dan tahap abstraksi yang lebih tinggi, tetapi ia juga meningkatkan kerumitan sistem

.

Corak Kilang Mudah

Mula-mula tentukan Kelas produk abstrak:

package com.fanqiechaodan.factory.simple.product;
/**
 * @Classname Product
 * @Description 抽象产品类
 */
public abstract class Product {
    public abstract void use();
}

Kemudian tentukan kelas produk tertentu

public class ProductA extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类A...");
    }
}
public class ProductB extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类B...");
    }
}
public class ProductC extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类C...");
    }
}

Seterusnya tentukan kelas kilang untuk mencipta produk yang berbeza

package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
/**
 * @Classname SimpleFactory
 * @Description 工厂类
 */
public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            case "C":
                return new ProductC();
            default:
                throw new RuntimeException("不支持的产品类型:" + type);
        }
    }
}

Ujian:

package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
/**
 * @Classname Demo
 * @Description 简单工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
        Product productC = SimpleFactory.createProduct("C");
        productC.use();
        Product productD = SimpleFactory.createProduct("D");
        productD.use();
    }
}

Corak kaedah kilang

Pertama tentukan antara muka untuk mewakili produk

package com.fanqiechaodan.factory.method.product;
/**
 * @Classname Product
 * @Description 产品接口
 */
public interface Product {
    void use();
}

Kedua tentukan dua kelas pelaksanaan produk tertentu

public class ProductA implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品A...");
    }
}
public class ProductB implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品B...");
    }
}

Kemudian tentukan kilang Antara muka digunakan untuk mencipta produk

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
/**
 * @Classname Factory
 * @Description 工厂接口
 */
public interface Factory {
    Product createProduct();
}

Seterusnya, tentukan dua kelas pelaksanaan kilang tertentu, masing-masing digunakan untuk mencipta produk yang berbeza

public class FactoryA implements Factory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

Uji

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
/**
 * @Classname FactoryB
 * @Description 工厂实现类B
 */
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

Corak Kilang Abstrak

Pertama tentukan produk abstrak

public interface ProductA {
    void doSomething();
}
public interface ProductB {
    void doSomething();
}

Kedua tentukan produk khusus

rreee

Kemudian tentukan kilang abstrak

public class ProductA1 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA1 doSomething ...");
    }
}
public class ProductA2 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA2 doSomething ...");
    }
}
public class ProductB1 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB1 doSomething ...");
    }
}
public class ProductB2 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB2 doSomething ...");
    }
}

Seterusnya tentukan Kilang khusus

package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname AbstractFactory
 * @Description 抽象工厂
 */
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

Ujian

public class Factory1 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}
public class Factory2 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

Atas ialah kandungan terperinci Cara menggunakan corak kilang Java untuk mencipta objek dan meningkatkan penggunaan semula dan fleksibiliti kod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!