வடிவமைப்பு வடிவங்கள். அலங்கரிப்பவர்

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

உண்மையில், இந்த வடிவங்கள் நிறைய உள்ளன, மேலும் அவை அவற்றின் குறிப்பிட்ட நோக்கத்தின்படி வகைப்படுத்தப்படலாம்.

வடிவ வகைப்பாடு

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

Java.io இல், பின்வரும் வகுப்புகள் வடிவங்களைச் செயல்படுத்துகின்றன:

அலங்கார முறை

வீட்டு வடிவமைப்பிற்கான மாதிரியை நாங்கள் விவரிக்கிறோம் என்று கற்பனை செய்து கொள்வோம்.

பொதுவாக, அணுகுமுறை இதுபோல் தெரிகிறது:

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

நாங்கள் ஒரு சுருக்கமான ஹவுஸ் வகுப்பை உருவாக்குகிறோம்:

public abstract class House {
	String info;
 
	public String getInfo() {
    	return info;
	}
 
	public abstract int getPrice();
}
    

இங்கே நமக்கு 2 முறைகள் உள்ளன:

• getInfo() எங்கள் வீட்டின் பெயர் மற்றும் அம்சங்களைப் பற்றிய தகவலை வழங்குகிறது;
• getPrice() தற்போதைய வீட்டின் உள்ளமைவின் விலையை வழங்குகிறது.

எங்களிடம் நிலையான வீட்டு செயலாக்கங்களும் உள்ளன - செங்கல் மற்றும் மர:

public class BrickHouse extends House {
 
	public BrickHouse() {
    	info = "Brick House";
	}
 
	@Override
	public int getPrice() {
    	return 20_000;
	}
}
 
public class WoodenHouse extends House {
 
	public WoodenHouse() {
    	info = "Wooden House";
	}
 
	@Override
	public int getPrice() {
    	return 25_000;
	}
}
    

இரண்டு வகுப்புகளும் ஹவுஸ் வகுப்பைப் பெறுகின்றன மற்றும் அதன் விலை முறையை மீறுகின்றன, நிலையான வீட்டிற்கான தனிப்பயன் விலையை அமைக்கின்றன. கட்டமைப்பாளரில் பெயரை அமைத்துள்ளோம்.

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

அங்குதான் ஒரு பொருளை மாற்றுவதற்கான கூடுதல் தர்க்கத்தை வைப்போம். ஆரம்பத்தில், கூடுதல் தர்க்கம் இருக்காது மற்றும் சுருக்க வகுப்பு காலியாக இருக்கும்.

abstract class HouseDecorator extends House {
}
    

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

public class SecondFloor extends HouseDecorator {
	House house;
 
	public SecondFloor(House house) {
    	this.house = house;
	}
 
	@Override
	public int getPrice() {
    	return house.getPrice() + 20_000;
	}
 
	@Override
	public String getInfo() {
    	return house.getInfo() + " + second floor";
	}
}
    

நாங்கள் "அலங்கரிப்போம்" அதாவது மாற்றங்களைச் சேர்ப்போம். மேலும் நாங்கள் getPrice() மற்றும் getInfo() முறைகளை மேலெழுதுகிறோம்.

public class Garage extends HouseDecorator {
 
	House house;
	public Garage(House house) {
    	this.house = house;
	}
 
	@Override
	public int getPrice() {
    	return house.getPrice() + 5_000;
	}
 
	@Override
	public String getInfo() {
    	return house.getInfo() + " + garage";
	}
}
    

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

House brickHouse = new BrickHouse();
    

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

brickHouse = new SecondFloor(brickHouse); 
    

நமதுவீடுமாறி இப்போது இரண்டாவது மாடியுடன் கூடிய வீடு.

அலங்கரிப்பாளர்கள் சம்பந்தப்பட்ட பயன்பாட்டு நிகழ்வுகளைப் பார்ப்போம்:

House brickHouse = new BrickHouse(); 

  System.out.println(brickHouse.getInfo());
  System.out.println(brickHouse.getPrice());
                    

House brickHouse = new BrickHouse(); 

  brickHouse = new SecondFloor(brickHouse); 

  System.out.println(brickHouse.getInfo());
  System.out.println(brickHouse.getPrice());
                    

House brickHouse = new BrickHouse();
 

  brickHouse = new SecondFloor(brickHouse);
  brickHouse = new Garage(brickHouse);

  System.out.println(brickHouse.getInfo());
  System.out.println(brickHouse.getPrice());
                    

House woodenHouse = new SecondFloor(new Garage(new WoodenHouse())); 

  System.out.println(woodenHouse.getInfo());
  System.out.println(woodenHouse.getPrice());
                    

House woodenHouse = new WoodenHouse(); 

  House woodenHouseWithGarage = new Garage(woodenHouse);

  System.out.println(woodenHouse.getInfo());
  System.out.println(woodenHouse.getPrice());

  System.out.println(woodenHouseWithGarage.getInfo());
  System.out.println(woodenHouseWithGarage.getPrice());
                    

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

எங்கள் திட்டத்தின் இந்த UML வரைபடத்தைப் பாருங்கள்:

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

எடுத்துக்காட்டாக, நாம் ஏற்கனவே குறிப்பிட்டுள்ளபடி, java.io.InputStream , OutputStream , Reader மற்றும் Writer இன் அனைத்து துணைப்பிரிவுகளும் ஒரே வகுப்புகளின் பொருட்களை ஏற்றுக்கொள்ளும் ஒரு கட்டமைப்பாளரைக் கொண்டுள்ளன.