எல்லோருக்கும் வணக்கம். எனது முந்தைய கட்டுரையில் , ஒவ்வொரு வடிவத்தையும் சுருக்கமாக விவரித்தேன். இந்த கட்டுரையில், வடிவங்களை எவ்வாறு பயன்படுத்துவது என்பதை விரிவாகக் காட்ட முயற்சிப்பேன்.
![ஜாவாவில் வடிவமைப்பு வடிவங்கள் [பகுதி 2] - 1](https://cdn.codegym.cc/images/article/e6459560-06f8-4128-98a5-229ac9dab308/512.jpeg)
படைப்பு
சிங்கிள்டன்
விளக்கம்: ஒரு வகுப்பின் உருவாக்கத்தை ஒரு நிகழ்விற்கு கட்டுப்படுத்துகிறது, மேலும் அந்த ஒற்றை நிகழ்விற்கான அணுகலை வழங்குகிறது. வகுப்பின் கட்டமைப்பாளர் தனிப்பட்டவர். இந்த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));
}
}
நல்ல அதிர்ஷ்டம் நிரலாக்கம்!
மேலும் வாசிப்பு: |
---|
GO TO FULL VERSION