எல்லோருக்கும் வணக்கம். எனது முந்தைய கட்டுரையில் , ஒவ்வொரு வடிவத்தையும் சுருக்கமாக விவரித்தேன். இந்த கட்டுரையில், வடிவங்களை எவ்வாறு பயன்படுத்துவது என்பதை விரிவாகக் காட்ட முயற்சிப்பேன்.
![ஜாவாவில் வடிவமைப்பு வடிவங்கள் [பகுதி 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