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

வணக்கம்! கடந்த பாடங்களில், இடைமுகங்களைச் சந்தித்து அவை எதற்காக என்று கண்டுபிடித்தோம். இன்றைய தலைப்பு முந்தையதை எதிரொலிக்கும். ஜாவாவில் சுருக்க வகுப்புகளைப் பற்றி பேசலாம் .

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

'சுருக்கம்' என்றால் என்ன என்பது உங்களுக்கு நினைவிருக்கலாம் - நாங்கள் ஏற்கனவே அதைக் கடந்துவிட்டோம். :) மறந்தால் பயம் வேண்டாம். நினைவில் கொள்ளுங்கள்: இது 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!");
   }

}

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

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 gas() {
       // Some logic
   }

    public void brake() {
       // Some logic
   }
}


public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // Everything is fine. A car is created.
   }
}

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

public abstract class Car {

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

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

   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();
   }
}

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

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

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

public class Toaster {


 public void on() {

       System.out.println("The toaster is on. Toast is being prepared!");
   }

   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 Toaster, NuclearBomb {

   public static void main(String[] args) {

       MysteriousDevice mysteriousDevice = new MysteriousDevice();
       mysteriousDevice.on(); // So what should happen here? Do we get toast or a nuclear apocalypse?
   }
}

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

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>

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