ஜாவாவில் நிகழ்வு மற்றும் பரம்பரை

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

பரம்பரை

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

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

இயற்கையாகவே, இரண்டாவது விருப்பம் மிகவும் வசதியானது:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }
}

public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

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

public class Car {

   public void gas() {
       // Accelerate
   }

   public void brake() {
       // Brake
   }
}


public class F1Car extends Car {

   public void pitStop() {
      
       // Only race cars make pit stops
   }

   public static void main(String[] args) {
      
       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

அனைத்து கார்களுக்கும் பொதுவான முறைகளை வகுப்பில் சேர்த்துள்ளோம் Car. F1Carஆனால், "ஃபார்முலா 1" ரேஸ் கார்களைக் குறிக்கும் வகுப்பைப் பாருங்கள் . பிட் ஸ்டாப்புகள் (அவசர கார் பராமரிப்புக்கான நிறுத்தங்கள்) பந்தயங்களில் மட்டுமே செய்யப்படுகின்றன, எனவே இந்த குறிப்பிட்ட செயல்பாட்டை தொடர்புடைய பெறப்பட்ட வகுப்பில் சேர்த்துள்ளோம்.

இயக்குனரின் உதாரணம்

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

public class Truck extends Car {

   public static void main(String[] args) {

       Truck truck = new Truck();
       System.out.println(truck instanceof Car);
   }
}

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

public static void main(String[] args) {

   Car car = new Car();
   System.out.println(car instanceof Truck);
}

வெளியீடு: தவறான வர்க்கம் Car(மற்றும் கார் பொருள்கள்) வகுப்பிலிருந்து பெறப்படவில்லை Truck. அனைத்து டிரக்குகளும் கார்கள், ஆனால் அனைத்து கார்களும் டிரக்குகள் அல்ல. Carபொருள்கள் வர்க்கத்தின் அடிப்படையில் இல்லை Truck. மேலும் ஒரு உதாரணம்:

public static void main(String[] args) {

   Car car = new Car();
   Truck truck = new Truck();
   System.out.println(car instanceof Object && truck instanceof Object);
}

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

public boolean equals(Object anObject) {
   if (this == anObject) {
       return true;
   }
   if (anObject instanceof String) {
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                       return false;
               i++;
           }
           return true;
       }
   }
   return false;
}

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