ஜாவாவில் வடிவமைப்பு வடிவங்கள் [பகுதி 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 SportsCar();
        Car unknownCar = new UnknownCar();
        Drawing drawing = new Drawing();
        drawing.add(sportsCar);
        drawing.add(unknownCar);
        drawing.draw("green");
        drawing.clear();
        drawing.add(sportsCar);
        drawing.add(unknownCar);
        drawing.draw("white");
    }
}

பதிலாள்

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

interface Image {
    void display();
}
class RealImage implements Image {
    private String file;
    public RealImage(String file){
        this.file = file;
        load(file);
    }
    private void load(String file){
        System.out.println("Loading " + file);
    }
    public void display() {
        System.out.println("Displaying " + file);
    }
}
class ProxyImage implements Image {
    private String file;
    private RealImage image;
    public ProxyImage(String file){
        this.file = file;
    }
    public void display() {
        if(image == null){
            image = new RealImage(file);
        }
        image.display();
    }
}

public class ProxyTest { // Test
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");
        image.display();
        image.display();
    }
}

ஃப்ளைவெயிட்

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

class Flyweight {
    private int row;
    public Flyweight(int row) {
        this.row = row;
        System.out.println("ctor: " + this.row);
    }
    void report(int col) {
        System.out.print(" " + row + col);
    }
}

class Factory {
    private Flyweight[] pool;
    public Factory(int maxRows) {
        pool = new Flyweight[maxRows];
    }
    public Flyweight getFlyweight(int row) {
        if (pool[row] == null) {
            pool[row] = new Flyweight(row);
        }
        return pool[row];
    }
}

public class FlyweightTest { // Test
    public static void main(String[] args) {
        int rows = 5;
        Factory theFactory = new Factory(rows);
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < rows; j++) {
                theFactory.getFlyweight(i).report(j);
            }
            System.out.println();
        }
    }
}

முகப்பு

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

interface Car {
    void start();
    void stop();
}
class Key implements Car {
    public void start() {
        System.out.println("Insert keys");
    }
    public void stop() {
        System.out.println("Remove keys");
    }
}
class Engine implements Car {
    public void start() {
        System.out.println("Start engine");
    }
    public void stop() {
        System.out.println ("Stop engine");
    }
}
class Facade {
    private Key key;
    private Engine engine;
    public Facade() {
        key = new Key();
        engine = new Engine();
    }
    public void startCar() {
        key.start();
        engine.start();
    }
    public void stoptCar() {
        key.stop();
        engine.stop();
    }
}

public class FacadeTest { // Test
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.startCar();
        System.out.println();
        facade.stoptCar();
    }
}

பாலம்

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

interface Engine {
    void setEngine();
}
abstract class Car {
    protected Engine engine;
    public Car(Engine engine){
        this.engine = engine;
    }
    abstract public void setEngine();
}
class SportsCar extends Car {
    public SportsCar(Engine engine) {
        super(engine);
    }
    public void setEngine() {
        System.out.print("SportsCar engine: ");
        engine.setEngine();
    }
}
class UnknownCar extends Car {
    public UnknownCar(Engine engine) {
        super(engine);
    }
    public void setEngine() {
        System.out.print("UnknownCar engine: ");
        engine.setEngine();
    }
}
class PerformanceEngine implements Engine {
    public void setEngine(){
        System.out.println("sport");
    }
}
class UnknownEngine implements Engine {
    public void setEngine(){
        System.out.println("unknown");
    }
}
public class BridgeTest { // Test
    public static void main(String[] args) {
        Car sportsCar = new SportsCar(new PerformanceEngine());
        sportsCar.setEngine();
        System.out.println();
        Car unknownCar = new UnknownCar(new UnknownEngine());
        unknownCar.setEngine();
    }
}

அலங்கரிப்பவர்

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

interface Car {
    void draw();
}
class SportsCar implements Car {
    public void draw() {
        System.out.println("SportsCar");
    }
}
class UnknownCar implements Car {
    public void draw() {
        System.out.println("UnknownCar");
    }
}
abstract class CarDecorator implements Car {
    protected Car decorated;
    public CarDecorator(Car decorated){
        this.decorated = decorated;
    }
    public void draw(){
        decorated.draw();
    }
}
class BlueCarDecorator extends CarDecorator {
    public BlueCarDecorator(Car decorated) {
        super(decorated);
    }
    public void draw() {
        decorated.draw();
        setColor();
    }
    private void setColor(){
        System.out.println("Color: red");
    }
}

public class DecoratorTest { // Test
    public static void main(String[] args) {
        Car sportsCar = new SportsCar();
        Car blueUnknownCar = new BlueCarDecorator(new UnknownCar());
        sportsCar.draw();
        System.out.println();
        blueUnknownCar.draw();
    }
}

நடத்தை

வார்ப்புரு முறை

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

abstract class Car {
    abstract void startEngine();
    abstract void stopEngine();

    public final void start(){
        startEngine();
        stopEngine();
    }
}
class CarOne extends Car {
    public void startEngine() {
        System.out.println("Start engine.");
    }
    public void stopEngine() {
        System.out.println("Stop engine.");
    }
}
class CarTwo extends Car {
    public void startEngine() {
        System.out.println("Start engine.");
    }
    public void stopEngine() {
        System.out.println("Stop engine.");
    }
}

public class TemplateTest { // Test
    public static void main(String[] args) {
        Car car1 = new CarOne();
        car1.start();
        System.out.println();
        Car car2 = new CarTwo();
        car2.start();
    }
}

மத்தியஸ்தர்

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

class Mediator {
    public static void sendMessage(User user, String msg){
        System.out.println(user.getName() + ": " + msg);
    }
}
class User {
    private String name;
    public User(String name){
        this.name  = name;
    }
    public String getName() {
        return name;
    }
    public void sendMessage(String msg){
        Mediator.sendMessage(this, msg);
    }
}

public class MediatorTest { // Test
    public static void main(String[] args) {
        User user1 = new User("user1");
        User user2 = new User("user2");
        user1.sendMessage("message1");
        user2.sendMessage("message2");
    }
}

பொறுப்பு சங்கிலி

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

interface Payment {
    void setNext(Payment payment);
    void pay();
}
class VisaPayment implements Payment {
    private Payment payment;
    public void setNext(Payment payment) {
        this.payment = payment;
    }
    public void pay() {
        System.out.println("Visa Payment");
    }
}
class PayPalPayment implements Payment {
    private Payment payment;
    public void setNext(Payment payment) {
        this.payment = payment;
    }
    public void pay() {
        System.out.println("PayPal Payment");
    }
}

public class ChainofResponsibilityTest { // Test
    public static void main(String[] args) {
        Payment visaPayment = new VisaPayment();
        Payment payPalPayment = new PayPalPayment();
        visaPayment.setNext(payPalPayment);
        visaPayment.pay();
    }
}

பார்வையாளர்

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

import java.util.ArrayList;
import java.util.List;
interface Observer {
    void event(List<String> strings);
}
class University {
    private List<Observer> observers = new ArrayList<Observer>();
    private List<String> students = new ArrayList<String>();
    public void addStudent(String name) {
        students.add(name);
        notifyObservers();
    }
    public void removeStudent(String name) {
        students.remove(name);
        notifyObservers();
    }
    public void addObserver(Observer observer){
        observers.add(observer);
    }
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers(){
        for (Observer observer : observers) {
            observer.event(students);
        }
    }
}
class Director implements Observer {
    public void event(List<String> strings) {
        System.out.println("The list of students has changed: " + strings);
    }
}

public class ObserverTest { // Test
    public static void main(String[] args) {
        University university = new University();
        Director director = new Director();
        university.addStudent("Oscar");
        university.addObserver(director);
        university.addStudent("Anna");
        university.removeStudent("Oscar");
    }
}

மூலோபாயம்

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

interface Strategy {
    void download(String file);
}
class WindowsDownloadStrategy implements Strategy {
    public void download(String file) {
        System.out.println("windows download: " + file);
    }
}
class LinuxDownloadStrategy implements Strategy {
    public void download(String file) {
        System.out.println("linux download: " + file);
    }
}
class Context {
    private Strategy strategy;
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    public void download(String file){
        strategy.download(file);
    }
}

public class StrategyTest { // Test
    public static void main(String[] args) {
        Context context = new Context(new WindowsDownloadStrategy());
        context.download("file.txt");
        context = new Context(new LinuxDownloadStrategy());
        context.download("file.txt");
    }
}

கட்டளை

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

interface Command {
    void execute();
}
class Car {
    public void startEngine() {
        System.out.println("Start engine");
    }
    public void stopEngine() {
        System.out.println ("Stop engine");
    }
}
class StartCar implements Command {
    Car car;
    public StartCar(Car car) {
        this.car = car;
    }
    public void execute() {
        car.startEngine();
    }
}
class StopCar implements Command {
    Car car;
    public StopCar(Car car) {
        this.car = car;
    }
    public void execute() {
        car.stopEngine();
    }
}
class CarInvoker {
    public Command command;
    public CarInvoker(Command command){
        this.command = command;
    }
    public void execute(){
        this.command.execute();
    }
}

public class CommandTest { // Test
    public static void main(String[] args) {
        Car car = new Car();
        StartCar startCar = new StartCar(car);
        StopCar stopCar = new StopCar(car);
        CarInvoker carInvoker = new CarInvoker(startCar);
        carInvoker.execute();
    }
}

நிலை

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

interface State {
    void doAction();
}
class StartPlay implements State {
    public void doAction() {
        System.out.println("start play");
    }
}
class StopPlay implements State {
    public void doAction() {
        System.out.println("stop play");
    }
}
class PlayContext implements State {
    private State state;
    public void setState(State state){
        this.state = state;
    }
    public void doAction() {
        this.state.doAction();
    }
}

public class StateTest { // Test
    public static void main(String[] args) {
        PlayContext playContext = new PlayContext();
        State startPlay = new StartPlay();
        State stopPlay = new StopPlay();
        playContext.setState(startPlay);
        playContext.doAction();
        playContext.setState(stopPlay);
        playContext.doAction();
    }
}

பார்வையாளர்

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

interface Visitor {
    void visit(SportsCar sportsCar);
    void visit(Engine engine);
    void visit(Wheel wheel);
}
interface Car {
    void accept(Visitor visitor);
}
class Engine implements Car {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
class Wheel implements Car {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
class SportsCar implements Car {
    Car[] cars;
    public SportsCar(){
        cars = new Car[]{new Engine(), new Wheel()};
    }
    public void accept(Visitor visitor) {
        for (int i = 0; i < cars.length; i++) {
            cars[i].accept(visitor);
        }
        visitor.visit(this);
    }
}
class CarVisitor implements Visitor {
    public void visit(SportsCar computer) {
        print("car");
    }
    public void visit(Engine engine) {
        print("engine");
    }
    public void visit(Wheel wheel) {
        print("wheel");
    }
    private void print(String string) {
        System.out.println(string);
    }
}

public class VisitorTest { // Test
    public static void main(String[] args) {
        Car computer = new SportsCar();
        computer.accept(new CarVisitor());
    }
}

மொழிபெயர்ப்பாளர்

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

interface Expression {
    String interpret(Context context);
}
class Context {
     public String getLowerCase(String s){
        return s.toLowerCase();
    }
    public String getUpperCase(String s){
        return s.toUpperCase();
    }
}
 class LowerExpression implements Expression {
    private String s;
     public LowerExpression(String s) {
        this.s = s;
    }
    public String interpret(Context context) {
        return context.getLowerCase(s);
    }
}
class UpperExpression implements Expression {
    private String s;
    public UpperExpression(String s) {
        this.s = s;
    }
    public String interpret(Context context) {
        return context.getUpperCase(s);
    }
}

public class InterpreterTest { // Test
    public static void main(String[] args) {
        String str = "TesT";
        Context context = new Context();
         Expression lowerExpression = new LowerExpression(str);
         str = lowerExpression.interpret(context);
        System.out.println(str);
        Expression upperExpression = new UpperExpression(str);
        str = upperExpression.interpret(context);
        System.out.println(str);
    }
}

மறு செய்கை

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

interface Iterator {
    boolean hasNext();
    Object next();
}
class Numbers {
    public int num[] = {1 , 2, 3};
    public Iterator getIterator() {
        return new NumbersIterator();
    }
    private class NumbersIterator implements Iterator {
        int ind;
        public boolean hasNext() {
            if(ind < num.length) return true;
            return false;
        }
        public Object next() {
            if(this.hasNext()) return num[ind++];
            return null;
        }
    }
}

public class IteratorTest { // Test
    public static void main(String[] args) {
        Numbers numbers = new Numbers();
        Iterator iterator = numbers.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

நினைவுச்சின்னம்

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

import java.util.ArrayList;
import java.util.List;
class Memento {
    private String name;
    private int age;
    public Memento(String name, int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}
class User {
    private String name;
    private int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println(String.format("create: name = %s, age = %s", name, age));
    }
    public Memento save(){
        System.out.println(String.format("save: name = %s, age = %s", name, age));
        return new Memento(name, age);
    }
    public void restore(Memento memento){
        name = memento.getName();
        age = memento.getAge();
        System.out.println(String.format("restore: name = %s, age = %s", name, age));
    }
}
class SaveUser {
    private List<Memento> list = new ArrayList<Memento>();
    public void add(Memento memento){
        list.add(memento);
    }
    public Memento get(int ind){
        return list.get(ind);
    }
}

public class MementoTest { // Test
    public static void main(String[] args) {
        SaveUser saveUser = new SaveUser();
        User user1 = new User("Peter", 17);
        User user2 = new User("Ian", 19);
        saveUser.add(user1.save());
        user1.restore(saveUser.get(0));
    }
}

நல்ல அதிர்ஷ்டம் நிரலாக்கம்!