ஜாவாவில் சுருக்க வகுப்புகளின் உறுதியான எடுத்துக்காட்டுகள்

வணக்கம்! ஜாவாவில் சுருக்க வகுப்புகளைப் பற்றி பேசலாம் .

வகுப்புகள் ஏன் "சுருக்கம்" என்று அழைக்கப்படுகின்றன?

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

ஜாவாவில் உள்ள சுருக்க வகுப்புகளின் எடுத்துக்காட்டுகள்

கார்களுடன் ஒரு எளிய உதாரணத்தைக் கவனியுங்கள்:

public abstract class Car {

   private String model;
   private String color;
   private int maxSpeed;
  
   public abstract void gas();

   public abstract void brake();

   public String getModel() {
       return model;
   }

   public void setModel(String model) {
       this.model = model;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getMaxSpeed() {
       return maxSpeed;
   }

   public void setMaxSpeed(int maxSpeed) {
       this.maxSpeed = maxSpeed;
   }
}

எளிமையான சுருக்க வகுப்பு இது போல் தெரிகிறது. நீங்கள் பார்க்க முடியும் என, சிறப்பு எதுவும் இல்லை :) நமக்கு இது ஏன் தேவைப்படலாம்? முதலில், இது நமக்குத் தேவையான நிறுவனத்தின் மிக சுருக்கமான விளக்கத்தை வழங்குகிறது - ஒரு கார். சுருக்கத் திறவுச்சொல் இங்கே ஏதோவொன்றைக் குறிக்கிறது . நிஜ உலகில், "வெறும் ஒரு கார்" என்று எதுவும் இல்லை. டிரக்குகள், ரேஸ் கார்கள், செடான்கள், கூபேக்கள் மற்றும் எஸ்யூவிகள் உள்ளன. எங்கள் சுருக்க வகுப்பு என்பது ஒரு "புளூபிரிண்ட்" ஆகும், பின்னர் குறிப்பிட்ட கார் வகுப்புகளை உருவாக்கப் பயன்படுத்துவோம்.

public class Sedan extends Car {
  
   @Override
   public void gas() {
       System.out.println("The sedan is accelerating!");
   }

   @Override
   public void brake() {
       System.out.println("The sedan is slowing down!");
   }
  
}

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

public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // Error! The Car class is abstract!
   }
}

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

public class Car {

   private String model;
   private String color;
   private int maxSpeed;
  
   public void go() {
       // ...some logic
   }

   public  void brake() {
       // ...some logic
   }
}


public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // This is okay. The car is created.
   }
}

தற்போது, ​​எங்கள் திட்டத்தில் ஒருவித புரிந்துகொள்ள முடியாத கார் உள்ளது. இது டிரக் அல்ல, ரேஸ் கார் அல்ல, செடான் அல்ல, ஆனால் அது என்ன என்பது தெளிவாகத் தெரியவில்லை. இது உண்மையில் இல்லாத "வெறும் ஒரு கார்". இதே உதாரணத்தை விலங்குகளுக்கும் கொடுக்கலாம். Animalஉங்கள் நிரலில் பொருள்கள் (" விலங்குகள் ") இருந்தால் கற்பனை செய்து பாருங்கள் . அது எந்த வகையானது, எந்தக் குடும்பத்தைச் சேர்ந்தது, என்ன குணாதிசயங்களைக் கொண்டுள்ளது என்பது தெளிவாகத் தெரியவில்லை. ஒரு நிரலில் ஒன்றைப் பார்ப்பது விசித்திரமாக இருக்கும். இயற்கையில் "வெறும் விலங்குகள்" இல்லை. நாய்கள், பூனைகள், நரிகள், உளவாளிகள் போன்றவை மட்டுமே. சுருக்க வகுப்புகள் " வெறும் பொருள்களில் " இருந்து நம்மைக் காப்பாற்றுகின்றன. அவை நமக்கு அடிப்படை நிலையையும் நடத்தையையும் தருகின்றன. எடுத்துக்காட்டாக, அனைத்து கார்களும் ஒரு மாதிரி , நிறம் மற்றும் அதிவேகத்தைக் கொண்டிருக்க வேண்டும், மேலும் அவர்கள் எரிவாயு மற்றும் பிரேக்கைப் பயன்படுத்தக்கூடியவர்களாக இருக்க வேண்டும் . அவ்வளவுதான். இது ஒரு பொதுவான சுருக்க வரைபடமாகும், பின்னர் உங்களுக்குத் தேவையான வகுப்புகளை வடிவமைக்கப் பயன்படுத்துவீர்கள். குறிப்பு: சுருக்க வகுப்பில் உள்ள இரண்டு முறைகளும் சுருக்கமானவை , அதாவது அவை செயல்படுத்தப்படவே இல்லை. காரணம் ஒன்றுதான்: சுருக்க வகுப்புகள் "வெறும் கார்களுக்கு" "இயல்புநிலை நடத்தைகளை" உருவாக்காது. ஒவ்வொரு காரும் என்ன செய்ய வேண்டும் என்பதை அவை சுட்டிக்காட்டுகின்றன. உங்களுக்கு இயல்புநிலை நடத்தை தேவைப்பட்டால், நீங்கள் ஒரு சுருக்க வகுப்பில் முறைகளை செயல்படுத்தலாம். ஜாவா இதை தடை செய்யவில்லை:

public abstract class Car {

   private String model;
   private String color;
   private int maxSpeed;

   public void gas() {
       System.out.println("Accelerating!");
   }

   public abstract void brake();
  
   // Getters and setters
}


public class Sedan extends Car {

   @Override
   public void brake() {
       System.out.println("The sedan is slowing down!");
   }

}

public class Main {

   public static void main(String[] args) {

       Sedan sedan = new Sedan();
       sedan.gas();
   }
}

கன்சோல் வெளியீடு:

Accelerating!

நீங்கள் பார்க்க முடியும் என, சுருக்க வகுப்பில் ஒரு முறையை நாங்கள் செயல்படுத்தினோம், ஆனால் மற்றொன்று அல்ல. இதன் விளைவாக, எங்கள் Sedanவகுப்பின் நடத்தை இரண்டு பகுதிகளாகப் பிரிக்கப்பட்டுள்ளது: அதன் முறையை நாம் அழைத்தால் gas(), நடத்தை சுருக்கமான பெற்றோர் வகுப்பிலிருந்து "மேலே இழுக்கப்படுகிறது" , மேலும் வகுப்பில் முறையைச் Carசெயல்படுத்துகிறோம் . இது மிகவும் வசதியானது மற்றும் நெகிழ்வானது. ஆனால் எங்கள் வகுப்பு இப்போது சுருக்கமாக இல்லை, இல்லையா ? எல்லாவற்றிற்கும் மேலாக, இது உண்மையில் பாதி முறைகளை செயல்படுத்தியது. உண்மை என்னவென்றால் - இது ஒரு மிக முக்கியமான அம்சமாகும் - ஒரு வகுப்பு அதன் முறைகளில் ஒன்று கூட சுருக்கமாக இருந்தால் அது சுருக்கமாகும்.brake()Sedan. இரண்டு முறை, அல்லது ஆயிரத்தில் ஒன்று - அது ஒரு பொருட்டல்ல. நாம் அனைத்து முறைகளையும் செயல்படுத்த முடியும், எதையும் சுருக்கமாக விட்டுவிடவில்லை. இதன் விளைவாக எந்த சுருக்க முறைகளும் இல்லாமல் ஒரு சுருக்க வகுப்பாக இருக்கும். இது கொள்கையளவில் சாத்தியமாகும் - கம்பைலர் எந்த பிழையையும் உருவாக்காது - ஆனால் இதைச் செய்யாமல் இருப்பது நல்லது, ஏனெனில் இது சுருக்கம் என்ற வார்த்தையின் அர்த்தத்தை இழக்கிறது. உங்கள் சக புரோகிராமர்களும் இதைப் பார்த்து மிகவும் ஆச்சரியப்படுவார்கள்:/ அதாவது, ஒரு முறை சுருக்கமாகக் குறிக்கப்பட்டால், ஒவ்வொரு சந்ததியினரும் அதைச் செயல்படுத்த வேண்டும் அல்லது சுருக்கமாக அறிவிக்க வேண்டும். இல்லையெனில், கம்பைலர் பிழையை ஏற்படுத்தும். நிச்சயமாக, ஒவ்வொரு வகுப்பும் ஒரு சுருக்க வகுப்பை மட்டுமே பெற முடியும், எனவே பரம்பரை அடிப்படையில் சுருக்க மற்றும் வழக்கமான வகுப்புகளுக்கு இடையே எந்த வித்தியாசமும் இல்லை. நாம் ஒரு சுருக்க வகுப்பை அல்லது வழக்கமான ஒன்றைப் பெற்றாலும் பரவாயில்லை — ஒரே ஒரு பெற்றோர் வகுப்பு மட்டுமே இருக்க முடியும்.

ஜாவாவிற்கு ஏன் பல வகுப்பு மரபுகள் இல்லை

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

public class Toaster {
  
  
 public void on() {

       System.out.println("The toaster is on. We're toasting!");
   }
  
   public void off() {

       System.out.println("The toaster is off!");
   }
}


public class NuclearBomb {

   public void on() {

       System.out.println("Boom!");
   }
}

நீங்கள் பார்க்க முடியும் என, இரண்டு வகுப்புகளுக்கும் ஒரு on()முறை உள்ளது. டோஸ்டரைப் பொறுத்தவரை, முறை டோஸ்ட் தயாரிக்கத் தொடங்குகிறது, ஆனால் அணுகுண்டு விஷயத்தில், அது வெடிப்பைத் தூண்டுகிறது. அடடா :/ இப்போது நீங்கள் இடையில் ஏதாவது ஒன்றை உருவாக்க முடிவு செய்துள்ளீர்கள் என்று கற்பனை செய்து பாருங்கள் (ஏன் என்று என்னிடம் கேட்காதீர்கள்!). இதோ உங்கள் வகுப்பு: MysteriousDevice! இந்த குறியீடு வேலை செய்யாது, நிச்சயமாக. "என்னவாக இருந்திருக்கலாம்" என்பதற்கான உதாரணமாக நாங்கள் அதை வழங்குகிறோம்:

public class MysteriousDevice extends Toster, NuclearBomb {

   public static void main(String[] args) {
      
       MysteriousDevice mysteriousDevice = new MysteriousDevice();
       mysteriousDevice.on(); // And what should happen here? Will we get toast or a nuclear apocalypse?
   }
}

நம்மிடம் என்ன இருக்கிறது என்று பார்ப்போம். மர்மமான சாதனம் ஒரே நேரத்தில் Toaster மற்றும் NuclearBomb இரண்டிலிருந்தும் பெறப்படுகிறது. இரண்டிற்கும் ஒரு on()முறை உண்டு. on()இதன் விளைவாக, ஒரு பொருளை நாம் அழைத்தால் எந்தச் செயலாக்கம் செயல்படுத்தப்பட வேண்டும் என்பது தெளிவாகத் தெரியவில்லை MysteriousDevice. பொருள் புரியாது. மேலும், எல்லாவற்றிற்கும் மேலாக, நியூக்ளியர் பாம்பில் ஒரு முறை இல்லை off(), எனவே நாம் சரியாக யூகிக்கவில்லை என்றால், சாதனத்தை அணைக்க இயலாது. இந்த "தவறான புரிதல்", எந்த நடத்தை செயல்படுத்தப்பட வேண்டும் என்பது தெளிவாக இல்லாதபோது, ​​ஜாவாவின் படைப்பாளிகள் பல மரபுகளை நிராகரித்ததற்கு துல்லியமாக காரணம். ஜாவா வகுப்புகள் பல இடைமுகங்களை செயல்படுத்த முடியும் என்பதை நீங்கள் அறிந்து கொள்வீர்கள்.