ஜாவாவில் வடிவமைப்பு வடிவங்கள் [பகுதி 2]

எல்லோருக்கும் வணக்கம். எனது முந்தைய கட்டுரையில் , ஒவ்வொரு வடிவத்தையும் சுருக்கமாக விவரித்தேன். இந்த கட்டுரையில், வடிவங்களை எவ்வாறு பயன்படுத்துவது என்பதை விரிவாகக் காட்ட முயற்சிப்பேன்.

படைப்பு

சிங்கிள்டன்

விளக்கம்: ஒரு வகுப்பின் உருவாக்கத்தை ஒரு நிகழ்விற்கு கட்டுப்படுத்துகிறது, மேலும் அந்த ஒற்றை நிகழ்விற்கான அணுகலை வழங்குகிறது. வகுப்பின் கட்டமைப்பாளர் தனிப்பட்டவர். இந்த getInstance()முறை வகுப்பின் ஒரு நிகழ்வை மட்டுமே உருவாக்குகிறது. செயல்படுத்தல்:

class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
		}
        return instance;
    }
    public void setUp() {
        System.out.println("setUp");
    }
}

public class SingletonTest { // Test
    public static void main(String[] args){
        Singleton singelton = Singleton.getInstance();
        singelton.setUp();
    }
}

தொழிற்சாலை

விளக்கம்: எங்களிடம் பல துணைப்பிரிவுகளுடன் சூப்பர்கிளாஸ் இருக்கும்போது பயன்படுத்தப்படும், மேலும் உள்ளீட்டின் அடிப்படையில் ஒரு துணைப்பிரிவை நாங்கள் திரும்பப் பெற வேண்டும். எந்த வகையான பொருளை உருவாக்க வேண்டும் என்பது வகுப்பிற்குத் தெரியாது. உள்ளீடுகளின் அடிப்படையில் பொருள்கள் உருவாக்கப்படுகின்றன. செயல்படுத்தல்:

class Factory {
    public OS getCurrentOS(String inputOS) {
        OS os = null;
        if (inputOS.equals("windows")) {
            os = new windowsOS();
        } else if (inputOS.equals("linux")) {
            os = new linuxOS();
        } else if (inputOS.equals("mac")) {
            os = new macOS();
        }
        return os;
    }
}
interface OS {
    void getOS();
}
class windowsOS implements OS {
    public void getOS () {
        System.out.println("uses Windows");
    }
}
class linuxOS implements OS {
    public void getOS () {
        System.out.println("uses Linux");
    }
}
class macOS implements OS {
    public void getOS () {
        System.out.println("uses macOS");
    }
}

public class FactoryTest { // Test
    public static void main(String[] args){
         String osName = "linux";
        Factory factory = new Factory();
        OS os = factory.getCurrentOS(osName);
        os.getOS();
    }
}

சுருக்கம் தொழிற்சாலை

விளக்கம்: சாத்தியமான தொழிற்சாலைகளின் குடும்பத்திலிருந்து ஒரு குறிப்பிட்ட தொழிற்சாலை செயலாக்கத்தைத் தேர்ந்தெடுக்க உங்களை அனுமதிக்கிறது. தொடர்புடைய பொருள்களின் குடும்பத்தை உருவாக்குகிறது. விரிவாக்க எளிதானது. செயல்படுத்தல்:

interface Lada {
    long getLadaPrice();
}
interface Ferrari {
    long getFerrariPrice();
}
interface Porshe {
    long getPorshePrice();
}
interface InteAbsFactory {
    Lada getLada();
    Ferrari getFerrari();
    Porshe getPorshe();
}
class UaLadaImpl implements Lada { // First
    public long getLadaPrice() {
        return 1000;
    }
}
class UaFerrariImpl implements Ferrari {
    public long getFerrariPrice() {
        return 3000;
    }
}
class UaPorsheImpl implements Porshe {
    public long getPorshePrice() {
        return 2000;
    }
}
class UaCarPriceAbsFactory implements InteAbsFactory {
    public Lada getLada() {
        return new UaLadaImpl();
    }
    public Ferrari getFerrari() {
        return new UaFerrariImpl();
    }
    public Porshe getPorshe() {
        return new UaPorsheImpl();
    }
} // First
class RuLadaImpl implements Lada { // Second
    public long getLadaPrice() {
        return 10000;
    }
}
class RuFerrariImpl implements Ferrari {
    public long getFerrariPrice() {
        return 30000;
    }
}
class RuPorsheImpl implements Porshe {
    public long getPorshePrice() {
        return 20000;
    }
}
class RuCarPriceAbsFactory implements InteAbsFactory {
    public Lada getLada() {
        return new RuLadaImpl();
    }
    public Ferrari getFerrari() {
        return new RuFerrariImpl();
    }
    public Porshe getPorshe() {
        return new RuPorsheImpl();
    }
} // Second

public class AbstractFactoryTest { // Test
    public static void main(String[] args) {
        String country = "UA";
        InteAbsFactory ifactory = null;
        if(country.equals("UA")) {
            ifactory = new UaCarPriceAbsFactory();
        } else if(country.equals("RU")) {
            ifactory = new RuCarPriceAbsFactory();
        }

        Lada lada = ifactory.getLada();
        System.out.println(lada.getLadaPrice());
    }
}

கட்டுபவர்

விளக்கம்: எளிய பொருட்களைப் பயன்படுத்தி சிக்கலான பொருளை உருவாக்கப் பயன்படுகிறது. இது ஒரு சிறிய, எளிய பொருளிலிருந்து படிப்படியாக ஒரு பெரிய பொருளை உருவாக்குகிறது. இறுதி தயாரிப்பின் உள் பிரதிநிதித்துவத்தை மாற்ற உங்களை அனுமதிக்கிறது. செயல்படுத்தல்:

class Car {
    public void buildBase() {
        print("Building the base");
    }
    public void buildWheels() {
        print("Installing wheels");
    }
    public void buildEngine(Engine engine) {
        print("Installing engine: " + engine.getEngineType());
    }
    private void print(String msg){
        System.out.println(msg);
    }
}
interface Engine {
    String getEngineType();
}
class EngineOne implements Engine {
    public String getEngineType() {
        return "First engine";
    }
}
class EngineTwo implements Engine {
    public String getEngineType() {
        return "Second engine";
    }
}
abstract class Builder {
    protected Car car;
    public abstract Car buildCar();
}
class OneBuilderImpl extends Builder {
    public OneBuilderImpl(){
        car = new Car();
    }
    public Car buildCar() {
        car.buildBase();
        car.buildWheels();
        Engine engine = new EngineOne();
        car.buildEngine(engine);
        return car;
    }
}
class TwoBuilderImpl extends Builder {
    public TwoBuilderImpl(){
        car = new Car();
    }
    public Car buildCar() {
        car.buildBase();
        car.buildWheels();
        Engine engine = new EngineOne();
        car.buildEngine(engine);
        car.buildWheels();
        engine = new EngineTwo();
        car.buildEngine(engine);
        return car;
    }
}
class Build {
    private Builder builder;
    public Build(int i){
        if(i == 1) {
            builder = new OneBuilderImpl();
        } else if(i == 2) {
            builder = new TwoBuilderImpl();
        }
    }
    public Car buildCar(){
        return builder.buildCar();
    }
}

public class BuilderTest { // Test
    public static void main(String[] args) {
        Build build = new Build(1);
        build.buildCar();
    }
}

முன்மாதிரி

விளக்கம்: நகல் பொருட்களை உருவாக்கும் போது செயல்திறனை மேம்படுத்த உதவுகிறது; ஒரு புதிய பொருளை உருவாக்குவதற்குப் பதிலாக, அது ஏற்கனவே உள்ள ஒரு பொருளின் குளோனை உருவாக்கித் திருப்பித் தருகிறது. இருக்கும் பொருளை குளோன் செய்கிறது. செயல்படுத்தல்:

interface Copyable {
    Copyable copy();
}
class ComplicatedObject implements Copyable {
    private Type type;
    public enum Type {
        ONE, TWO
    }
    public ComplicatedObject copy() {
        ComplicatedObject complicatedObject = new ComplicatedObject();
        return complicatedObject;
    }
    public void setType(Type type) {
        this.type = type;
    }
}

public class PrototypeTest { // Test
    public static void main(String[] args) {
        ComplicatedObject prototype = new ComplicatedObject();
        ComplicatedObject clone = prototype.copy();
        clone.setType(ComplicatedObject.Type.ONE);
    }
}

கட்டமைப்பு

அடாப்டர்

விளக்கம்: இரண்டு பொருந்தாத இடைமுகங்களை இணைக்க அடாப்டர் வடிவத்தைப் பயன்படுத்தலாம். இது இரண்டு பொருந்தாத பொருள்களுக்கு இடையே மாற்றியாக செயல்படுகிறது. செயல்படுத்தல்:

class PBank {
	private int balance;
	public PBank() { balance = 100; }
	public void getBalance() {
		System.out.println("PBank balance = " + balance);
	}
}
class ABank {
	private int balance;
	public ABank() { balance = 200; }
	public void getBalance() {
		System.out.println("ABank balance = " + balance);
	}
}
class PBankAdapter extends PBank {
	private ABank abank;
	public PBankAdapter(ABank abank) {
		this.abank = abank;
	}
	public void getBalance() {
		abank.getBalance();
	}
}

public class AdapterTest { // Test
	public static void main(String[] args) {
		PBank pbank = new PBank();
		pbank.getBalance();
		PBankAdapter abank = new PBankAdapter(new ABank());
		abank.getBalance();
	}
}

கூட்டு

விளக்கம்: ஒரு வகுப்பைப் பயன்படுத்தி பல பொருட்களை ஒரு மர அமைப்பில் குழுவாக்குகிறது. ஒரு பொருளின் மூலம் பல வகுப்புகளுடன் வேலை செய்ய உங்களை அனுமதிக்கிறது. செயல்படுத்தல்:

import java.util.ArrayList;
import java.util.List;
interface Car {
    void draw(String color);
}
class SportsCar implements Car {
    public void draw(String color) {
        System.out.println("SportsCar color: " + color);
    }
}
class UnknownCar implements Car {
    public void draw(String color) {
        System.out.println("UnknownCar color: " + color);
    }
}
class Drawing implements Car {
    private List<Car> cars = new ArrayList<Car>();
    public void draw(String color) {
        for(Car car : cars) {
            car.draw(color);
        }
    }
    public void add(Car s){
        this.cars.add(s);
    }
    public void clear(){
		System.out.println();
        this.cars.clear();
    }
}

public class CompositeTest { // Test
    public static void main(String[] args) {
        Car sportsCar = new