Apakah metode beton utama menimpa bau kode?

Benarkah metode konkret yang utama adalah bau kode? Karena saya pikir jika Anda perlu mengganti metode konkret:

public class A{
    public void a(){
    }
}

public class B extends A{
    @Override
    public void a(){
    }
}

dapat ditulis ulang sebagai

public interface A{
    public void a();
}

public class ConcreteA implements A{
    public void a();
}

public class B implements A{
    public void a(){
    }
}

dan jika B ingin menggunakan kembali a () dalam A dapat ditulis ulang sebagai:

public class B implements A{
    public ConcreteA concreteA;
    public void a(){
        concreteA.a();
    }
}

yang tidak memerlukan warisan untuk mengganti metode, apakah itu benar?

Tidak, ini bukan bau kode.

• Jika kelas tidak final, ini memungkinkan untuk disubklasifikasikan.
• Jika suatu metode tidak final, ini memungkinkan untuk diganti.

Itu terletak dalam tanggung jawab masing-masing kelas untuk mempertimbangkan dengan hati-hati jika subklasifikasi sesuai, dan metode mana yang mungkin ditimpa .

Kelas dapat mendefinisikan dirinya sendiri atau metode apa pun sebagai final, atau dapat menempatkan batasan (pengubah visibilitas, konstruktor yang tersedia) tentang bagaimana dan di mana subkelasnya.

Kasus umum untuk metode utama adalah implementasi default di kelas dasar yang dapat dikustomisasi atau dioptimalkan dalam subkelas (terutama di Java 8 dengan munculnya metode default di antarmuka).

class A {
    public String getDescription(Element e) {
        // return default description for element
    }
}

class B extends A {
    public String getDescription(Element e) {
        // return customized description for element
    }
}

Sebuah alternatif untuk override perilaku adalah Pola Strategi , dimana perilaku tersebut disarikan sebagai interface, dan pelaksanaannya dapat diatur di kelas.

interface DescriptionProvider {
    String getDescription(Element e);
}

class A {
    private DescriptionProvider provider=new DefaultDescriptionProvider();

    public final String getDescription(Element e) {
       return provider.getDescription(e);
    }

    public final void setDescriptionProvider(@NotNull DescriptionProvider provider) {
        this.provider=provider;
    }
}

class B extends A {
    public B() {
        setDescriptionProvider(new CustomDescriptionProvider());
    }
}

Benarkah metode konkret yang utama adalah bau kode?

Ya, secara umum, metode beton utama adalah bau kode.

Karena metode dasar memiliki perilaku yang dikaitkan dengan itu yang biasanya dihormati pengembang, perubahan itu akan mengarah ke bug ketika implementasi Anda melakukan sesuatu yang berbeda. Lebih buruk lagi, jika mereka mengubah perilaku, implementasi Anda yang sebelumnya benar dapat memperburuk masalah. Dan secara umum, cukup sulit untuk menghormati Prinsip Substitusi Liskov untuk metode konkret non-sepele.

Sekarang, ada beberapa kasus di mana ini bisa dilakukan dan bagus. Metode semi-sepele dapat dikendarai agak aman. Metode dasar yang ada hanya sebagai jenis perilaku "waras standar" yang dimaksudkan untuk ditunggangi memiliki kegunaan yang baik.

Oleh karena itu, ini sepertinya bau bagi saya - kadang-kadang baik, biasanya buruk, lihatlah untuk memastikan.

jika Anda perlu mengganti metode konkret [...] itu dapat ditulis ulang sebagai

Jika itu dapat ditulis ulang dengan cara itu berarti Anda memiliki kendali atas kedua kelas. Tetapi kemudian Anda tahu apakah Anda mendesain kelas A agar diturunkan dengan cara ini dan jika Anda melakukannya, itu bukan bau kode.

Sebaliknya, jika Anda tidak memiliki kendali atas kelas dasar, Anda tidak dapat menulis ulang dengan cara itu. Jadi, apakah kelas itu dirancang untuk diturunkan dengan cara ini, dalam hal ini lanjut saja, itu bukan bau kode, atau tidak, dalam hal ini Anda memiliki dua opsi: mencari solusi lain sama sekali, atau lanjutkan saja , karena kemurnian kerja desain truf.

Pertama, izinkan saya menunjukkan bahwa pertanyaan ini hanya berlaku di sistem pengetikan tertentu. Misalnya, dalam pengetikan Struktural dan sistem pengetikan Bebek - suatu kelas yang hanya memiliki metode dengan nama & tanda tangan yang sama akan berarti bahwa kelas itu kompatibel dengan jenis (setidaknya untuk metode tertentu, dalam kasus pengetikan Bebek).

Ini (jelas) sangat berbeda dari ranah bahasa yang diketik secara statis , seperti Java, C ++, dll. Serta sifat pengetikan yang Kuat , seperti yang digunakan dalam Java & C ++, serta C # dan lainnya.

Saya menduga Anda berasal dari latar belakang Java, di mana metode harus secara eksplisit ditandai sebagai final jika perancang kontrak bermaksud agar mereka tidak diganti. Namun, dalam bahasa seperti C #, kebalikannya adalah default. Metode (tanpa dekorasi, kata kunci khusus) " disegel " (versi C # final), dan harus dinyatakan secara eksplisit seolah- virtualolah diizinkan untuk diganti.

Jika API atau pustaka telah dirancang dalam bahasa-bahasa ini dengan metode konkret yang dapat ditimpa, maka harus (setidaknya dalam beberapa kasus) masuk akal untuk ditimpa. Oleh karena itu, ini bukan bau kode untuk menggantikan metode unsealed / virtual / not finalconcrete.     _{(Ini tentu saja mengasumsikan bahwa perancang API mengikuti konvensi dan menandai virtual(C #), atau menandai sebagai final(Java) metode yang sesuai untuk apa yang mereka desain.)}

Lihat juga

• Sistem tipe struktural
• Mengetik bebek
• Pengetikan statis
• Mengetik dengan kuat
• Prinsip substitusi Liskov

Ya itu karena dapat menyebabkan panggilan super anti-pola Itu juga dapat menghilangkan tujuan awal metode ini, memperkenalkan efek samping (=> bug) dan membuat tes gagal. Apakah Anda akan menggunakan kelas yang tes unitnya merah (failling)? Saya tidak akan.

Saya akan melangkah lebih jauh dengan mengatakan, bau kode awal adalah ketika suatu metode tidak abstractatau tidak final. Karena memungkinkan untuk mengubah (dengan mengesampingkan) perilaku entitas yang dibangun (perilaku ini dapat hilang atau diubah). Dengan abstractdan finalmaksudnya tidak ambigu:

• Abstrak: Anda harus memberikan perilaku
• Final: Anda tidak diizinkan mengubah perilaku

Cara paling aman untuk menambahkan perilaku ke kelas yang ada adalah apa yang ditunjukkan oleh contoh terakhir Anda: menggunakan pola dekorator.

public interface A{
    void a();
}

public final class ConcreteA implements A{
    public void a() {
        ...
    }
}

public final class B implements A{
    private final ConcreteA concreteA;
    public void a(){
        //Additionnal behaviour
        concreteA.a();
    }
}