Tek Sorumluluk İlkesi yeni koda uygulanabilir mi / uygulanmalı mı?


20

İlke, değiştirmek için bir nedeni olan modüller olarak tanımlanır . Benim sorum, kesinlikle bu nedenleri kod aslında değişmeye başlayana kadar bilinmiyor ?? Hemen hemen kodun her parçası için neden sayısız nedenleri vardır olabilir çok kötü kod ile sona ereceğini, bu düşünce ile muhtemelen değiştirmek ama kesinlikle tüm bunlar tahmin teşebbüs ve kodunuzu tasarlayın. Kod değiştirme istekleri geldiğinde SRP'yi uygulamaya başlamak gerçekten daha iyi bir fikir değil mi? Daha spesifik olarak, bir kod parçası birden fazla nedenden ötürü bir kereden fazla değiştiğinde, değiştirmenin birden fazla nedeni olduğunu kanıtlamak. Değişimin nedenlerini tahmin etmeye çalışmak çok çevik geliyor.

Bir örnek, bir belgeyi yazdıran bir kod parçasıdır. PDF'ye yazdırmak için değiştirmek için bir istek gelir ve daha sonra belgeye farklı biçimlendirme uygulamak için değiştirmek için ikinci bir istek yapılır. Bu noktada, değiştirmek (ve SRP'yi ihlal etmek) için tek bir sebepten daha fazlasına dair kanıtınız var ve uygun yeniden düzenleme yapmalısınız.


6
@Frank - aslında yaygın böyle tanımlanan IS - örneğin bkz en.wikipedia.org/wiki/Single_responsibility_principle
Joris Timmermans

1
İfadenizi nasıl yaptığınız, SRP'nin tanımını anladığım şekilde değildir.
Pieter B

2
Her kod satırının (en azından) değiştirilmesinin iki nedeni vardır: Bir hataya katkıda bulunur veya yeni bir gereksinime müdahale eder.
Bart van Ingen Schenau

1
@BartvanIngenSchenau: LOL ;-) Bu şekilde görürseniz, SRP hiçbir yere uygulanamaz.
Doc Brown

1
@DBBrown: SRP'yi kaynak kodunu değiştirmeyle eşleştirmezseniz yapabilirsiniz. Örneğin, SRP'yi bir cümle içinde bir sınıfın / işlevin ne yaptığını tam olarak açıklayabildiğinizi ve (ve bu kısıtlamanın üstesinden gelmek için çakal ifadelerinin olmadığını) yorumluyorsanız.
Bart van Ingen Schenau

Yanıtlar:


27

Tabii ki, YAGNI prensibi SRP'yi gerçekten ihtiyaç duymadan önce uygulamanızı söyleyecektir. Ama kendinize sormanız gereken soru şudur: SRP'yi önce ve sadece kodumu gerçekten değiştirmek zorunda kaldığımda mı uygulamalıyım?

Deneyimlerime göre, SRP uygulaması size çok daha erken bir fayda sağlar: kodunuzda belirli bir değişikliği nerede ve nasıl uygulayacağınızı ne zaman öğrenmeniz gerektiği . Bu görev için mevcut işlevlerinizi ve sınıflarınızı okumalı ve anlamalısınız. Tüm fonksiyonlarınızın ve sınıflarınızın belirli bir sorumluluğu olduğunda bu çok daha kolay hale gelir. IMHO, SRP'yi kodunuzun okunmasını kolaylaştıracak, işlevlerinizi daha küçük ve kendi kendini tanımlayan hale getirdiği zaman uygulamanız gerekir. Bu nedenle cevap evet , yeni kod için bile SRP uygulamak mantıklı.

Örneğin, yazdırma kodunuz bir belgeyi okuduğunda, belgeyi biçimlendirdiğinde ve sonucu belirli bir aygıta yazdırdığında, bunlar 3 ayrı ayrı ayrılabilir sorumluluktur. Bu yüzden bunlardan en az 3 işlev yapın, isimlere göre verin. Örneğin:

 void RunPrintWorkflow()
 {
     var document = ReadDocument();
     var formattedDocument = FormatDocument(document);
     PrintDocumentToScreen(formattedDocument);
 }

Biçimlendirme değişikliği belgeye yeni bir gereklilik veya PDF yazdırmak için başka bir tane Şimdi, bilirsin tam olarak koduna bu işlevlerin veya konumların hangi noktada değişiklikleri uygulamak zorunda ve daha da önemlisi, nerede değil.

Eğer bir işleve gelip zaman fonksiyonu "çok fazla" yapar, çünkü Yani, anlamıyorum ve bir değişikliği uygulamak için nerede ve, eğer emin değilseniz o zaman ayrı, daha küçük fonksiyonlarına işlevini refactor düşünün. Bir şeyi değiştirmek zorunda kalana kadar beklemeyin. Kod, değiştirilenden 10 kat daha sık okunur ve daha küçük işlevlerin okunması çok daha kolaydır. Deneyimlerime göre, bir fonksiyonun belirli bir karmaşıklığı olduğunda, gelecekte hangi değişikliklerin olacağını bilmeksizin, fonksiyonu her zaman farklı sorumluluklara bölebilirsiniz. Bob Martin tipik olarak bir adım daha ileri gider, aşağıdaki yorumlarımda verdiğim bağlantıya bakın.

DÜZENLEME: yorumunuza: Yukarıdaki örnekte dış işlevin temel sorumluluğu, belirli bir aygıta yazdırmak veya belgeyi biçimlendirmektir - yazdırma iş akışını tümleştirmektir . Bu nedenle, dış işlevin soyutlama düzeyinde, "dokümanlar artık biçimlendirilmemelidir" veya "yazdırılan yerine dokümanın postalanması gerekir" yalnızca "aynı nedendir" - yani "yazdırma iş akışı değişmiştir". Böyle şeyler hakkında konuşursak, doğru soyutlama seviyesine bağlı kalmak önemlidir .


Genelde TDD ile her zaman gelişirim, bu yüzden örneğimde fiziksel olarak tüm bu mantığı tek bir modülde tutamazdım çünkü test etmek imkansız olurdu. Bu sadece TDD'nin bir yan ürünüdür ve kasıtlı olarak SRP uyguladığım için değil. Örneğim oldukça açık, ayrı sorumluluklara sahipti, bu yüzden iyi bir örnek olmayabilir. Sorduğum şey, yeni bir kod parçası yazabilir ve açık bir şekilde söyleyebilir misiniz , evet bu SRP'yi ihlal etmiyor mu? 'Değişim nedenleri' esasen işletme tarafından tanımlanmamış mı?
SeeNoWeevil

3
@ thecapsaicinkid: evet, yapabilirsiniz (en azından hemen yeniden düzenleme yoluyla). Ama çok, çok küçük fonksiyonlar alacaksınız - ve her programcı bunu sevmiyor. Bu örneğe bakın: sites.google.com/site/unclebobconsultingllc/…
Doc Brown

Eğer değişmek için nedenler öngörerek SRP uyguluyorsanız, örneğinizde hala tek bir neden değişikliğinden daha fazla olduğunu iddia edebilirim. İşletme artık bir belgeyi biçimlendirmek istemediklerine karar verebilir ve daha sonra yazdırılmak yerine e-postayla gönderilmesini istediklerine karar verebilir. DÜZENLEME: Sadece bağlantıyı okuyun ve son sonucu sevmiyorum, ancak 'Artık daha fazla çıkaramayacak kadar ayıkla' çok daha mantıklı ve 'değiştirmek için sadece bir sebepten' daha belirsiz. Gerçi çok pragmatik değil.
SeeNoWeevil

1
@ thecapsaicinkid: benim düzenlememe bakın. Dış işlevin ana sorumluluğu belirli bir aygıta yazdırmak veya belgeyi biçimlendirmektir - yazdırma iş akışını entegre etmektir. Ve bu iş akışı değiştiğinde, işlevin değişmesinin tek nedeni budur
Doc Brown

Doğru soyutlama seviyesine bağlı kalmayla ilgili yorumunuz eksik olduğum şey gibi görünüyor. Bir örnek, 'JSON dizisinden veri yapıları oluşturur' olarak tanımlayacağım bir sınıfım var. Bana tek bir sorumluluk gibi geliyor. JSON dizisindeki nesneler arasında dolaşır ve bunları POJO'larla eşler. Açıklamamla aynı soyutlama düzeyine sadık kalırsam, değiştirmek için birden fazla nedeni olduğunu iddia etmek zor, yani 'JSON nesneye nasıl eşlenir'. Daha az soyut olmak , örneğin tarih alanlarındaki değişiklikleri nasıl haritaladığım, sayısal değerlerin günlerle nasıl eşlendiği vb.
Gibi

7

Bence SRP'yi yanlış anlıyorsun.

Değişikliğin tek nedeni kodu değiştirmek değil, kodunuzun ne yaptığıdır.


3

SRP'nin "değiştirmek için bir nedene sahip" olarak tanımlanması tam da bu nedenle yanıltıcıdır. Tam olarak nominal değerde alın: Tek Sorumluluk İlkesi, bir sınıf veya işlevin tam olarak bir sorumluluğu olması gerektiğini söylüyor. Değiştirmek için sadece bir nedene sahip olmak, başlamak için sadece bir şey yapmanın bir yan etkisidir. İleride nasıl değişebileceği hakkında hiçbir şey bilmeden, kodunuzda tek bir sorumluluk için çaba göstermemenizin bir nedeni yoktur.

Bu tür şeyler için en iyi ipuçlarından biri, sınıf veya işlev adlarını seçmektir. Sınıfın ne adlandırılması gerektiği belli değilse veya ad özellikle uzun / karmaşıksa veya ad "yönetici" veya "yardımcı program" gibi genel terimler kullanıyorsa, muhtemelen SRP'yi ihlal ediyor demektir. Benzer şekilde, API'yi belgelendirirken, hangi işlevselliği açıkladığınıza bağlı olarak SRP'yi ihlal ediyorsanız, bu durum hızla anlaşılmalıdır.

Tabii ki, SRP'ye nihayetinde projede daha sonra bilemeyeceğiniz nüanslar var - tek bir sorumluluk gibi görünen şey iki veya üç oldu. Bunlar SRP'yi uygulamak için yeniden düzenleme yapmanız gerekecek durumlardır. Ancak bu, bir değişiklik isteği alana kadar SRP'nin dikkate alınmaması gerektiği anlamına gelmez; SRP'nin amacını alt eden!

Doğrudan örneğinizle konuşmak için yazdırma yönteminizi belgelemeyi düşünün. Eğer derdim "bu yöntem baskı için verileri biçimlendirir ve yazıcıya gönderir," o takdirde ve sizi alır şudur: Tek bir sorumluluk olmadığını, iki sorumluluklar söz konusudur: biçimlendirme ve yazıcıya gönderme. Bunu fark edip bunları iki işleve / sınıfa ayırırsanız, değişiklik istekleriniz geldiğinde, her bölümün değişmesi için zaten tek bir nedeniniz olurdu.


3

Bir örnek, bir belgeyi yazdıran bir kod parçasıdır. PDF'ye yazdırmak için değiştirmek için bir istek gelir ve daha sonra belgeye farklı biçimlendirme uygulamak için değiştirmek için ikinci bir istek yapılır. Bu noktada, değiştirmek (ve SRP'yi ihlal etmek) için tek bir sebepten daha fazlasına dair kanıtınız var ve uygun yeniden düzenleme yapmalısınız.

Bu değişiklikleri benimsemek için çok fazla zaman harcayarak kendimi ayağımdan vurdum. Sadece aptal PDF'yi yazdırmak yerine.

Kodu Azaltmak İçin Refactor

Tek kullanımlık desen kod bloat oluşturabilir. Paketlerin, bireysel olarak anlamlı olmayan bir çöp yığını oluşturan küçük belirli sınıflarla kirlendiği yerlerde. Baskı kısmına nasıl geldiğini anlamak için düzinelerce kaynak dosyasını açmanız gerekiyor. Bunun da ötesinde, gerçek baskıyı yapan 10 satır kod yürütmek için binlerce satır olmasa bile yüzlerce satır kod bulunabilir.

Bullseye Yarat

Tek kullanımlık desen, kaynak kodunu azaltmak ve kodun yeniden kullanımını iyileştirmek için tasarlanmıştır. Uzmanlık ve özel uygulamalar yaratmaktı. bullseyeSizin için kaynak kodunda bir tür go to specific tasks. Yazdırmayla ilgili bir sorun olduğunda, düzeltmek için tam olarak nereye gideceğinizi biliyordunuz.

Tek Kullanım Belirsiz Kırılma anlamına gelmez

Evet, zaten bir belge yazdıran kodunuz var. Evet, artık PDF'leri de yazdırabilmek için kodu değiştirmeniz gerekir. Evet, şimdi belgenin biçimlendirmesini değiştirmelisiniz.

usageÖnemli ölçüde değiştiğinden emin misiniz ?

Yeniden düzenleme, kaynak kodunun bölümlerinin aşırı genelleşmesine neden oluyorsa. Orijinal amacının printing stuffartık açık olmadığı noktaya gelince , kaynak kodunda belirsiz bir kırılma yarattınız.

Yeni adam bunu çabucak çözebilecek mi?

Kaynak kodunuzu her zaman en kolay anlaşılan organizasyonda tutun.

Saatçi Olma

Çok fazla kez geliştiricilerin bir mercek taktığını gördüm ve küçük ayrıntılara, başka hiç kimsenin parçaları tekrar parçalayamazsa tekrar birleştiremeyeceği noktaya odaklandım.

resim açıklamasını buraya girin


2

Değişimin bir nedeni, sonuçta, uygulamanın çalıştığı ortam ile ilgili şartnamede veya bilgide yapılan bir değişikliktir. Bu nedenle, tek bir sorumluluk ilkesi, her bir bileşeni (sınıf, işlev, modül, hizmet ...) yazmanızı söyler, böylece spesifikasyonu ve yürütme ortamını olabildiğince az dikkate alması gerekir.

Bileşeni yazarken özellikleri ve ortamı bildiğiniz için prensibi uygulayabilirsiniz.

Bir belgeyi yazdıran kod örneğini dikkate alırsanız. Belgenin PDF olarak sonuçlanacağını düşünmeden mizanpaj şablonunu tanımlayıp tanımlayamayacağınızı düşünmelisiniz. Yapabilirsiniz, böylece SRP size söylemelisiniz.

Tabii ki YAGNI size yapmamanız gerektiğini söylüyor. Tasarım ilkeleri arasında bir denge bulmalısınız.


2

Flup doğru yönde ilerliyor. Başlangıçta prosedürlere uygulanan "tek sorumluluk ilkesi". Örneğin, Dennis Ritchie bir fonksiyonun bir şey yapması ve bunu iyi yapması gerektiğini söyleyebilir. Sonra, C ++ 'da, Bjarne Stroustrup bir sınıfın bir şey yapması ve bunu iyi yapması gerektiğini söylerdi.

Başparmak kuralları dışında, bu ikisinin resmi olarak birbirleriyle çok az veya hiçbir ilgisi olmadığına dikkat edin. Sadece programlama dilinde ifade etmek için uygun olanlara hitap ederler. Bu bir şey. Ama flupun sürdüğünden oldukça farklı bir hikaye.

Modern (yani çevik ve DDD) uygulamalar, programlama dilinin ifade edebileceğinden çok, iş için önemli olan şeylere odaklanır. Şaşırtıcı olan şey, programlama dillerinin henüz yakalanmamış olmasıdır. Eski FORTRAN benzeri diller, zamanın en önemli kavramsal modellerine uyan sorumlulukları yakalar: kart okuyucusundan geçerken her bir karta uygulanan süreçler veya her kesmeye eşlik eden işlem (C'deki gibi). Daha sonra DDD halkının daha sonra önemli olarak yeniden icat edeceği şeyi yakalama noktasına kadar olgunlaşan ADT dilleri geldi (Jim Neighbors'ın çoğunun bunu 1968'de anladı, yayınladı ve kullanıyordu). . (Bunlar modüller DEĞİLDİR.)

Bu adım bir sarkaç salınımından daha az bir evrimdi. Sarkaç verilere döndüğünde FORTRAN'ın doğasında olan kullanım örneği modelini kaybettik. Birincil odağınız ekrandaki verileri veya şekilleri içerdiğinde sorun yoktur. PowerPoint gibi programlar veya en azından basit işlemleri için harika bir model.

Kaybolan şey sistem sorumluluklarıdır . DDD'nin unsurlarını satmıyoruz. Ve sınıf yöntemlerini iyi bilmiyoruz. Sistem sorumluluklarını satıyoruz. Bir düzeyde, sisteminizi tek sorumluluk ilkesi çerçevesinde tasarlamanız gerekir.

Yani sınıf yöntemleri hakkında konuşmuş olan Rebecca Wirfs-Brock gibi benim gibi insanlara bakarsanız, şimdi kullanım durumları hakkında konuşuyoruz. Biz bunu satıyoruz. Bunlar sistem işlemleri. Bir kullanım senaryosunun tek bir sorumluluğu olmalıdır. Bir kullanım durumu nadiren mimari bir birimdir. Ama herkes öyle davranmaya çalışıyordu. Örneğin, SOA halkına tanık olun.

Bu yüzden yukarıdaki Yalın Mimari kitabında açıklanan Trygve Reenskaug'un DCI mimarisi hakkında heyecan duyuyorum. Nihayet, yukarıdaki tartışmanın çoğunda bulduğu gibi, "tek sorumluluk" için keyfi ve mistik bir keşif olan şeye gerçek bir önem verir. Bu boy insanın zihinsel modelleri ile ilgilidir: önce son kullanıcılar VE sonra programcılar. Ticari kaygılarla ilgilidir. Ve neredeyse tesadüfen, flup bize meydan okudukça değişimi kapsülliyor.

Bildiğimiz tek sorumluluk ilkesi, ya başlangıç ​​günlerinden kalan bir dinozor ya da anlamanın yerine kullandığımız bir hobi atıdır. Harika bir yazılım yapmak için bu hobi atlarından birkaçını geride bırakmanız gerekiyor. Ve bu kutunun dışında düşünmeyi gerektirir. İşleri basit ve kolay anlaşılır tutmak yalnızca sorun basit ve anlaşılması kolay olduğunda işe yarar. Bu çözümlerle çok fazla ilgilenmiyorum: tipik değiller ve meydan okuma burada yatıyor.


2
Yazdıklarınızı okurken, yol boyunca bir yerde, neden bahsettiğinizi tamamen gözden kaçırdım. İyi cevaplar, soruyu ormanda bir engelin başlangıç ​​noktası olarak değil, tüm yazıları birbirine bağlamak için kesin bir tema olarak ele alır.
Donal Üyeleri

1
Ah, sen onlardan birisin, eski yöneticilerimden biri gibi. "Onu anlamak istemiyoruz: geliştirmek istiyoruz!" Buradaki ana tematik konu prensiplerden biridir: "SRP" deki "P". Belki de doğru soru olsaydı soruyu doğrudan cevaplardım: Öyle değildi. Bunu kimin sorusunu sormuş olabilirsiniz.
Cope

Burada bir yere gömülü iyi bir cevap var. Sanırım ...
RubberDuck

0

Evet, Tek Sorumluluk İlkesi yeni koda uygulanmalıdır.

Fakat! Sorumluluk nedir?

"Bir rapor yazdırmak sorumluluk" mudur? Cevap, "Belki" olduğuna inanıyorum.

SRP'nin tanımını "değiştirmek için tek bir nedene sahip" olarak kullanmaya çalışalım.

Raporları yazdıran bir işleviniz olduğunu varsayalım. İki değişikliğiniz varsa:

  1. raporunuzun siyah bir arka plana sahip olması gerektiğinden bu işlevi değiştirin
  2. pdf'ye yazdırmanız gerektiğinden bu işlevi değiştirin

Sonra ilk değişiklik "rapor stilini değiştir" diğeri "rapor çıktı biçimini değiştir" dir ve şimdi bunları iki farklı fonksiyona koymalısınız çünkü bunlar farklı şeylerdir.

Ama ikinci değişikliğiniz olsaydı:

2b. raporunuzun farklı bir yazı tipine ihtiyacı olduğu için bu işlevi değiştirin

Her iki değişikliğin de "rapor stilini değiştir" olduğunu söyleyebilirim ve tek bir işlevde kalabilirler.

Peki bu bizi nereye bırakıyor? Her zamanki gibi, işleri basit ve kolay anlaşılır tutmaya çalışmalısınız. Arka plan rengini değiştirmek 20 kod satırı ve yazı tipini değiştirmek 20 kod satırı anlamına geliyorsa, tekrar iki işlev yapın. Her biri bir satırsa, bir satırda tutun.


0

Yeni bir sistem tasarlarken, kullanım ömrü boyunca ne tür değişiklikler yapmanız gerekebileceğini ve yerleştirdiğiniz mimariye ne kadar pahalı verileceğini düşünmek akıllıca olacaktır. Sisteminizi modüllere bölmek yanlış yapmak için pahalı bir karardır.

İyi bir bilgi kaynağı, işletmenin alan adı uzmanlarının kafasındaki zihinsel modeldir. Belge, biçimlendirme ve pdf örneğini ele alalım. Alan adı uzmanları büyük olasılıkla mektuplarını belge şablonlarını kullanarak biçimlendirdiklerini söyleyecektir. Ya durağan ya da Word'de ya da her neyse. Kodlamaya başlamadan ve tasarımınızda kullanmadan önce bu bilgileri alabilirsiniz.

Bu şeyler hakkında harika bir okuma: Coplien'den Yalın Mimari


0

"Yazdır", MVC'deki "görünüm" e çok benzer. Nesnelerin temellerini anlayan herkes bunu anlayacaktır.

Bu bir sistem sorumluluğudur. Bir yazıcı (Görünüm), yazdırılan şeyi (Modül) ve yazıcı isteğini ve seçeneklerini (Denetleyiciden) içeren bir mekanizma - MVC - olarak uygulanır.

Bunu bir sınıf veya modül sorumluluğu olarak yerelleştirmeye çalışmak asinindir ve 30 yaşındaki düşünceyi yansıtır. O zamandan beri çok şey öğrendik ve literatürde ve olgun programcıların kodunda fazlasıyla kanıtlanmıştır.


0

SRP'yi uygulamak için yalnızca kodu değiştirme istekleri geldiğinde daha iyi bir fikir değil mi?

İdeal olarak, kodun çeşitli bölümlerinin sorumluluklarının ne olduğu konusunda iyi bir fikriniz olacaktır. İlk içgüdülerinize göre sorumluluklara bölün, muhtemelen kullandığınız kütüphanelerin ne yapmak istediğini dikkate alarak (bir görevi, bir sorumluluğu bir kütüphaneye devretmek, kütüphanenin gerçekten görevi yapabilmesi şartıyla, genellikle yapmak için harika bir şeydir ). Ardından, değişen gereksinimlere göre sorumluluklar hakkındaki anlayışınızı geliştirin. Sistemi başlangıçta ne kadar iyi anlarsanız, sorumluluk atamalarını temelden daha az değiştirmeniz gerekir (ancak bazen bir sorumluluğun en iyi alt sorumluluklara ayrıldığını keşfedersiniz).

Bunun için endişelenerek uzun zaman harcamanız gerekmiyor. Kodun önemli bir özelliği, daha sonra değiştirilebilmesidir, ilk seferinde tamamen doğru yapmanız gerekmez. Gelecekte daha az hata yapabilmeniz için ne tür şekil sorumluluklarının olduğunu öğrenmek için zamanla daha iyi olmaya çalışın.

Bir örnek, bir belgeyi yazdıran bir kod parçasıdır. PDF'ye yazdırmak için değiştirmek için bir istek gelir ve daha sonra belgeye farklı biçimlendirme uygulamak için değiştirmek için ikinci bir istek yapılır. Bu noktada, değiştirmek (ve SRP'yi ihlal etmek) için tek bir sebepten daha fazlasına dair kanıtınız var ve uygun yeniden düzenleme yapmalısınız.

Bu kesinlikle genel sorumluluğun - kodu “basma” nın alt sorumlulukları olduğunu ve parçalara bölünmesi gerektiğinin bir göstergesidir. Bu kendiliğinden SRP'nin ihlali değil, bölümlendirmenin (belki de “biçimlendirme” ve “oluşturma” alt görevlerine) muhtemelen bir göstergedir. Bu sorumlulukları, görevlerine bakmadan alt görevlerde neler olup bittiğini anlayabilmeniz için açık bir şekilde anlatabilir misiniz? Mümkünse, makul bölünmeler olabilirler.

Basit bir gerçek örneğe bakarsak daha açık olabilir. İçindeki sort()yarar yöntemini ele alalım java.util.Arrays. Bu ne işe yarıyor? Bir diziyi sıralar ve tek yaptığı budur. O düdük değil, en ahlaki-fit üyesi bulamazsa, unsurları çıktısını gelmez Dixie . Sadece bir dizi sıralar. Nasıl olduğunu da bilmek zorunda değilsiniz. Sıralama, bu yöntemin tek sorumluluğudur. (Aslında, ilkel tiplerle yapmak için çirkin teknik nedenlerden dolayı Java'da birçok sıralama yöntemi vardır; hepsine eşdeğer sorumlulukları olduğu için buna dikkat etmek zorunda değilsiniz.)

Metodlarınızı, sınıflarınızı, modüllerinizi, onların hayatınızda açıkça belirlenmiş bir rolleri olmasını sağlayın. Anlamak zorunda olduğunuz miktarı aynı anda tutar ve bu da büyük bir sistemin tasarımını ve bakımını yapmanıza izin veren şeydir.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.