பாலிமார்பிசம் மற்றும் சுருக்க வகுப்புகள்

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

பாலிமார்பிசம்

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

class Animal {
    public void makeSound() {
        System.out.println("Verso...");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Miao");
    }
}

பாலிமார்பிஸத்திற்கு நன்றி, நாம் இதைச் செய்யலாம்:

Animal myAnimal1 = new Dog(); // Polymorphism
Animal myAnimal2 = new Cat(); // Polymorphism

myAnimal1.makeSound(); // Executes Dog's method (Woof)
myAnimal2.makeSound(); // Executes Cat's method (Miao)

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

சுருக்க வகுப்புகள் (abstract)

சுருக்க வகுப்பு என்பது abstract திறவுச்சொல்லால் குறிக்கப்பட்ட வகுப்பாகும், அதை நேரடியாகத் தொடங்க முடியாது (நீங்கள் new MyAbstractClass() செய்ய முடியாது). இது மற்ற வகுப்புகளுக்கு "பகுதி டெம்ப்ளேட்டாக" செயல்படுகிறது.

சுருக்க முறைகள்

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

abstract class Shape {
    String color;

    // Abstract method (no body)
    public abstract double getArea();
}

class Circle extends Shape {
    double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    // Required to implement getArea
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

டைனமிக் பைண்டிங் / லேட் பைண்டிங்

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

சுருக்க வகுப்புகள் மற்றும் விடுபட்ட செயல்படுத்தல்

ஒரு துணைப்பிரிவு ஒரு சுருக்க வகுப்பிலிருந்து பெறப்பட்டால், அதற்கு இரண்டு விருப்பங்கள் உள்ளன:

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

abstract class Animal {
    public abstract void makeSound();
}

// This class MUST be abstract because it does not implement makeSound()
abstract class Canine extends Animal {
    // Inherits makeSound() but does not implement it
}

நீங்களே முயற்சி செய்து பாருங்கள்