DonanımHaber

clean code etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
clean code etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

In clean code, although we have meaningful names, are there cases that we still need comments?



Yes, even in clean code where meaningful names are used, there are still cases where comments are necessary and beneficial. Here are a few scenarios where comments are important:

Complex Logic: If the code involves complex algorithms or logic that is not immediately obvious, comments can provide clarity. This helps other developers understand the rationale behind certain decisions or the approach taken.

Workarounds and Temporary Fixes: Sometimes code may include workarounds or temporary fixes for bugs or issues. Comments in such cases are crucial to explain why this non-standard approach was necessary and under what conditions it can or should be changed or removed.

References to External Resources: If the code is based on or related to external documentation, standards, or resources (like a specific RFC or a research paper), including a comment with the reference can be very helpful for future understanding and maintenance.

Intent and Context: While good naming conveys what the code is doing, it may not always convey why it is doing it. Comments can be used to describe the intent behind a block of code, especially when the 'why' is not immediately obvious from the code itself.

TODOs and FIXMEs: Comments are often used to mark areas of the code that need future attention, like optimizations, enhancements, or areas where a more robust solution is needed.

Non-Obvious Consequences or Implications: Sometimes, a piece of code might have side effects or implications that are not immediately apparent. A comment can be helpful to warn future maintainers of these consequences.

Code Generation: In cases where code is automatically generated, comments can be used to indicate that the code should not be modified manually, or to explain how to update the generated code.

Remember, the key to effective commenting is to provide useful information that is not readily apparent from the code itself. Over-commenting, or stating the obvious, can clutter the code and reduce readability. The goal should always be to write clear, self-explanatory code as much as possible, using comments judiciously to enhance understanding where necessary.

28 Maddede Java ile Clean Code

Java kodları kullanarak Clean Code kavramlarını maddeler halinde açıklamaya başlayacağım. Her maddeyi kod örneği, açıklama, sebep ve çözümü içerecek şekilde detaylandıracağım. İşte ilk madde:



1. Anlamlı İsimler Kullanın

Kod Örneği:


java

Copy code

// Kötü İsimlendirme

int d; // geçen günlerin sayısı


// İyi İsimlendirme

int passedDays;

Açıklama:

Değişken, fonksiyon ve sınıf isimleri anlamlı ve açık olmalıdır. İsimler, niyeti açıkça ifade etmeli ve kodun okunabilirliğini artırmalıdır.


Sebep:

Anlamsız veya kısa isimler, kodun amacını ve işleyişini anlamayı zorlaştırır.


Çözüm:

Her değişken, fonksiyon veya sınıf için, işlevini ve kullanım amacını net bir şekilde yansıtan isimler seçin.


2. Fonksiyonlar Kısa ve Odaklı Olmalı

Kod Örneği:


java

Copy code

// Kötü Uygulama

public void processUserInputAndSave() {

    // kullanıcı girdisini işleme

    // veritabanına kaydetme

}


// İyi Uygulama

public void processUserInput() {

    // kullanıcı girdisini işleme

}


public void saveInputData() {

    // veritabanına kaydetme

}

Açıklama:

Fonksiyonlar tek bir iş yapmalı ve bu işi en iyi şekilde yapmalıdır. Karmaşık fonksiyonlar, birden fazla işi bir arada yapmaya çalışırsa, anlaşılması ve bakımı zorlaşır.


Sebep:

Çok işlevli fonksiyonlar, kodun okunabilirliğini azaltır ve hata yapma riskini artırır.


Çözüm:

Her fonksiyonu, yalnızca bir görevi yerine getirecek şekilde tasarlayın. Bu, kodun daha temiz, anlaşılır ve bakımı kolay olmasını sağlar.


3. Yorumlardan Kaçının; Kodunuz Konuşsun

Kod Örneği:


java

Copy code

// Kötü Uygulama

// Eğer kullanıcı giriş yapmışsa, bilgilerini güncelle

if (user.isLoggedIn()) {

    // ...

}


// İyi Uygulama

if (isUserLoggedIn(user)) {

    // ...

}


private boolean isUserLoggedIn(User user) {

    return user.isLoggedIn();

}

Açıklama:

Kodun kendisi ne yaptığını açıkça ifade etmeli ve yorumlar mümkün olduğunca azaltılmalıdır. İyi yazılmış bir kod, yorumlara gereksinim duymaz.


Sebep:

Aşırı yorum kullanımı, kodun anlaşılabilirliğini azaltabilir ve gerçek işlevselliği maskeleyebilir.


Çözüm:

Kodun okunabilirliğini ve anlaşılırlığını artıracak şekilde isimlendirme ve fonksiyon ayrımı yapın. Yorumlar yerine, kodun kendisinin açıklayıcı olmasını sağlayın.


4. Hata Yönetimini Kodun Ana Akışından Ayırın

Kod Örneği:


java

Copy code

// Kötü Uygulama

public void processData() {

    try {

        // veri işleme

    } catch (Exception e) {

        // hata yönetimi

    }

}


// İyi Uygulama

public void processData() {

    try {

        // veri işleme

    } catch (Exception e) {

        handleException(e);

    }

}


private void handleException(Exception e) {

    // hata yönetimi

}

Açıklama:

Hata yönetimi, iş mantığının bir parçası olmamalıdır. Bu, kodun okunabilirliğini ve sürdürülebilirliğini artırır.


Sebep:

İş mantığı ile hata yönetiminin bir arada olması, her ikisini de anlamayı ve yönetmeyi zorlaştırır.


Çözüm:

Hata yönetimini ayrı bir metodda yaparak, ana iş akışınızın daha temiz ve anlaşılır olmasını sağlayın.


5. Tekrarlanan Kodlardan Kaçının (DRY - Don't Repeat Yourself)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public void calculateBonusForSalesDepartment() {

    // satış departmanı için bonus hesaplama

}


public void calculateBonusForHRDepartment() {

    // insan kaynakları departmanı için bonus hesaplama

    // (satış departmanı için yapılan hesaplamanın aynısı)

}


// İyi Uygulama

public void calculateBonusForDepartment(Department department) {

    // departman için bonus hesaplama

}

Açıklama:

Tekrarlanan kod, hata yapma riskini artırır ve kod tabanını gereksiz yere şişirir. Ortak işlevselliği, yeniden kullanılabilir metodlarla merkezileştirmek, kodun bakımını ve anlaşılırlığını artırır.


Sebep:

Tekrarlanan kod, değişiklik yapmayı zorlaştırır ve kodun tutarlılığını bozar.


Çözüm:

Ortak işlevselliği genel metodlar halinde organize ederek, kodun yeniden kullanılabilirliğini ve sürdürülebilirliğini artırın.


6. Küçük ve Anlaşılır Sınıflar ve Metodlar Oluşturun

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class UserManager {

    public void createUser() { /* kullanıcı oluşturma işlemleri */ }

    public void updateUser() { /* kullanıcı güncelleme işlemleri */ }

    // Diğer kullanıcı işlemleri...

}


// İyi Uygulama

public class UserCreator {

    public void create() { /* kullanıcı oluşturma işlemleri */ }

}


public class UserUpdater {

    public void update() { /* kullanıcı güncelleme işlemleri */ }

}

Açıklama:

Sınıflar ve metodlar, belirli bir işlevsellik veya sorumluluk etrafında odaklanmalıdır. Bu, kodun anlaşılabilirliğini ve bakımını kolaylaştırır.


Sebep:

Çok fazla sorumluluğu olan büyük sınıflar ve metodlar, karmaşık hale gelir ve değişiklik yapmayı zorlaştırır.


Çözüm:

Sorumlulukları daha küçük, odaklanmış sınıflar ve metodlar arasında bölerek kodun yönetilebilirliğini ve anlaşılırlığını artırın.


7. Bağımlılıkları Minimize Edin

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class OrderProcessor {

    private Database database;

    public OrderProcessor(Database db) {

        this.database = db;

    }

    // Sipariş işleme kodları

}


// İyi Uygulama

public class OrderProcessor {

    private IDatabase database;

    public OrderProcessor(IDatabase db) {

        this.database = db;

    }

    // Sipariş işleme kodları

}

Açıklama:

Sınıflar arası bağımlılıklar, mümkün olduğunca azaltılmalıdır. Bu, test edilebilirliği artırır ve kodun esnekliğini sağlar.


Sebep:

Yüksek bağımlılıklar, kodun değişikliklere adapte olmasını zorlaştırır ve test sürecini karmaşıklaştırır.


Çözüm:

Arayüzler ve bağımlılık enjeksiyonu gibi teknikler kullanarak, sınıfların birbirine olan bağımlılıklarını azaltın.


8. Yüksek Okunabilirlik için Kod Formatlama Standartlarına Uyun

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class User{public void create(){//...}public void delete(){//...}}


// İyi Uygulama

public class User {

    public void create() {

        // ...

    }


    public void delete() {

        // ...

    }

}

Açıklama:

Tutarlı kod formatlaması, kodun anlaşılmasını ve takım içinde işbirliğini kolaylaştırır.


Sebep:

Düzensiz ve standartlara uymayan kod formatlaması, kodun okunabilirliğini ve bakımını zorlaştırır.


Çözüm:

Bir kod formatlama standardı belirleyin ve tüm kod tabanında bu standardı uygulayın. Bu, kodun daha düzenli ve anlaşılır olmasını sağlar.


9. Yüksek Bağlam İçeren İsimlendirme Kullanın

Kod Örneği:


java

Copy code

// Kötü Uygulama

int d; // belirsiz

String n; // ne anlama geldiği net değil


// İyi Uygulama

int elapsedTimeInDays;

String customerName;

Açıklama:

Değişken, fonksiyon ve sınıf isimleri, içerdikleri bağlamı yansıtmalıdır. Bu, kodun anlamını ve niyetini daha net hale getirir.


Sebep:

Belirsiz veya genel isimlendirmeler, kodun ne yaptığını anlamayı zorlaştırır.


Çözüm:

Değişken, fonksiyon ve sınıf isimlerinde, onların kullanım amacını ve işlevselliğini açıkça yansıtacak terimler seçin.


10. Global Değişkenlerden Kaçının

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class Application {

    public static int globalCount; // global değişken

    // ...

}


// İyi Uygulama

public class Application {

    private int instanceCount; // sınıf içinde kapsüllenmiş

    // ...

}

Açıklama:

Global değişkenler, kodun tahmin edilebilirliğini ve güvenliğini azaltır. Ayrıca, yan etkilere ve hata yapma riskine neden olur.


Sebep:

Global değişkenler, kodun farklı bölümleri arasında kontrolsüz erişim ve değişikliklere yol açabilir.


Çözüm:

Değişkenleri, ihtiyaç duyulan en dar kapsamda tanımlayın. Sınıf veya fonksiyon seviyesinde kapsüllenmiş değişkenleri kullanın.


11. Sihirli Sayılar ve Stringlerden Kaçının

Kod Örneği:


java

Copy code

// Kötü Uygulama

if (userType == 1) {

    // ...

}


// İyi Uygulama

final int ADMIN_USER = 1;

if (userType == ADMIN_USER) {

    // ...

}

Açıklama:

Kodunuzda anlamı belirsiz sayılar ve stringler kullanmaktan kaçının. Bunlar, kodun anlaşılabilirliğini azaltır ve hatalara yol açabilir.


Sebep:

"Sihirli" sayılar ve stringler, kodun okunabilirliğini düşürür ve değişiklik yapmayı zorlaştırır.


Çözüm:

Anlamı belirsiz sayıları ve stringleri anlamlı sabitlerle değiştirin. Bu, kodunuzun daha okunabilir ve bakımının daha kolay olmasını sağlar.


12. Erken Dönüş Prensibi (Early Return)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public void processUser(User user) {

    if (user.isValid()) {

        // geçerli kullanıcı işlemleri

    }

}


// İyi Uygulama

public void processUser(User user) {

    if (!user.isValid()) {

        return;

    }

    // geçerli kullanıcı işlemleri

}

Açıklama:

Fonksiyonlarda, olumsuz veya beklenmeyen durumlar için erken dönüş yapmak, kodun okunabilirliğini ve anlaşılırlığını artırır.


Sebep:

Derin iç içe geçmiş yapılar ve koşullar, kodun anlaşılmasını ve bakımını zorlaştırır.


Çözüm:

Olumsuz veya beklenmeyen durumlarda hemen dönüş yaparak, kodun daha düz ve okunabilir olmasını sağlayın.


13. Uzun Metod Zincirlerinden Kaçının (Law of Demeter)

Kod Örneği:


java

Copy code

// Kötü Uygulama

String cityName = user.getAddress().getCity().getName();


// İyi Uygulama

String cityName = user.getCityName();

Açıklama:

Bir nesnenin başka nesneler üzerinden çok sayıda metod çağırması, kodun bağımlılıklarını ve karmaşıklığını artırır.


Sebep:

Uzun metod zincirleri, kodun bakımını ve değişiklikleri zorlaştırır, ayrıca sınıflar arası bağımlılıkları artırır.


Çözüm:

Nesnelerin birbirlerinin ayrıntılarına doğrudan erişimini sınırlandırarak ve gerekli verileri daha basit arayüzlerle sağlayarak kodun bağımlılığını ve karmaşıklığını azaltın.


14. Ölçeklenebilirlik ve Esneklik İçin Tasarlayın

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class FixedSizeArray {

    private int[] array = new int[10];

    // ...

}


// İyi Uygulama

public class DynamicArray {

    private List<Integer> array = new ArrayList<>();

    // ...

}

Açıklama:

Kodunuzu, gelecekteki değişikliklere ve genişlemelere uyum sağlayacak şekilde tasarlayın. Esnek ve ölçeklenebilir yapılar, uzun vadede daha sürdürülebilir ve bakımı daha kolaydır.


Sebep:

Sabit veya sınırlı yapılar, gelecekteki ihtiyaçlara uyum sağlamakta zorluk çeker ve değişiklik gerektiğinde daha fazla iş yüküne neden olur.


Çözüm:

Esnek ve genişleyebilir yapılar kullanarak, kodunuzun gelecekteki gereksinimlere daha kolay uyum sağlamasını sağlayın.


15. Tekrarlanan Kodları Fonksiyonlarla Soyutlayın

Kod Örneği:


java

Copy code

// Kötü Uygulama

if (condition) {

    // 5 satır kod

}

if (anotherCondition) {

    // Aynı 5 satır kod

}


// İyi Uygulama

private void reusableMethod() {

    // 5 satır kod

}


if (condition) {

    reusableMethod();

}

if (anotherCondition) {

    reusableMethod();

}

Açıklama:

Tekrarlanan kod bloklarını, yeniden kullanılabilir fonksiyonlar veya metodlar haline getirin. Bu, kodun temizliğini ve bakımını kolaylaştırır.


Sebep:

Tekrarlanan kod blokları, hatalara açık olabilir ve kodun bakımını zorlaştırır.


Çözüm:

Tekrarlanan kod parçalarını soyutlayarak, kodun yeniden kullanılabilirliğini ve tutarlılığını artırın.


16. Kapsülleme Prensibine Uyun

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class User {

    public String name;

    public int age;

}


// İyi Uygulama

public class User {

    private String name;

    private int age;


    public String getName() {

        return name;

    }


    public void setName(String name) {

        this.name = name;

    }


    public int getAge() {

        return age;

    }


    public void setAge(int age) {

        this.age = age;

    }

}

Açıklama:

Kapsülleme, nesne değişkenlerini dış dünyadan gizleyerek ve yalnızca belirli metodlar aracılığıyla erişilebilir hale getirerek, nesnenin iç durumunu korur.


Sebep:

Doğrudan erişilebilir public alanlar, nesnenin iç durumunu kontrolsüz ve güvenli olmayan bir şekilde değiştirilmesine yol açabilir.


Çözüm:

Sınıf üyelerini private yaparak ve public getter/setter metodları ile erişimi kontrol ederek, nesnelerin daha güvenli ve kontrollü bir şekilde kullanılmasını sağlayın.


17. Tutarlı Hata Yönetimi Stratejisi Geliştirin

Kod Örneği:


java

Copy code

// Kötü Uygulama

public void readFile(String path) {

    try {

        // dosya okuma işlemleri

    } catch (IOException e) {

        e.printStackTrace();

    }

}


// İyi Uygulama

public void readFile(String path) throws IOException {

    // dosya okuma işlemleri

}

Açıklama:

Hata yönetimi, uygulamanın genelinde tutarlı ve öngörülebilir olmalıdır. Hataların uygun şekilde ele alınması, uygulamanın dayanıklılığını ve güvenilirliğini artırır.


Sebep:

Farklı hata yönetimi yaklaşımları, kodun karmaşıklığını artırır ve hataların doğru şekilde ele alınmasını zorlaştırır.


Çözüm:

Uygulamanın genelinde tutarlı bir hata yönetimi stratejisi benimseyin. Gerekirse, hataları yukarıya iletin ve merkezi bir yerde ele alın.


18. Yüksek Seviye Modüller, Alt Seviye Modüllere Bağlı Olmamalı (Dependency Inversion Principle)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class DataProcessor {

    private MySQLDatabase database;


    public DataProcessor(MySQLDatabase database) {

        this.database = database;

    }

    // Veri işleme işlemleri

}


// İyi Uygulama

public class DataProcessor {

    private IDatabase database;


    public DataProcessor(IDatabase database) {

        this.database = database;

    }

    // Veri işleme işlemleri

}

Açıklama:

Yüksek seviye modüller, alt seviye modüllerin somut sınıflarına değil, soyutlamalarına (arayüzler, abstract sınıflar) bağlı olmalıdır. Bu, modüller arasındaki bağımlılığı azaltır ve sistem mimarisinin daha esnek olmasını sağlar.


Sebep:

Alt seviye modüllerin somut sınıflarına doğrudan bağımlılık, modüller arasında sıkı bağlar oluşturur ve değişiklikleri zorlaştırır.


Çözüm:

Arayüzler ve soyut sınıflar kullanarak, yüksek seviye modüllerin alt seviye modüllere olan bağımlılığını tersine çevirin. Bu, modüllerin birbirinden bağımsız geliştirilmesini ve test edilmesini kolaylaştırır.


19. Yinelemeli Tasarım ve Refaktoring

Kod Örneği:


java

Copy code

// İlk Tasarım

public class ReportGenerator {

    public String generateReport(Data data) {

        // rapor oluşturma

    }

}


// Refaktoring Sonrası

public class ReportGenerator {

    public String generateReport(Data data) {

        Report report = prepareReport(data);

        return formatReport(report);

    }


    private Report prepareReport(Data data) {

        // rapor hazırlama

    }


    private String formatReport(Report report) {

        // rapor formatlama

    }

}

Açıklama:

Kodunuzun yinelemeli olarak tasarlanması ve sürekli refaktoring yapılması, daha temiz, anlaşılır ve sürdürülebilir bir kod tabanı oluşturur.


Sebep:

İlk seferde mükemmel kod yazmak nadiren mümkündür. Zamanla, kodunuzun eksikliklerini ve iyileştirme fırsatlarını göreceksiniz.


Çözüm:

Kodunuzu düzenli olarak gözden geçirin ve iyileştirmeler yapın. Fonksiyonları daha küçük ve yönetilebilir parçalara ayırın, gereksiz karmaşıklıkları ortadan kaldırın.


20. Test Odaklı Geliştirme (TDD)

Kod Örneği:


java

Copy code

// Test öncelikli yaklaşım

public class CalculatorTest {

    @Test

    public void testAdd() {

        Calculator calc = new Calculator();

        assertEquals(5, calc.add(2, 3));

    }

}


public class Calculator {

    public int add(int a, int b) {

        // toplama işlemi

    }

}

Açıklama:

Test odaklı geliştirme (TDD), önce testlerin yazılmasını ve ardından bu testleri geçecek kodun yazılmasını içerir. Bu yaklaşım, daha sağlam ve hatasız kod yazılmasını sağlar.


Sebep:

Önce kod yazmak ve sonra test etmek, bazı hataların gözden kaçmasına yol açabilir.


Çözüm:

Önce testleri yazın ve bu testlere uyan kodu geliştirin. Bu, kodunuzun baştan itibaren daha güvenilir ve test edilebilir olmasını sağlar.


21. Yalın Kod (KISS - Keep It Simple, Stupid)

Kod Örneği:


java

Copy code

// Karmaşık Kod

public String complexLogic() {

    // karmaşık ve anlaşılması zor kod

}


// Basit Kod

public String simpleLogic() {

    // basit ve anlaşılır kod

}

Açıklama:

Kodunuzu mümkün olduğunca basit ve anlaşılır tutun. Karmaşıklıktan kaçınmak, kodunuzun okunabilirliğini ve bakımını kolaylaştırır.


Sebep:

Gereksiz karmaşıklık, kodun anlaşılmasını ve bakımını zorlaştırır, hata yapma olasılığını artırır.


Çözüm:

Kodunuzu basitleştirin ve gereksiz karmaşıklıklardan kaçının. Basit çözümler genellikle en iyisidir.


22. Modüler Kod Yazın

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class UserProcessor {

    public void processUser(User user) {

        // Kullanıcı işleme kodları

        // Veritabanı işlemleri

        // Ağ işlemleri

    }

}


// İyi Uygulama

public class UserProcessor {

    private DatabaseService dbService;

    private NetworkService networkService;


    public UserProcessor(DatabaseService dbService, NetworkService networkService) {

        this.dbService = dbService;

        this.networkService = networkService;

    }


    public void processUser(User user) {

        // Kullanıcı işleme kodları

        dbService.saveUser(user);

        networkService.sendUserData(user);

    }

}

Açıklama:

Kodunuzu modüler yapın, böylece her modül belirli bir görevi yerine getirir. Bu, kodun anlaşılabilirliğini ve bakımını kolaylaştırır, yeniden kullanılabilirliği artırır.


Sebep:

Tek bir devasa fonksiyon veya sınıf, anlaşılması zor olabilir ve birden fazla sorumluluk taşır.


Çözüm:

Fonksiyonları ve sınıfları, belirli görevleri yerine getirecek şekilde ayırarak kodun modülerliğini ve esnekliğini artırın.


23. Sabitler ve Yapılandırma Dosyaları Kullanın

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class Server {

    public void start() {

        connectTo("192.168.1.1", 8080);

    }

}


// İyi Uygulama

public class Server {

    private static final String HOST = "192.168.1.1";

    private static final int PORT = 8080;


    public void start() {

        connectTo(HOST, PORT);

    }

}

Açıklama:

Yapılandırma verilerini ve sabit değerleri kodun içinden ayırarak, değişiklikleri ve yönetimi kolaylaştırın.


Sebep:

Sabit olmayan değerlerin kod içinde sert-kodlanması, değişikliklerin zor olmasına ve hatalara neden olabilir.


Çözüm:

Yapılandırma verilerini ve sabitleri ayrı dosyalarda veya kodun başında tanımlayarak, kodun esnekliğini ve bakımını kolaylaştırın.


24. İyi Düşünülmüş Hata Mesajları Kullanın

Kod Örneği:


java

Copy code

// Kötü Uygulama

throw new Exception("Hata oluştu");


// İyi Uygulama

throw new Exception("Veritabanı bağlantısı kurulamadı: [Detaylı hata mesajı]");

Açıklama:

Kullanıcıya veya geliştiriciye sunulan hata mesajları, problemi net bir şekilde tanımlamalı ve mümkünse çözüm yolları sunmalıdır.


Sebep:

Belirsiz hata mesajları, problemin kaynağını bulmayı ve çözüm üretmeyi zorlaştırır.


Çözüm:

Hata mesajlarını açık ve anlaşılır yaparak, hata ayıklama sürecini kolaylaştırın ve hataların daha hızlı çözülmesini sağlayın.


25. Kod İçi Belgelendirmeyi İhmal Etmeyin (Javadoc Kullanımı)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public void processData() {

    // Veri işleme

}


// İyi Uygulama

/**

 * Verilen veriyi işler ve sonucu döndürür.

 * @param data İşlenecek veri

 * @return İşlenmiş veri sonucu

 */

public DataResult processData(Data data) {

    // Veri işleme

}

Açıklama:

Metodlarınızın ve sınıflarınızın ne yaptığını açıkça belirten dokümantasyon yorumları ekleyin. Bu, kodunuzun daha anlaşılır ve kullanılabilir olmasını sağlar.


Sebep:

Yorum ve belgelerin eksikliği, kodun anlaşılmasını ve kullanılmasını zorlaştırabilir.


Çözüm:

Javadoc gibi belgelendirme araçlarını kullanarak, metodların ve sınıfların işlevselliğini, parametrelerini ve dönüş değerlerini açıkça belirtin.


26. Kodunuzda Esneklik ve Genişletilebilirlik Sağlayın (Open/Closed Principle)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class ReportGenerator {

    public void generateReport(Data data) {

        // rapor oluşturma

    }

}


// İyi Uygulama

public abstract class ReportGenerator {

    public abstract void generateReport(Data data);

}


public class SalesReportGenerator extends ReportGenerator {

    @Override

    public void generateReport(Data data) {

        // satış raporu oluşturma

    }

}

Açıklama:

Sınıflarınızı ve metodlarınızı, yeni özellikler eklenirken mevcut kodu değiştirmek zorunda kalmadan genişletebilecek şekilde tasarlayın.


Sebep:

Mevcut kodun sık sık değiştirilmesi, hatalara ve entegrasyon sorunlarına yol açabilir.


Çözüm:

Soyutlamalar ve kalıtım kullanarak, mevcut kodu değiştirmeden yeni özellikler ekleyebilir hale getirin. Bu prensip, kodunuzun esnekliğini ve genişletilebilirliğini artırır.


27. Tek Sorumluluk Prensibi (Single Responsibility Principle)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class User {

    public void createUser() { /* Kullanıcı oluşturma */ }

    public void sendEmail() { /* E-posta gönderme */ }

}


// İyi Uygulama

public class User {

    public void createUser() { /* Kullanıcı oluşturma */ }

}


public class EmailService {

    public void sendEmail() { /* E-posta gönderme */ }

}

Açıklama:

Her sınıf ve metod, yalnızca bir sorumluluğa sahip olmalıdır. Bu, kodun anlaşılabilirliğini artırır ve bakımını kolaylaştırır.


Sebep:

Birden fazla sorumluluğu olan sınıflar ve metodlar, değişiklik yapmayı ve kodu anlamayı zorlaştırır.


Çözüm:

Her sınıfı ve metodu, yalnızca bir görevi yerine getirecek şekilde tasarlayarak, kodunuzun anlaşılabilirliğini ve yönetilebilirliğini artırın.


28. İşlevsellik ve Veriyi Ayırın (Separation of Concerns)

Kod Örneği:


java

Copy code

// Kötü Uygulama

public class User {

    private String name;

    public void saveUser() { /* Kullanıcıyı kaydetme */ }

}


// İyi Uygulama

public class User {

    private String name;

}


public class UserService {

    public void saveUser(User user) { /* Kullanıcıyı kaydetme */ }

}

Açıklama:

İşlevselliği ve veriyi birbirinden ayırarak, her birinin bağımsız olarak geliştirilmesini, test edilmesini ve bakımını sağlayın.


Sebep:

İşlevsellik ve verinin bir arada bulunması, kodun karmaşık ve yönetilmesi zor hale gelmesine neden olabilir.


Çözüm:

İşlevsel kodları ve veri modellerini ayrı sınıflar veya modüller içinde tutarak, kodun temizliğini ve yönetilebilirliğini artırın.

Aggressive Refactoring by Victor Rentea

 




#refactoring #cleancode #intellij
To import it go to Settings> Editor> Inspections> Profile> Settings> Import

Xml Dosyasını buradan indirebilirisniz.





Clean Code ve Effective Java Dersleri - Udemy - Furkan Sönmez - Türkçe

 Clean Code ve Effective Java kitaplarını işleyen Furkan Sönmez konuya hakim ve bol örneklerle konunun anlaşılmasını kolaylaştıryor.






İleri/Orta Seviye Java Dersleri - (Effective Java)

Kursa buradan ulaşabilirsiniz.

Sürekli güncellenen ileri orta seviye effective java eğitimiyle bilginizi ve java mülakat performansınızı katlayın!
Java teknik mülakat geçme garantisi :)Design Pattern ezberi yapmadan sorunları patterne dökebilme yeteneği.Temiz, doğru, esnek ve bakımı kolay uygulamalar tasarlayabilme yeteneği.İş arkadaşlarınızın okurken zorlanmayacağı ve insanların kolay adapte olabileceği tasarımlar yapmak.Ezbere değil farkında olarak kod yazma yetisi.Effective Java kitabının en ince detayına kadar tüm içeriği.


Clean Code - Temiz Kod Yazma Sanatı

Piyasanın en etkin clean code eğitimi. Kurstan sonra bir daha asla aynı kodu yazmayacaksınız. (Güncel Bonus İçeriklerle)

Kursa buradan ulaşabilirsiniz.

Kaliteli ve okunabilir kod yazma
Metotları ve sınıfları optimum uzunlukta tutma
SOLID prensipleri (Detaylı örneklerle)
Test yazmanın önemi ve mentalitesi
Kod refaktör etme
Temel Yazılım Prensipleri
Kurs dil spesifik değil ama Java Püf noktalarına sıkça değindik :)
Yük Testlerinin Önemi
Mülakat Performansında Gözle Görülür Artış
Kod yazan normal bir bireyden ziyade MÜHENDİS kafasıyla yazılım yapma





Canburak Tümer - Yazılımda Kırık Camlar Teorisi

Canburak Tümer - Yazılımda Kırık Camlar Teorisi adlı makalesini aşağıdaki linkten okuyabilirsiniz.

https://medium.com/@canburaktumer/yaz%C4%B1l%C4%B1mda-k%C4%B1r%C4%B1k-camlar-625d7f676cab
Kırık Camlar teorisi wikipedia alıntısı :

"Birkaç kırık penceresi olan bir bina düşünün. Camlar tamir edilmemişse vandallar birkaç cam daha kırmaya meyillidir. Sonunda bina boş ise tüm camları kırılabilir, gecekonduysa belki de yangın dahi çıkarabilirler. Ya da bir kaldırım düşünün. Burada bazı çöpler birikir. Yakın zamanda bu çöpler daha fazla birikir. Sonunda buradaki restoranlar, hatta paket servis yapan insanlar bile çöpleri araba ile poşetler halinde getirerek buraya atarlar."



 




Rastgele İçerik

© tüm hakları saklıdır
made with by templateszoo