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.