Ngrancang Kelas lan Antarmuka (Terjemahan artikel)

Isi

1. Pambuka
2. Antarmuka
3. Tandha antarmuka
4. Antarmuka Fungsional, Metode Statis, lan Metode Default
5. Kelas abstrak
6. Kelas sing ora bisa diganti (permanen).
7. Kelas anonim
8. Visibilitas
9. pusaka
10. Multiple warisan
11. Warisan lan komposisi
12. Enkapsulasi
13. Kelas lan metode pungkasan
14. Apa maneh
15. Ngundhuh kode sumber

1. PAMBUKA

Ora ketompo apa basa pamrograman sing sampeyan gunakake (lan Jawa ora kajaba), miturut prinsip desain sing apik minangka kunci kanggo nulis kode sing resik, bisa dingerteni, lan bisa diverifikasi; lan uga nggawe supaya bisa tahan suwe lan gampang ndhukung pemecahan masalah. Ing bagean tutorial iki, kita bakal ngrembug babagan dhasar dhasar sing diwenehake basa Jawa lan ngenalake sawetara prinsip desain kanggo mbantu sampeyan nggawe keputusan desain sing luwih apik. Luwih khusus, kita bakal ngrembug antarmuka lan antarmuka nggunakake metode standar (fitur anyar ing Jawa 8), kelas abstrak lan pungkasan, kelas sing ora bisa diowahi, warisan, komposisi, lan mriksa maneh aturan visibilitas (utawa aksesibilitas) sing dideleng kanthi ringkes ing. Bagian 1 pelajaran "Carane nggawe lan ngrusak obyek" .

2. Antarmuka

Ing pemrograman berorientasi obyek , konsep antarmuka dadi basis kanggo pangembangan kontrak . Cekakipun, antarmuka nemtokake pesawat saka cara (kontrak) lan saben kelas sing mbutuhake support kanggo antarmuka tartamtu kudu nyedhiyani implementasine saka cara kasebut: idea cukup prasaja nanging kuat. Akeh basa pemrograman duwe antarmuka ing siji utawa liyane, nanging Jawa khusus nyedhiyakake dhukungan basa kanggo iki. Ayo goleki definisi antarmuka sing prasaja ing Jawa.

package com.javacodegeeks.advanced.design;

public interface SimpleInterface {
void performAction();
}

Ing cuplikan ing ndhuwur, antarmuka sing diarani SimpleInterface, nyatakake mung siji metode sing diarani performAction. Bentenipun utama antarane antarmuka lan kelas iku antarmuka njelaske nganggo bentuk garis apa kontak kudu (padha ngumumake cara), nanging ora nyedhiyani implementasine. Nanging, antarmuka ing Jawa bisa dadi luwih rumit: bisa kalebu antarmuka bersarang, kelas, count, anotasi, lan konstanta. Tuladhane:

package com.javacodegeeks.advanced.design;

public interface InterfaceWithDefinitions {
    String CONSTANT = "CONSTANT";

    enum InnerEnum {
        E1, E2;
    }

    class InnerClass {
    }

    interface InnerInterface {
        void performInnerAction();
    }

    void performAction();
}

Ing conto sing luwih rumit iki, ana sawetara watesan sing antarmuka tanpa syarat kanggo mbangun nesting lan deklarasi metode, lan iki dileksanakake dening compiler Java. Kaping pisanan, sanajan ora diumumake kanthi jelas, saben deklarasi metode ing antarmuka umum (lan mung bisa umum). Dadi, deklarasi metode ing ngisor iki padha karo:

public void performAction();
void performAction();

Perlu dicathet yen saben metode ing antarmuka kasebut sacara implisit diumumake abstract , lan uga deklarasi metode iki padha karo:

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

Kanggo lapangan konstan sing diumumake, saliyane dadi umum , uga sacara implisit statis lan ditandhani final . Mulane, deklarasi ing ngisor iki uga padha:

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

Pungkasan, kelas bersarang, antarmuka, utawa jumlah, saliyane dadi umum , uga sacara implisit diumumake statis . Contone, deklarasi iki uga padha karo:

class InnerClass {
}

static class InnerClass {
}

Gaya sing sampeyan pilih minangka pilihan pribadi, nanging ngerti sifat-sifat antarmuka sing prasaja iki bisa nylametake sampeyan saka ngetik sing ora perlu.

3. Panandha antarmuka

Antarmuka panandha minangka antarmuka khusus sing ora duwe metode utawa konstruksi bersarang liyane. Kepiye carane perpustakaan Java nemtokake:

public interface Cloneable {
}

Penanda antarmuka ora mung kontrak, nanging minangka teknik sing migunani kanggo "masang" utawa "ngahubungake" sawetara sipat tartamtu karo kelas. Contone, babagan Cloneable , kelas kasebut ditandhani minangka cloneable, nanging cara iki bisa utawa kudu dileksanakake ora dadi bagian saka antarmuka. Conto panandha antarmuka liyane sing misuwur lan akeh digunakake yaiku Serializable:

public interface Serializable {
}

Antarmuka iki menehi tandha kelas minangka cocok kanggo serialization lan deserialization, lan maneh, iku ora nemtokake carane iki bisa utawa kudu dipun ginakaken. Penanda antarmuka duwe panggonan ing pemrograman berorientasi obyek, sanajan ora bisa nyukupi tujuan utama antarmuka dadi kontrak. 

4. ANTARA FUNGSIONAL, METODE DEFAULT lan METODE STATIS

Wiwit rilis Java 8, antarmuka wis entuk sawetara fitur anyar sing menarik: metode statis, metode standar, lan konversi otomatis saka lambdas (antarmuka fungsional). Ing bagean antarmuka, kita nandheske kasunyatan manawa antarmuka ing Jawa mung bisa ngumumake metode, nanging ora menehi implementasine. Kanthi cara standar, ana macem-macem: antarmuka bisa menehi tandha cara nganggo tembung kunci standar lan menehi implementasine. Tuladhane:

package com.javacodegeeks.advanced.design;

public interface InterfaceWithDefaultMethods {
    void performAction();

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

Dadi ing tingkat conto, cara gawan bisa diganti dening saben implementasine antarmuka, nanging antarmuka saiki bisa uga kalebu cara statis , contone: paket com.javacodegeeks.advanced.design;

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

Bisa dikandhakake manawa nyedhiyakake implementasine ing antarmuka bisa ngalahake kabeh tujuan program kontrak. Nanging ana akeh alasan kenapa fitur-fitur kasebut dikenalake ing basa Jawa lan ora ketompo carane migunani utawa mbingungake, nanging ana kanggo sampeyan lan sampeyan. Antarmuka fungsional minangka crita sing beda lan wis kabukten minangka tambahan sing migunani kanggo basa kasebut. Sejatine, antarmuka fungsional minangka antarmuka kanthi mung siji cara abstrak sing diumumake. RunnableAntarmuka perpustakaan standar minangka conto sing apik banget babagan konsep iki.

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

Compiler Java nganggep antarmuka fungsional kanthi cara sing beda lan bisa ngowahi fungsi lambda dadi implementasi antarmuka fungsional sing cocog. Ayo dipikirake deskripsi fungsi ing ngisor iki: 

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

Kanggo nelpon fungsi iki ing Jawa 7 lan ngisor, implementasine saka antarmuka kudu kasedhiya Runnable(contone, nggunakake kelas anonim), nanging Jawa 8 iku cukup kanggo nyedhiyani implementasine saka run() cara nggunakake sintaks lambda:

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

Kajaba iku, anotasi @FunctionalInterface (anotasi bakal dibahas kanthi rinci ing Bagian 5 saka tutorial) nuduhake manawa kompiler bisa mriksa manawa antarmuka mung ngemot siji metode abstrak, saengga owah-owahan apa wae ing antarmuka ing mangsa ngarep ora bakal nglanggar asumsi iki. .

5. KELAS ABSTRAK

Konsep liyane sing menarik sing didhukung dening basa Jawa yaiku konsep kelas abstrak. Kelas abstrak meh padha karo antarmuka ing Jawa 7 lan cedhak banget karo antarmuka metode standar ing Jawa 8. Boten kados kelas biasa, kelas abstrak ora bisa instantiated, nanging bisa subclassed (ndeleng bagean Warisan kanggo rincian liyane ). Sing luwih penting, kelas abstrak bisa ngemot metode abstrak: metode khusus tanpa implementasine, kaya antarmuka. Tuladhane:

package com.javacodegeeks.advanced.design;

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

    public abstract void performAnotherAction();
}

Ing conto iki, kelas kasebut SimpleAbstractClassdiumumake minangka abstrak lan ngemot siji metode abstrak sing diumumake. Kelas abstrak migunani banget; umume utawa malah sawetara bagean saka rincian implementasine bisa dienggo bareng ing pirang-pirang subkelas. Apa wae, dheweke isih mbukak lawang lan ngidini sampeyan ngatur prilaku sing ana ing saben subkelas kanthi nggunakake metode abstrak. Perlu dicathet yen ora kaya antarmuka, sing mung bisa ngemot deklarasi umum , kelas abstrak bisa nggunakake kekuwatan aturan aksesibilitas kanggo ngontrol visibilitas metode abstrak.

6. KELAS LANGSUNG

Immutability dadi luwih penting ing pangembangan piranti lunak saiki. Peningkatan sistem multi-inti wis nyebabake akeh masalah sing ana gandhengane karo enggo bareng data lan paralelisme. Nanging siji masalah wis temtunipun njedhul: gadhah sethitik (utawa malah ora) negara mutable ndadékaké kanggo extensibility luwih (scalability) lan alesan luwih gampang babagan sistem. Sayange, basa Jawa ora nyedhiyakake dhukungan sing layak kanggo immutability kelas. Nanging, kanthi nggunakake kombinasi teknik, dadi bisa ngrancang kelas sing ora bisa diganti. Kaping pisanan, kabeh lapangan kelas kudu final (ditandhani minangka final ). Iki minangka wiwitan sing apik, nanging ora ana 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;
}

Kapindho, mesthekake initialization sing tepat: yen kolom minangka referensi kanggo koleksi utawa array, aja nemtokake kolom kasebut langsung saka argumen konstruktor, nggawe salinan. Iki bakal mesthekake yen negara koleksi utawa Uploaded ora diowahi njaba saka iku.

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 );
}

Lan pungkasane, njamin akses sing tepat (getters). Kanggo koleksi, immutability kudu disedhiyakake minangka pambungkus  Collections.unmodifiableXxx: Kanthi arrays, siji-sijine cara kanggo nyedhiyakake immutability bener yaiku nyedhiyakake salinan tinimbang ngasilake referensi menyang array. Iki bisa uga ora bisa ditampa saka sudut pandang praktis, amarga gumantung banget karo ukuran array lan bisa nyebabake tekanan gedhe ing kolektor sampah.

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

Malah conto cilik iki menehi gagasan apik yen immutability durung dadi warga kelas siji ing Jawa. Prekara bisa dadi rumit yen kelas sing ora bisa diganti duwe lapangan sing nuduhake obyek saka kelas liyane. Kelas kasebut uga kudu ora owah, nanging ora ana cara kanggo njamin iki. Ana sawetara penganalisa kode sumber Jawa sing apik, kayata FindBugs lan PMD, sing bisa mbantu kanthi mriksa kode sampeyan lan nuduhake cacat pemrograman Java sing umum. Piranti kasebut minangka kanca apik kanggo pangembang Java.

7. KELAS ANONYM

Ing jaman pra-Jawa 8, kelas anonim minangka siji-sijine cara kanggo mesthekake yen kelas ditetepake kanthi cepet lan langsung ditindakake. Tujuan kelas anonim yaiku nyuda boilerplate lan nyedhiyakake cara sing cendhak lan gampang kanggo makili kelas minangka rekaman. Ayo ndeleng cara lawas sing khas kanggo ngasilake utas anyar ing 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();
    }
}

Ing conto iki, implementasine Runnableantarmuka kasedhiya langsung minangka kelas anonim. Sanajan ana sawetara watesan sing ana gandhengane karo kelas anonim, kekurangan utama nggunakake yaiku sintaksis konstruksi sing verbose sing diwajibake basa Jawa. Malah mung kelas anonim sing ora nindakake apa-apa mbutuhake paling sethithik 5 baris kode saben ditulis.

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

Untunge, kanthi antarmuka Java 8, lambda lan fungsional, kabeh stereotip kasebut bakal ilang, pungkasane nulis kode Jawa bakal katon ringkes.

package com.javacodegeeks.advanced.design;

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

8. KAWASAN

Kita wis ngomong sethithik babagan aturan visibilitas lan aksesibilitas ing Jawa ing Bagian 1 saka tutorial. Ing bagean iki, kita bakal nliti maneh topik iki, nanging ing konteks subclassing. Visibilitas ing tingkat sing beda ngidini utawa ngalangi kelas saka ndeleng kelas utawa antarmuka liyane (contone, yen ana ing paket beda utawa nested ing saben liyane) utawa subclass saka ndeleng lan ngakses cara, konstruktor, lan lapangan tuwane. Ing bagean sabanjure, warisan, kita bakal weruh iki ing tumindak.

9. PUISI

Warisan minangka salah sawijining konsep kunci pemrograman berorientasi obyek, dadi dhasar kanggo mbangun kelas hubungan. Digabungake karo aturan visibilitas lan aksesibilitas, warisan ngidini kelas dirancang dadi hirarki sing bisa ditambah lan dijaga. Ing tingkat konseptual, warisan ing Jawa diimplementasikake nggunakake subclassing lan tembung kunci extends , bebarengan karo kelas induk. Subkelas marisi kabeh unsur umum lan dilindhungi saka kelas induk. Kajaba iku, subclass diwenehi unsur paket-pribadi saka kelas induk yen loro (subclass lan kelas) ana ing paket sing padha. Menawi mekaten, iku penting banget, ora prakara apa sampeyan nyoba kanggo ngrancang, kanggo tetep ing pesawat minimal saka cara sing kelas mbabarake publicly utawa kanggo subclasses sawijining. Contone, ayo deleng kelas Parentlan subkelas Childkanggo nduduhake bedane tingkat visibilitas lan efeke.

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 minangka topik sing gedhe banget, kanthi akeh rincian khusus kanggo Jawa. Nanging, ana sawetara aturan sing gampang dituruti lan bisa digunakake kanggo njaga ringkesan hirarki kelas. Ing Jawa, saben subkelas bisa ngganti cara sing diwarisake saka induke kajaba wis diumumake final. Nanging, ora ana sintaks utawa tembung kunci khusus kanggo menehi tandha cara minangka ditimpa, sing bisa nyebabake kebingungan. Iki sebabe anotasi @Override dienalake : saben tujuan sampeyan kanggo ngganti metode sing diwarisake, gunakake anotasi @Override kanggo nuduhake kanthi ringkes. Dilema liyane sing terus ditindakake para pangembang Jawa ing desain yaiku pambangunan hierarki kelas (kanthi kelas konkrit utawa abstrak) tinimbang implementasi antarmuka. Disaranake banget kanggo milih antarmuka tinimbang kelas utawa kelas abstrak yen bisa. Antarmuka luwih entheng, luwih gampang kanggo nyoba lan njaga, lan uga nyuda efek samping saka owah-owahan implementasine. Akeh teknik pemrograman canggih, kayata nggawe kelas proxy ing perpustakaan standar Jawa, gumantung banget marang antarmuka.

10. PUSAKA MASING-MASING

Ora kaya C ++ lan sawetara basa liyane, Jawa ora ndhukung sawetara warisan: ing Jawa, saben kelas mung bisa duwe siji induk langsung (kanthi kelas Objecting ndhuwur hirarki). Nanging, kelas bisa ngleksanakake macem-macem antarmuka, lan kanthi mangkono antarmuka numpuk minangka cara mung kanggo entuk (utawa simulasi) sawetara warisan ing Jawa.

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
    }
}

Ngleksanakake macem-macem antarmuka bener cukup kuat, nanging asring perlu kanggo nggunakake implementasine bola-bali ndadékaké kanggo hirarki kelas jero minangka cara kanggo ngatasi lack of support Jawa kanggo macem-macem warisan. 

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
    }
}

Lan sateruse... Rilis Java 8 anyar-anyar iki rada ngatasi masalah karo injeksi metode standar. Amarga cara standar, antarmuka ora mung menehi kontrak, nanging uga implementasine. Mulane, kelas sing ngleksanakake antarmuka iki uga bakal kanthi otomatis marisi cara iki dileksanakake. Tuladhane:

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
    }
}

Elinga yen pirang-pirang warisan minangka alat sing kuat, nanging ing wektu sing padha mbebayani. Masalah Diamond of Death sing kondhang asring kasebut minangka cacat utama ing implementasine pirang-pirang warisan, meksa pangembang kanggo ngrancang hierarki kelas kanthi ati-ati. Sayange, antarmuka Java 8 karo metode standar uga dadi korban cacat kasebut.

interface A {
    default void performAction() {
    }
}

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

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

Contone, snippet kode ing ngisor iki bakal gagal dikompilasi:

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

Ing titik iki, cukup kanggo ngomong yen Jawa minangka basa tansah nyoba ngindhari kasus pojok pemrograman berorientasi obyek, nanging nalika basa kasebut berkembang, sawetara kasus kasebut dumadakan wiwit katon. 

11. PUSAKA LAN KOMPOSISI

Untunge, warisan ora mung cara kanggo ngrancang kelas sampeyan. Alternatif liyane sing dipercaya akeh pangembang luwih apik tinimbang warisan yaiku komposisi. Ide iki gampang banget: tinimbang nggawe hierarki kelas, dheweke kudu kalebu kelas liyane. Ayo deleng conto iki:

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

Kelas Vehiclekasusun saka mesin lan gembong (plus akeh bagean liyane sing ditinggalake kanggo gamblang). Nanging, bisa diarani kelas Vehicleuga mesin, saengga bisa dirancang kanthi warisan. 

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

Solusi desain endi sing bener? Pedoman inti umum dikenal minangka prinsip IS-A (iku) lan HAS-A (ngemot). IS-A minangka hubungan warisan: subclass uga nyukupi spesifikasi kelas kelas induk lan variasi kelas induk. subclass) ngluwihi induke. Yen sampeyan pengin ngerti apa entitas ngluwihi liyane, apa test match - IS -A (punika)") Mulane, HAS-A minangka hubungan komposisi: kelas duwe (utawa ngemot) obyek sing Umume kasus, prinsip HAS-A luwih apik tinimbang IS-A amarga sawetara alasan: 

• Desain luwih fleksibel;
• Model luwih stabil amarga owah-owahan ora nyebar liwat hirarki kelas;
• A kelas lan komposisi sing longgar digandhengake karo komposisi, kang tightly pasangan tiyang sepah lan subclass sawijining.
• Sepur logis pamikiran ing kelas luwih prasaja, amarga kabeh dependensi kasebut kalebu ing sak panggonan. 

Ora preduli, warisan duwe papan lan ngrampungake sawetara masalah desain sing ana ing macem-macem cara, mula ora kudu dilalekake. Elinga loro alternatif kasebut nalika ngrancang model berorientasi obyek.

12. ENKAPULASI.

Konsep enkapsulasi ing pemrograman berorientasi obyek yaiku ndhelikake kabeh rincian implementasine (kaya mode operasi, metode internal, lan liya-liyane) saka jagad njaba. Keuntungan saka enkapsulasi yaiku maintainability lan gampang diganti. Implementasi internal kelas didhelikake, nggarap data kelas dumadi sacara eksklusif liwat cara umum kelas (masalah nyata yen sampeyan ngembangake perpustakaan utawa kerangka sing digunakake dening akeh wong). Enkapsulasi ing Jawa digayuh liwat aturan visibilitas lan aksesibilitas. Ing Jawa, dianggep minangka praktik paling apik kanggo ora mbukak lapangan kanthi langsung, mung liwat getter lan setter (kajaba kolom kasebut ditandhani final). Tuladhane:

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;
    }
}

Conto iki kaya sing diarani JavaBeans ing basa Jawa: kelas-kelas Jawa standar ditulis miturut sakumpulan konvensi, sing siji ngidini lapangan bisa diakses mung nggunakake metode getter lan setter. Minangka kita wis nandheske ing bagean warisan, mangga tansah netepi kontrak publisitas minimal ing kelas, nggunakake prinsip enkapsulasi. Kabeh sing ora umum kudu dadi pribadi (utawa dilindhungi / paket pribadi, gumantung saka masalah sing sampeyan rampung). Iki bakal mbayar ing roto dawa kanthi menehi kebebasan kanggo ngrancang tanpa (utawa paling nyilikake) owahan bejat. 

13. KELAS AKHIR LAN METODE

Ing Jawa, ana cara kanggo nyegah kelas dadi subclass saka kelas liyane: kelas liyane kudu diumumake final. 

package com.javacodegeeks.advanced.design;

public final class FinalClass {
}

Tembung kunci pungkasan sing padha ing deklarasi metode ngalangi subkelas kanggo ngatasi metode kasebut. 

package com.javacodegeeks.advanced.design;

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

Ora ana aturan umum kanggo mutusake apa kelas utawa metode kudu final utawa ora. Kelas lan metode pungkasan mbatesi ekstensibilitas lan angel banget kanggo mikir apa kelas kudu diwarisake utawa ora, utawa cara kudu utawa ora kudu ditindhes ing mangsa ngarep. Iki penting banget kanggo pangembang perpustakaan, amarga keputusan desain kaya iki bisa mbatesi panggunaan perpustakaan. Pustaka Standar Jawa nduweni sawetara conto kelas pungkasan, sing paling misuwur yaiku kelas String. Ing tahap awal, keputusan iki digawe kanggo nyegah upaya pangembang kanggo nggawe solusi sing "luwih apik" kanggo ngetrapake string. 

14. APA SABAJE

Wonten ing piwulang menika, kita ngrembag babagan konsep pemrograman berorientasi objek ing basa Jawi. Kita uga njupuk dipikir cepet ing program kontrak, ndemek sawetara konsep fungsi lan ndeleng carane basa wis ngalami évolusi saka wektu. Ing bagean sabanjure saka pawulangan, kita bakal ketemu generik lan carane ngganti cara kita pendekatan safety jinis ing program. 

15. UNDUH KODE SUMBER

Sampeyan bisa ngundhuh sumber ing kene - advanced-java-part-3 Source: How to design Classes an