జావాలో డిజైన్ నమూనాలు [పార్ట్ 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));
    }
}

ప్రోగ్రామింగ్ అదృష్టం!