Merekabentuk Kelas dan Antara Muka (Terjemahan artikel)

Kandungan

1. pengenalan
2. Antara muka
3. Penanda antara muka
4. Antara muka berfungsi, kaedah statik dan kaedah lalai
5. Kelas abstrak
6. Kelas tidak berubah (kekal).
7. Kelas tanpa nama
8. Keterlihatan
9. Warisan
10. Pusaka berbilang
11. Warisan dan komposisi
12. Enkapsulasi
13. Kelas dan kaedah akhir
14. Apa yang akan datang
15. Muat turun kod sumber

1. PENGENALAN

Tidak kira apa bahasa pengaturcaraan yang anda gunakan (dan Java tidak terkecuali), mengikut prinsip reka bentuk yang baik adalah kunci untuk menulis kod yang bersih, mudah difahami dan boleh disahkan; dan juga menciptanya untuk bertahan lama dan mudah menyokong penyelesaian masalah. Dalam bahagian tutorial ini, kami akan membincangkan blok binaan asas yang disediakan oleh bahasa Java dan memperkenalkan beberapa prinsip reka bentuk dalam usaha untuk membantu anda membuat keputusan reka bentuk yang lebih baik. Lebih khusus lagi, kita akan membincangkan antara muka dan antara muka menggunakan kaedah lalai (ciri baharu dalam Java 8), kelas abstrak dan akhir, kelas tidak boleh ubah, warisan, gubahan, dan menyemak semula peraturan keterlihatan (atau kebolehaksesan) yang kami sentuh secara ringkas dalam Bahagian 1 pelajaran "Cara mencipta dan memusnahkan objek" .

2. ANTARA MUKA

Dalam pengaturcaraan berorientasikan objek , konsep antara muka membentuk asas untuk pembangunan kontrak . Secara ringkasnya, antara muka mentakrifkan satu set kaedah (kontrak) dan setiap kelas yang memerlukan sokongan untuk antara muka khusus itu mesti menyediakan pelaksanaan kaedah tersebut: idea yang agak mudah tetapi berkuasa. Banyak bahasa pengaturcaraan mempunyai antara muka dalam satu bentuk atau yang lain, tetapi Java khususnya menyediakan sokongan bahasa untuk ini. Mari kita lihat definisi antara muka mudah dalam Java.

package com.javacodegeeks.advanced.design;

public interface SimpleInterface {
void performAction();
}

Dalam coretan di atas, antara muka yang kami panggil SimpleInterface, mengisytiharkan hanya satu kaedah yang dipanggil performAction. Perbezaan utama antara antara muka dan kelas ialah antara muka menggariskan hubungan yang sepatutnya (mereka mengisytiharkan kaedah), tetapi tidak menyediakan pelaksanaannya. Walau bagaimanapun, antara muka dalam Java boleh menjadi lebih kompleks: ia boleh termasuk antara muka bersarang, kelas, kiraan, anotasi dan pemalar. Sebagai contoh:

package com.javacodegeeks.advanced.design;

public interface InterfaceWithDefinitions {
    String CONSTANT = "CONSTANT";

    enum InnerEnum {
        E1, E2;
    }

    class InnerClass {
    }

    interface InnerInterface {
        void performInnerAction();
    }

    void performAction();
}

Dalam contoh yang lebih kompleks ini, terdapat beberapa sekatan yang antara muka dikenakan tanpa syarat pada binaan bersarang dan pengisytiharan kaedah yang dikuatkuasakan oleh pengkompil Java. Pertama sekali, walaupun tidak diisytiharkan secara eksplisit, setiap pengisytiharan kaedah dalam antara muka adalah awam (dan hanya boleh didedahkan kepada umum). Oleh itu, pengisytiharan kaedah berikut adalah setara:

public void performAction();
void performAction();

Perlu dinyatakan bahawa setiap kaedah dalam antara muka diisytiharkan secara tersirat abstract , malah pengisytiharan kaedah ini adalah setara:

public abstract void performAction();
public void performAction();
void performAction();

Bagi medan malar yang diisytiharkan, selain menjadi awam , ia juga secara tersirat statik dan ditanda muktamad . Oleh itu pengisytiharan berikut juga setara:

String CONSTANT = "CONSTANT";
public static final String CONSTANT = "CONSTANT";

Akhir sekali, kelas bersarang, antara muka atau kiraan, selain menjadi public , juga secara tersirat diisytiharkan statik . Sebagai contoh, pengisytiharan ini juga bersamaan dengan:

class InnerClass {
}

static class InnerClass {
}

Gaya yang anda pilih ialah pilihan peribadi, tetapi mengetahui sifat mudah antara muka ini boleh menyelamatkan anda daripada menaip yang tidak perlu.

3. Penanda antara muka

Antara muka penanda ialah jenis antara muka khas yang tidak mempunyai kaedah atau binaan bersarang lain. Bagaimana pustaka Java mentakrifkannya:

public interface Cloneable {
}

Penanda antara muka bukan kontrak semata-mata, tetapi merupakan teknik yang agak berguna untuk "melekatkan" atau "mengaitkan" beberapa sifat tertentu dengan kelas. Sebagai contoh, berkenaan dengan Cloneable , kelas ditandakan sebagai boleh klon, tetapi cara ini boleh atau harus dilaksanakan bukan sebahagian daripada antara muka. Satu lagi contoh penanda antara muka yang sangat terkenal dan digunakan secara meluas ialah Serializable:

public interface Serializable {
}

Antara muka ini menandakan kelas sebagai sesuai untuk bersiri dan penyahserikatan, dan sekali lagi, ia tidak menyatakan cara ini boleh atau patut dilaksanakan. Penanda antara muka mempunyai tempat mereka dalam pengaturcaraan berorientasikan objek, walaupun mereka tidak memenuhi tujuan utama antara muka untuk menjadi kontrak. 

4. ANTARA MUKA BERFUNGSI, KAEDAH LALAI DAN KAEDAH STATIK

Sejak keluaran Java 8, antara muka telah memperoleh beberapa ciri baharu yang sangat menarik: kaedah statik, kaedah lalai dan penukaran automatik daripada lambdas (antara muka berfungsi). Dalam bahagian antara muka, kami menekankan fakta bahawa antara muka dalam Java hanya boleh mengisytiharkan kaedah, tetapi tidak menyediakan pelaksanaannya. Dengan kaedah lalai, perkara adalah berbeza: antara muka boleh menandakan kaedah dengan kata kunci lalai dan menyediakan pelaksanaan untuknya. Sebagai contoh:

package com.javacodegeeks.advanced.design;

public interface InterfaceWithDefaultMethods {
    void performAction();

    default void performDefaulAction() {
        // Implementation here
    }
}

Berada di peringkat contoh, kaedah lalai boleh ditindih oleh setiap pelaksanaan antara muka, tetapi antara muka kini boleh juga termasuk kaedah statik , contohnya: package com.javacodegeeks.advanced.design;

public interface InterfaceWithDefaultMethods {
    static void createAction() {
        // Implementation here
    }
}

Boleh dikatakan bahawa menyediakan pelaksanaan dalam antara muka mengalahkan keseluruhan tujuan pengaturcaraan kontrak. Tetapi terdapat banyak sebab mengapa ciri ini diperkenalkan ke dalam bahasa Java dan tidak kira betapa berguna atau mengelirukan ciri tersebut, ia ada untuk anda dan kegunaan anda. Antara muka berfungsi ialah cerita yang sama sekali berbeza dan telah terbukti sebagai tambahan yang sangat berguna kepada bahasa. Pada asasnya, antara muka berfungsi ialah antara muka dengan hanya satu kaedah abstrak yang diisytiharkan padanya. RunnableAntara muka perpustakaan standard adalah contoh yang sangat baik untuk konsep ini.

@FunctionalInterface
public interface Runnable {
    void run();
}

Pengkompil Java melayan antara muka berfungsi secara berbeza dan boleh menukar fungsi lambda menjadi pelaksanaan antara muka berfungsi di mana ia masuk akal. Mari kita pertimbangkan penerangan fungsi berikut: 

public void runMe( final Runnable r ) {
    r.run();
}

Untuk memanggil fungsi ini dalam Java 7 dan ke bawah, pelaksanaan antara muka mesti disediakan Runnable(contohnya, menggunakan kelas tanpa nama), tetapi dalam Java 8 adalah mencukupi untuk menyediakan pelaksanaan kaedah run() menggunakan sintaks lambda:

runMe( () -> System.out.println( "Run!" ) );

Selain itu, anotasi @FunctionalInterface (anotasi akan diliputi secara terperinci dalam Bahagian 5 tutorial) membayangkan bahawa pengkompil boleh menyemak sama ada antara muka mengandungi hanya satu kaedah abstrak, jadi sebarang perubahan yang dibuat pada antara muka pada masa hadapan tidak akan melanggar andaian ini .

5. KELAS ABSTRAK

Satu lagi konsep menarik yang disokong oleh bahasa Java ialah konsep kelas abstrak. Kelas abstrak agak serupa dengan antara muka dalam Java 7 dan sangat hampir dengan antara muka kaedah lalai dalam Java 8. Tidak seperti kelas biasa, kelas abstrak tidak boleh digunakan, tetapi ia boleh disubkelaskan (rujuk bahagian Warisan untuk butiran lanjut ). Lebih penting lagi, kelas abstrak boleh mengandungi kaedah abstrak: kaedah khas tanpa pelaksanaan, sama seperti antara muka. Sebagai contoh:

package com.javacodegeeks.advanced.design;

public abstract class SimpleAbstractClass {
    public void performAction() {
        // Implementation here
    }

    public abstract void performAnotherAction();
}

Dalam contoh ini, kelas SimpleAbstractClassdiisytiharkan sebagai abstrak dan mengandungi satu kaedah abstrak yang diisytiharkan. Kelas abstrak sangat berguna; kebanyakan atau bahkan beberapa bahagian butiran pelaksanaan boleh dikongsi di antara banyak subkelas. Walau apa pun, mereka masih membiarkan pintu terbuka dan membenarkan anda menyesuaikan tingkah laku yang wujud dalam setiap subkelas menggunakan kaedah abstrak. Perlu dinyatakan bahawa tidak seperti antara muka, yang hanya boleh mengandungi pengisytiharan awam , kelas abstrak boleh menggunakan kuasa penuh peraturan kebolehaksesan untuk mengawal keterlihatan kaedah abstrak.

6. KELAS SEGERA

Ketidakbolehubahan menjadi semakin penting dalam pembangunan perisian pada masa kini. Kebangkitan sistem berbilang teras telah menimbulkan banyak isu yang berkaitan dengan perkongsian data dan keselarian. Tetapi satu masalah pasti timbul: mempunyai sedikit (atau bahkan tiada) keadaan boleh berubah membawa kepada kebolehlanjutan (skala) yang lebih baik dan penaakulan yang lebih mudah tentang sistem. Malangnya, bahasa Java tidak menyediakan sokongan yang baik untuk kebolehubahan kelas. Walau bagaimanapun, dengan menggunakan gabungan teknik, ia menjadi mungkin untuk mereka bentuk kelas yang tidak berubah. Pertama sekali, semua medan kelas mestilah muktamad (ditandakan sebagai muktamad ). Ini adalah permulaan yang baik, tetapi ia bukan jaminan. 

package com.javacodegeeks.advanced.design;

import java.util.Collection;

public class ImmutableClass {
    private final long id;
    private final String[] arrayOfStrings;
    private final Collection<String> collectionOfString;
}

Kedua, pastikan permulaan yang betul: jika medan adalah rujukan kepada koleksi atau tatasusunan, jangan tetapkan medan tersebut terus daripada hujah pembina, sebaliknya buat salinan. Ini akan memastikan bahawa keadaan koleksi atau tatasusunan tidak diubah suai di luarnya.

public ImmutableClass( final long id, final String[] arrayOfStrings,
        final Collection<String> collectionOfString) {
    this.id = id;
    this.arrayOfStrings = Arrays.copyOf( arrayOfStrings, arrayOfStrings.length );
    this.collectionOfString = new ArrayList<>( collectionOfString );
}

Dan akhirnya, memastikan akses yang betul (getters). Untuk koleksi, kebolehubahan mesti disediakan sebagai pembungkus  Collections.unmodifiableXxx: Dengan tatasusunan, satu-satunya cara untuk memberikan kebolehubahan sebenar adalah dengan menyediakan salinan dan bukannya mengembalikan rujukan kepada tatasusunan. Ini mungkin tidak boleh diterima dari sudut praktikal, kerana ia sangat bergantung pada saiz tatasusunan dan boleh memberi tekanan yang besar kepada pemungut sampah.

public String[] getArrayOfStrings() {
    return Arrays.copyOf( arrayOfStrings, arrayOfStrings.length );
}

Malah contoh kecil ini memberikan idea yang baik bahawa kebolehubahan belum lagi menjadi warga kelas pertama di Jawa. Perkara boleh menjadi rumit jika kelas tidak berubah mempunyai medan yang merujuk kepada objek kelas lain. Kelas tersebut juga seharusnya tidak berubah, tetapi tidak ada cara untuk memastikan ini. Terdapat beberapa penganalisis kod sumber Java yang baik, seperti FindBugs dan PMD, yang boleh membantu dengan menyemak kod anda dan menunjukkan kelemahan pengaturcaraan Java biasa. Alat ini adalah rakan hebat mana-mana pembangun Java.

7. KELAS TANPA NAMA

Dalam era pra-Java 8, kelas tanpa nama adalah satu-satunya cara untuk memastikan kelas ditakrifkan dengan cepat dan dibuat serta-merta. Tujuan kelas tanpa nama adalah untuk mengurangkan boilerplate dan menyediakan cara ringkas dan mudah untuk mewakili kelas sebagai rekod. Mari kita lihat cara lama yang tipikal untuk menghasilkan benang baharu di Jawa:

package com.javacodegeeks.advanced.design;

public class AnonymousClass {
    public static void main( String[] args ) {
        new Thread(
            // Example of creating anonymous class which implements
            // Runnable interface
            new Runnable() {
                @Override
                public void run() {
                    // Implementation here
                }
            }
        ).start();
    }
}

Dalam contoh ini, pelaksanaan Runnableantara muka disediakan serta-merta sebagai kelas tanpa nama. Walaupun terdapat beberapa batasan yang dikaitkan dengan kelas tanpa nama, kelemahan utama penggunaannya ialah sintaks binaan yang sangat verbose yang Java sebagai bahasa wajib. Walaupun hanya kelas tanpa nama yang tidak melakukan apa-apa memerlukan sekurang-kurangnya 5 baris kod setiap kali ia ditulis.

new Runnable() {
   @Override
   public void run() {
   }
}

Nasib baik, dengan Java 8, lambda dan antara muka berfungsi, semua stereotaip ini akan hilang tidak lama lagi, akhirnya menulis kod Java akan kelihatan benar-benar ringkas.

package com.javacodegeeks.advanced.design;

public class AnonymousClass {
    public static void main( String[] args ) {
        new Thread( () -> { /* Implementation here */ } ).start();
    }
}

8. KELIHATAN

Kami telah bercakap sedikit tentang peraturan keterlihatan dan kebolehaksesan di Java dalam Bahagian 1 tutorial. Dalam bahagian ini, kita akan menyemak semula topik ini, tetapi dalam konteks subkelas. Keterlihatan pada tahap yang berbeza membenarkan atau menghalang kelas daripada melihat kelas atau antara muka lain (contohnya, jika mereka berada dalam pakej yang berbeza atau bersarang dalam satu sama lain) atau subkelas daripada melihat dan mengakses kaedah, pembina dan medan ibu bapa mereka. Dalam bahagian seterusnya, warisan, kita akan melihat ini dalam tindakan.

9. WARISAN

Warisan ialah salah satu konsep utama pengaturcaraan berorientasikan objek, berfungsi sebagai asas untuk membina kelas perhubungan. Digabungkan dengan peraturan keterlihatan dan kebolehaksesan, warisan membolehkan kelas direka bentuk menjadi hierarki yang boleh dilanjutkan dan dikekalkan. Pada peringkat konsep, pewarisan dalam Java dilaksanakan menggunakan subkelas dan kata kunci lanjutan , bersama dengan kelas induk. Subkelas mewarisi semua elemen awam dan dilindungi kelas induk. Selain itu, subkelas mewarisi elemen pakej-peribadi kelas induknya jika kedua-duanya (subkelas dan kelas) berada dalam pakej yang sama. Walau bagaimanapun, adalah sangat penting, tidak kira apa yang anda cuba reka bentuk, untuk berpegang pada set kaedah minimum yang didedahkan oleh kelas secara terbuka atau kepada subkelasnya. Sebagai contoh, mari kita lihat kelas Parentdan subkelasnya Childuntuk menunjukkan perbezaan tahap keterlihatan dan kesannya.

package com.javacodegeeks.advanced.design;

public class Parent {
    // Everyone can see it
    public static final String CONSTANT = "Constant";

    // No one can access it
    private String privateField;
    // Only subclasses can access it
    protected String protectedField;

    // No one can see it
    private class PrivateClass {
    }

    // Only visible to subclasses
    protected interface ProtectedInterface {
    }

    // Everyone can call it
    public void publicAction() {
    }

    // Only subclass can call it
    protected void protectedAction() {
    }

    // No one can call it
    private void privateAction() {
    }

    // Only subclasses in the same package can call it
    void packageAction() {
    }
}

package com.javacodegeeks.advanced.design;

// Resides in the same package as parent class
public class Child extends Parent implements Parent.ProtectedInterface {
    @Override
    protected void protectedAction() {
        // Calls parent's method implementation
        super.protectedAction();
    }

    @Override
    void packageAction() {
        // Do nothing, no call to parent's method implementation
    }

    public void childAction() {
        this.protectedField = "value";
    }
}

Warisan adalah topik yang sangat besar itu sendiri, dengan banyak perincian halus khusus untuk Java. Walau bagaimanapun, terdapat beberapa peraturan yang mudah diikuti dan boleh membantu dalam mengekalkan kepekatan hierarki kelas. Di Java, setiap subkelas boleh mengatasi mana-mana kaedah yang diwarisi induknya melainkan ia telah diisytiharkan muktamad. Walau bagaimanapun, tiada sintaks atau kata kunci khas untuk menandakan kaedah sebagai ditindih, yang boleh menyebabkan kekeliruan. Inilah sebab mengapa anotasi @Override diperkenalkan : apabila matlamat anda adalah untuk menggantikan kaedah yang diwarisi, sila gunakan anotasi @Override untuk menunjukkannya dengan ringkas. Satu lagi dilema yang selalu dihadapi oleh pembangun Java dalam reka bentuk ialah pembinaan hierarki kelas (dengan kelas konkrit atau abstrak) berbanding pelaksanaan antara muka. Kami amat mengesyorkan untuk mengutamakan antara muka berbanding kelas atau kelas abstrak apabila boleh. Antara muka lebih ringan, lebih mudah untuk diuji dan diselenggara, dan juga meminimumkan kesan sampingan perubahan pelaksanaan. Banyak teknik pengaturcaraan lanjutan, seperti mencipta kelas proksi dalam perpustakaan standard Java, sangat bergantung pada antara muka.

10. WARISAN BERGANDA

Tidak seperti C++ dan beberapa bahasa lain, Java tidak menyokong pelbagai warisan: dalam Java, setiap kelas hanya boleh mempunyai satu induk langsung (dengan kelas Objectdi bahagian atas hierarki). Walau bagaimanapun, kelas boleh melaksanakan berbilang antara muka, dan dengan itu susun antara muka adalah satu-satunya cara untuk mencapai (atau mensimulasikan) warisan berbilang dalam Java.

package com.javacodegeeks.advanced.design;

public class MultipleInterfaces implements Runnable, AutoCloseable {
    @Override
    public void run() {
        // Some implementation here
    }

    @Override
    public void close() throws Exception {
       // Some implementation here
    }
}

Melaksanakan berbilang antara muka sebenarnya agak berkuasa, tetapi selalunya keperluan untuk menggunakan pelaksanaan berulang kali membawa kepada hierarki kelas mendalam sebagai cara untuk mengatasi kekurangan sokongan Java untuk warisan berbilang. 

public class A implements Runnable {
    @Override
    public void run() {
        // Some implementation here
    }
}

// Class B wants to inherit the implementation of run() method from class A.
public class B extends A implements AutoCloseable {
    @Override
    public void close() throws Exception {
       // Some implementation here
    }
}

// Class C wants to inherit the implementation of run() method from class A
// and the implementation of close() method from class B.
public class C extends B implements Readable {
    @Override
    public int read(java.nio.CharBuffer cb) throws IOException {
       // Some implementation here
    }
}

Dan seterusnya... Keluaran Java 8 baru-baru ini agak menangani isu dengan suntikan kaedah lalai. Kerana kaedah lalai, antara muka sebenarnya menyediakan bukan sahaja kontrak, tetapi juga pelaksanaan. Oleh itu, kelas yang melaksanakan antara muka ini juga akan mewarisi kaedah yang dilaksanakan ini secara automatik. Sebagai contoh:

package com.javacodegeeks.advanced.design;

public interface DefaultMethods extends Runnable, AutoCloseable {
    @Override
    default void run() {
        // Some implementation here
    }

    @Override
    default void close() throws Exception {
       // Some implementation here
    }
}

// Class C inherits the implementation of run() and close() methods from the
// DefaultMethods interface.
public class C implements DefaultMethods, Readable {
    @Override
    public int read(java.nio.CharBuffer cb) throws IOException {
       // Some implementation here
    }
}

Perlu diingat bahawa warisan berbilang adalah alat yang sangat berkuasa, tetapi pada masa yang sama berbahaya. Masalah Diamond of Death yang terkenal sering disebut sebagai kecacatan utama dalam pelaksanaan pelbagai warisan, memaksa pembangun untuk mereka bentuk hierarki kelas dengan berhati-hati. Malangnya, antara muka Java 8 dengan kaedah lalai juga menjadi mangsa kepada kecacatan ini.

interface A {
    default void performAction() {
    }
}

interface B extends A {
    @Override
    default void performAction() {
    }
}

interface C extends A {
    @Override
    default void performAction() {
    }
}

Sebagai contoh, coretan kod berikut akan gagal untuk disusun:

// E is not compilable unless it overrides performAction() as well
interface E extends B, C {
}

Pada ketika ini, adalah wajar untuk mengatakan bahawa Java sebagai bahasa sentiasa cuba mengelakkan kes sudut pengaturcaraan berorientasikan objek, tetapi apabila bahasa itu berkembang, beberapa kes tersebut tiba-tiba mula muncul. 

11. WARISAN DAN KARANGAN

Nasib baik, warisan bukan satu-satunya cara untuk mereka bentuk kelas anda. Alternatif lain yang ramai pembangun percaya jauh lebih baik daripada warisan ialah komposisi. Idea ini sangat mudah: daripada mencipta hierarki kelas, mereka perlu terdiri daripada kelas lain. Mari lihat contoh ini:

// E is not compilable unless it overrides performAction() as well
interface E extends B, C {
}

Kelas ini Vehicleterdiri daripada enjin dan roda (ditambah banyak bahagian lain yang diketepikan untuk kesederhanaan). Walau bagaimanapun, boleh dikatakan bahawa kelas Vehiclejuga adalah enjin, jadi ia boleh direka bentuk menggunakan warisan. 

public class Vehicle extends Engine {
    private Wheels[] wheels;
    // ...
}

Penyelesaian reka bentuk manakah yang betul? Garis panduan teras umum dikenali sebagai prinsip IS-A (adalah) dan HAS-A (mengandungi). IS-A ialah perhubungan warisan: subkelas juga memenuhi spesifikasi kelas kelas induk dan variasi kelas induk. subkelas) memanjangkan induknya. Jika anda ingin mengetahui sama ada satu entiti melanjutkan yang lain, lakukan ujian padanan - IS -A (ialah)") Oleh itu, HAS-A ialah hubungan gubahan: kelas memiliki (atau mengandungi) objek yang Dalam kebanyakan kes, prinsip HAS-A berfungsi lebih baik daripada IS-A atas beberapa sebab: 

• Reka bentuk lebih fleksibel;
• Model ini lebih stabil kerana perubahan tidak disebarkan melalui hierarki kelas;
• Kelas dan gubahannya digandingkan secara longgar berbanding dengan gubahan, yang menggandingkan dengan ketat ibu bapa dan subkelasnya.
• Pemikiran logik dalam kelas adalah lebih mudah, kerana semua kebergantungannya disertakan di dalamnya, di satu tempat. 

Walau apa pun, warisan mempunyai tempatnya dan menyelesaikan beberapa masalah reka bentuk sedia ada dalam pelbagai cara, jadi ia tidak boleh diabaikan. Sila ingat kedua-dua alternatif ini semasa mereka bentuk model berorientasikan objek anda.

12. EKAPSULASI.

Konsep enkapsulasi dalam pengaturcaraan berorientasikan objek adalah untuk menyembunyikan semua butiran pelaksanaan (seperti mod pengendalian, kaedah dalaman, dll.) dari dunia luar. Faedah enkapsulasi ialah kebolehselenggaraan dan kemudahan perubahan. Pelaksanaan dalaman kelas disembunyikan, bekerja dengan data kelas berlaku secara eksklusif melalui kaedah awam kelas (masalah sebenar jika anda sedang membangunkan perpustakaan atau rangka kerja yang digunakan oleh ramai orang). Enkapsulasi dalam Java dicapai melalui peraturan keterlihatan dan kebolehaksesan. Di Jawa, adalah dianggap sebagai amalan terbaik untuk tidak mendedahkan medan secara langsung, hanya melalui getter dan setter (melainkan medan ditanda muktamad). Sebagai contoh:

package com.javacodegeeks.advanced.design;

public class Encapsulation {
    private final String email;
    private String address;

    public Encapsulation( final String email ) {
        this.email = email;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getEmail() {
        return email;
    }
}

Contoh ini mengingatkan apa yang dipanggil JavaBeans dalam bahasa Java: kelas Java standard ditulis mengikut set konvensyen, salah satunya membenarkan medan diakses hanya menggunakan kaedah pengambil dan penetap. Seperti yang telah kami tekankan dalam bahagian warisan, sila sentiasa mematuhi kontrak publisiti minimum dalam kelas, menggunakan prinsip enkapsulasi. Segala-galanya yang tidak sepatutnya umum harus menjadi peribadi (atau dilindungi/pakej peribadi, bergantung pada masalah yang anda selesaikan). Ini akan membuahkan hasil dalam jangka panjang dengan memberi anda kebebasan untuk mereka bentuk tanpa (atau sekurang-kurangnya meminimumkan) perubahan yang melanggar. 

13. KELAS DAN KAEDAH AKHIR

Di Jawa, terdapat cara untuk menghalang kelas daripada menjadi subkelas kelas lain: kelas lain mesti diisytiharkan muktamad. 

package com.javacodegeeks.advanced.design;

public final class FinalClass {
}

Kata kunci akhir yang sama dalam pengisytiharan kaedah menghalang subkelas daripada mengatasi kaedah. 

package com.javacodegeeks.advanced.design;

public class FinalMethod {
    public final void performAction() {
    }
}

Tiada peraturan am untuk memutuskan sama ada kelas atau kaedah harus muktamad atau tidak. Kelas dan kaedah akhir mengehadkan kebolehlanjutan dan amat sukar untuk berfikir ke hadapan sama ada kelas patut atau tidak patut diwarisi, atau sama ada kaedah patut atau tidak patut ditindih pada masa hadapan. Ini amat penting untuk pembangun perpustakaan, kerana keputusan reka bentuk seperti ini boleh mengehadkan kebolehgunaan perpustakaan dengan ketara. Perpustakaan Standard Java mempunyai beberapa contoh kelas akhir, yang paling terkenal ialah kelas String. Pada peringkat awal, keputusan ini dibuat untuk menghalang sebarang percubaan oleh pembangun untuk menghasilkan penyelesaian "lebih baik" mereka sendiri untuk melaksanakan rentetan. 

14. APA SETERUSNYA

Dalam bahagian pelajaran ini, kami membincangkan konsep pengaturcaraan berorientasikan objek di Jawa. Kami juga melihat dengan pantas pengaturcaraan kontrak, menyentuh beberapa konsep berfungsi dan melihat bagaimana bahasa itu telah berkembang dari semasa ke semasa. Dalam bahagian pelajaran seterusnya, kita akan bertemu generik dan cara mereka mengubah cara kita mendekati keselamatan jenis dalam pengaturcaraan. 

15. MUAT TURUN KOD SUMBER

Anda boleh memuat turun sumber di sini - advanced-java-part-3 Sumber: Bagaimana untuk mereka bentuk Kelas an