Java Academy · Pelajaran

Template Method: Mentakrifkan Rangka Algoritma

Takrifkan rangka algoritma dalam kelas asas dan biarkan subkelas melengkapkan langkah-langkahnya.

Pelajaran 4 daripada 414 langkah

Template Method: Mentakrifkan Rangka Algoritma ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Tujuan Kaedah Templat

Kaedah Templat mentakrifkan rangka algoritma dalam kelas asas dan menyerahkan beberapa langkah kepada subkelas. Subkelas boleh menggantikan langkah tanpa mengubah struktur keseluruhan.

Kelas Asas abstract

Kelas asas mempunyai kaedah templat, biasanya final, yang menyelaraskan langkah-langkah. Kaedah abstract mewakili langkah yang berbeza-beza. Kaedah konkret menyediakan tingkah laku lalai.

public abstract class DataProcessor {
    // Template method — final, defines the algorithm
    public final void process() {
        readData();
        processData();
        writeResult();
    }
    protected abstract void readData();
    protected abstract void processData();
    protected void writeResult() {
        System.out.println("Result written (default)");
    }
}

Subkelas Konkret

Setiap subkelas mengisi langkah abstract. Urutan kaedah templat tidak pernah berubah — hanya pelaksanaan langkah individu yang berbeza.

public class CSVProcessor extends DataProcessor {
    protected void readData()    { System.out.println("Reading CSV..."); }
    protected void processData() { System.out.println("Parsing CSV rows..."); }
}
public class XMLProcessor extends DataProcessor {
    protected void readData()    { System.out.println("Reading XML..."); }
    protected void processData() { System.out.println("Parsing XML nodes..."); }
    @Override
    protected void writeResult() { System.out.println("Writing XML result."); }
}

Kaedah Cangkuk

Cangkuk ialah langkah pilihan dengan pelaksanaan lalai, yang selalunya kosong. Subkelas boleh menggantikan cangkuk untuk menambah tingkah laku pilihan tanpa dipaksa melaksanakannya.

public abstract class Game {
    public final void play() {
        initialize();
        while (!isDone()) takeTurn();
        printWinner();
    }
    protected void initialize() {}  // hook — optional override
    protected abstract boolean isDone();
    protected abstract void takeTurn();
    protected abstract void printWinner();
}

Kaedah Templat berbanding Strategi

Kaedah Templat menggunakan pewarisan: rangka ditetapkan dalam kelas asas dan langkah digantikan dalam subkelas. Strategi menggunakan komposisi: keseluruhan algoritma berada di luar kelas. Strategi lebih fleksibel; Kaedah Templat lebih mudah apabila langkah-langkah berkongsi banyak konteks.

InputStream Java sebagai Kaedah Templat

read(byte[], int, int) dalam java.io.InputStream dilaksanakan berdasarkan read() abstract. Subkelas melaksanakan versi satu bait; bacaan berbilang bait ialah templatnya.

Kaedah Templat untuk Penjanaan Laporan

Tentukan templat laporan: kumpulkan data, formatkannya dan hasilkan output. Tukar subkelas untuk output PDF, HTML atau CSV tanpa mengubah logik penyelarasan.

public abstract class ReportGenerator {
    public final String generate() {
        List<Record> data = fetchData();
        String body = format(data);
        return wrap(body);
    }
    protected abstract List<Record> fetchData();
    protected abstract String format(List<Record> data);
    protected String wrap(String body) { return body; } // hook
}

Mencegah Penggantian Templat

Isytiharkan kaedah templat sebagai final untuk menghalang subkelas daripada mengubah struktur algoritma. Hanya kaedah cangkuk dan kaedah abstract yang patut boleh digantikan.

public final void process() {
    validate(); // abstract
    execute();  // abstract
    cleanup();  // hook with default
}

Langkah abstract berbanding Konkret

Jadikan sesuatu langkah abstract apabila langkah itu mesti disediakan oleh subkelas. Jadikan langkah itu konkret, mungkin kosong, apabila subkelas boleh menggantikannya untuk penyesuaian.

Kaedah Templat dalam JUnit

setUp() dan tearDown() JUnit 4 ialah cangkuk dalam kaedah templat yang ditakrifkan oleh pelaksana ujian. Pelaksana itu mengawal masa kedua-duanya dipanggil.

Kaedah Templat dalam Spring

JdbcTemplate Spring menggunakan Kaedah Templat secara dalaman. Templat mengawal sambungan, penciptaan pernyataan dan pembersihan; anda membekalkan lambda RowMapper untuk langkah yang berbeza-beza, iaitu memetakan baris.

List<User> users = jdbcTemplate.query(
    "SELECT * FROM users",
    (rs, row) -> new User(rs.getLong("id"), rs.getString("name"))
);

Elakkan Pewarisan Mendalam

Kaedah Templat bergantung pada pewarisan, yang boleh menghasilkan hierarki kelas yang mendalam. Hadkan kepada 1–2 aras. Jika subkelas mula menggantikan banyak langkah secara berbeza, pertimbangkan untuk beralih kepada Strategi.

Semakan Pantas

Apakah kata kunci yang menghalang subkelas daripada mengubah urutan kaedah templat?

Jawab dalam pelajaran interaktif

Rumusan

Kaedah Templat mengunci rangka algoritma dalam kelas asas dengan final. Subkelas melaksanakan langkah abstract dan secara pilihan menggantikan cangkuk. Kekalkan hierarki yang cetek; gunakan Strategi apabila lebih banyak fleksibiliti diperlukan.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Template Method: Mentakrifkan Rangka Algoritma” percuma?

Ya — teks penuh “Template Method: Mentakrifkan Rangka Algoritma” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Template Method: Mentakrifkan Rangka Algoritma”?

Takrifkan rangka algoritma dalam kelas asas dan biarkan subkelas melengkapkan langkah-langkahnya. Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Template Method: Mentakrifkan Rangka Algoritma” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Corak Observer: Pemberitahuan Acara
Corak Strategy: Algoritma Boleh Tukar Ganti
Corak Command: Merangkum Tindakan
Template Method: Mentakrifkan Rangka Algoritma

← Kembali ke Java Academy