டெம்ப்ளேட் முறை வடிவமைப்பு முறை என்ன?

உங்களைப் போன்ற வாசகர்கள் MUO ஐ ஆதரிக்க உதவுகிறார்கள். எங்கள் தளத்தில் உள்ள இணைப்புகளைப் பயன்படுத்தி நீங்கள் வாங்கும் போது, ​​நாங்கள் ஒரு இணை கமிஷனைப் பெறலாம்.

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

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

---

---

அன்றைய வீடியோவை உருவாக்கவும்

ஒரு துணைப்பிரிவு ஒரு சுருக்க முறையை செயல்படுத்த முடியும், ஆனால் அது ஒரு இறுதி முறை மூலம் செயல்படுத்தப்படும் வழிமுறையை மறுவரையறை செய்ய முடியாது.

உள்ளூர் தொலைக்காட்சியை ரோகுவில் பார்ப்பது எப்படி

டெம்ப்ளேட் முறை எவ்வாறு செயல்படுகிறது

ஒரு பொதுவான டெம்ப்ளேட் முறை முறை பின்வரும் அமைப்பைக் கொண்டிருக்கும்:

final void templateMethod() { 
    abstractOperation1(); 
    abstractOperation2(); 
  
    concreteOperation1(); 
    concreteOperation2(); 
  
    hook(); 
}

கவனிக்க வேண்டிய முதல் முக்கியமான விஷயம் என்னவென்றால், templateMethod() இறுதியானது, எனவே எந்த துணைப்பிரிவும் இந்த முறையை மீற முடியாது. கவனிக்க வேண்டிய மற்ற முக்கியமான விஷயம், டெம்ப்ளேட் முறை முறை பயன்படுத்தும் மூன்று வகையான முறைகள்: கான்கிரீட், சுருக்கம் மற்றும் கொக்கி.

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

ஜாவாவில் டெம்ப்ளேட் முறை வடிவத்தை செயல்படுத்துதல்

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

---

---

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

public abstract class Database { 
    // template method 
    final void databaseTemplate() { 
        // abstract methods 
        setDBDriver(); 
        setCredentials(); 
  
        // concrete method 
        connect(); 
  
        // abstract methods 
        createDB(); 
        setData(); 
        readData(); 
  
        // hook methods 
        if (userWantsToUpdate()) { 
            updateData(); 
        } 
  
        if (userWantsToDelete()) { 
            deleteData(); 
        } 
  
        // concrete method 
        closeConnection(); 
    } 
  
    abstract void setDBDriver(); 
    abstract void setCredentials(); 
    abstract void createDB(); 
    abstract void setData(); 
    abstract void readData(); 
    abstract void updateData(); 
    abstract void deleteData(); 
  
    void connect() { 
        System.out.println("Connecting to database..."); 
    } 
  
    void closeConnection() { 
        System.out.println("Destroying database connection..."); 
    } 
  
    boolean userWantsToUpdate() { 
        return false; 
    } 
  
    boolean userWantsToDelete() { 
        return false; 
    } 
} 

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

---

---

டெம்ப்ளேட் முறையில் உள்ள மற்ற முறைகள் தரவுத்தளத்தின் வகையைப் பொறுத்து மாறுபடும். எடுத்துக்காட்டாக, MySQL தரவுத்தளம் அட்டவணையில் தரவைச் சேமிக்கிறது, அதே சமயம் a MongoDB தரவுத்தளம் சேகரிப்புகளில் தரவைச் சேமிக்கிறது . நீங்கள் பயன்படுத்த விரும்பினால் a ஜாவாவில் MySQL தரவுத்தளம் , தரவுத்தள வகுப்பை நீட்டிக்கும் புதிய MySQL வகுப்பை உருவாக்கவும்:

public class MySQL extends Database { 
    @Override 
    void setDBDriver() { 
        System.out.println("Selecting MySQL driver..."); 
    } 
  
    @Override 
    void setCredentials() { 
        System.out.println("Setting MySQL database Credential..."); 
    } 
  
    @Override 
    void createDB() { 
        System.out.println("Creating a new table..."); 
    } 
  
    @Override 
    void setData() { 
        System.out.println("Inserting data into database..."); 
    } 
  
    @Override 
    void readData() { 
        System.out.println("Retrieving data from database..."); 
    } 
  
    @Override 
    void updateData() { 
        System.out.println("Updating data in database..."); 
    } 
  
    @Override 
    void deleteData() { 
        System.out.println("Deleting data from database..."); 
    } 
} 

MySQL வகுப்பு தரவுத்தள வகுப்பின் அனைத்து சுருக்க முறைகளையும் செயல்படுத்துகிறது. இது சில உறுதியான முறைகளையும் மீறலாம். இருப்பினும், அதைத் தொட முடியாது தரவுத்தள வார்ப்புரு() முறை, இது இறுதி முக்கிய சொல்லைப் பயன்படுத்துகிறது.

public class Main { 
    public static void main(String[] args) { 
        Database mySQLDB = new MySQL(); 
        mySQLDB.databaseTemplate(); 
    } 
} 

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

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

@Override 
boolean userWantsToUpdate() { 
    return true; 
}

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

நீங்கள் பார்க்க முடியும் என, பயன்பாடு இப்போது தரவுத்தளத்தில் தரவைப் புதுப்பிக்கிறது.

டெம்ப்ளேட் முறை வடிவமைப்பு வடிவத்தைப் பயன்படுத்துவதன் நன்மைகள்

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

கூடுதலாக, டெம்ப்ளேட் முறை முறையைப் பயன்படுத்தும் பயன்பாடு மிகவும் பாதுகாப்பானது, ஏனெனில் வெளிப்புற வகுப்புகள் அதன் செயல்பாட்டு கட்டமைப்பை மாற்ற முடியாது.