Sınıf alanlarını yapıcıda mı yoksa bildirimde mi?

Son zamanlarda C # ve Java programlama ve sınıf alanları başlatmak için en iyi yer nerede merak ediyorum.

Beyanda mı yapmalıyım ?:

public class Dice
{
    private int topFace = 1;
    private Random myRand = new Random();

    public void Roll()
    {
       // ......
    }
}

veya bir kurucuda ?:

public class Dice
{
    private int topFace;
    private Random myRand;

    public Dice()
    {
        topFace = 1;
        myRand = new Random();
    }

    public void Roll()
    {
        // .....
    }
}

Bazı gazilerinizin en iyi uygulama olduğunu düşündüklerini gerçekten merak ediyorum. Tutarlı olmak ve bir yaklaşıma bağlı kalmak istiyorum.

Benim kurallarım:

1. Bildiriminde varsayılan değerlerle başlatmak etmeyin ( null, false, 0, 0.0...).
2. Alanın değerini değiştiren bir yapıcı parametreniz yoksa bildirimde başlatmayı tercih edin.
3. Alanın değeri bir yapıcı parametresi nedeniyle değişirse, başlatmayı yapıcılara koyun.
4. Uygulamanızda tutarlı olun (en önemli kural).

C # 'da önemli değil. Verdiğiniz iki kod örneği tamamen eşdeğerdir. İlk örnekte C # derleyicisi (veya CLR mi?) Boş bir kurucu oluşturacak ve değişkenleri kurucudaymış gibi başlatacaktır (Jon Skeet'in aşağıdaki yorumlarda açıkladığı gibi küçük bir nüansı vardır). Zaten bir kurucu varsa, o zaman "yukarıdaki" herhangi bir başlatma onun üstüne taşınır.

En iyi uygulama açısından birincisi, bir başkası kolayca başka bir kurucu ekleyebilir ve onu zincirlemeyi unutabileceğinden, ikincisinden daha az hataya eğilimlidir.

C # semantiği burada Java'dan biraz farklıdır. C # 'da deklarasyonda atama, üst sınıf yapıcısı çağrılmadan önce gerçekleştirilir. Java'da hemen yapılır, bu da 'bunun' kullanılmasına izin verir (özellikle anonim iç sınıflar için yararlıdır) ve iki formun anlambiliminin gerçekten eşleştiği anlamına gelir.

Yapabiliyorsanız alanları sonlandırın.

Sanırım bir uyarı var. Bir keresinde böyle bir hata yaptım: Türetilmiş bir sınıfın içinde, soyut bir temel sınıftan miras alan alanları "beyanda başlatmaya" çalıştım. Sonuç olarak, biri "temel" diğeri yeni bildirilen alanlar olmak üzere iki alan kümesi mevcuttu ve hata ayıklamak için oldukça zaman harcadım.

Ders: devralınan alanları başlatmak için bunu yapıcı içinde yaparsınız.

Örneğinizdeki türü varsayarsak, kesinlikle yapıcıdaki alanları başlatmayı tercih edin. İstisnai durumlar:

• Statik sınıf / alanlardaki alanlar
• Statik / final / et al olarak yazılan alanlar

Ben her zaman bir sınıfın üstündeki alan listesi içindekiler (burada bulunan, nasıl kullanılır değil) ve yapıcı giriş olarak düşünüyorum. Tabii yöntemler bölümlerdir.

Ya sana söylersem duruma göre değişir?

Genel olarak her şeyi başlatır ve tutarlı bir şekilde yaparım. Evet aşırı açık ancak bakımı biraz daha kolay.

Performans konusunda endişeliysek, o zaman sadece ne yapılması gerektiğini başlatırım ve paranın en çok patladığı alanlara yerleştiririm.

Gerçek zamanlı bir sistemde, değişkene veya sabite bile ihtiyacım olup olmadığını soruyorum.

Ve C ++ 'da sık sık her iki yerde de başlatma yok ve bunu bir Init () işlevine taşımak. Neden? C ++ 'ta nesne yapımı sırasında istisna oluşturabilecek bir şey başlatıyorsanız, kendinizi bellek sızıntılarına açarsınız.

Çok ve çeşitli durumlar var.

Sadece boş bir listeye ihtiyacım var

Durum açık. Birisi listeye bir öğe eklediğinde sadece listemi hazırlamam ve bir istisnanın atılmasını önlemem gerekiyor.

public class CsvFile
{
    private List<CsvRow> lines = new List<CsvRow>();

    public CsvFile()
    {
    }
}

Değerleri biliyorum

Tam olarak varsayılan olarak hangi değerlere sahip olmak istediğimi biliyorum veya başka bir mantık kullanmam gerekiyor.

public class AdminTeam
{
    private List<string> usernames;

    public AdminTeam()
    {
         usernames = new List<string>() {"usernameA", "usernameB"};
    }
}

veya

public class AdminTeam
{
    private List<string> usernames;

    public AdminTeam()
    {
         usernames = GetDefaultUsers(2);
    }
}

Olası değerleri içeren boş liste

Bazen varsayılan olarak boş bir liste bekliyorum ve başka bir kurucu aracılığıyla değer ekleme olanağını bekliyorum.

public class AdminTeam
{
    private List<string> usernames = new List<string>();

    public AdminTeam()
    {
    }

    public AdminTeam(List<string> admins)
    {
         admins.ForEach(x => usernames.Add(x));
    }
}

Java'da, bildirime sahip bir başlatıcı, hangi kurucunun kullanıldığına (birden fazla varsa) veya yapıcılarınızın parametrelerine (bağımsız değişkenleri varsa) bakılmaksızın, alanın her zaman aynı şekilde başlatıldığı anlamına gelir. değeri değiştirin (son değilse). Bu nedenle, bir bildirim içeren bir başlatıcı kullanmak, bir okuyucunun, başlatılan değerin, hangi kurucunun kullanıldığına bakılmaksızın ve herhangi bir kurucuya iletilen parametrelerden bağımsız olarak, alanın her durumda sahip olduğu değer olduğunu gösterir. Bu nedenle, yalnızca tüm oluşturulmuş nesnelerin değeri aynı ise ve her zaman bildirimle birlikte bir başlatıcı kullanın.

C # tasarımı, satır içi başlatmanın tercih edildiğini veya dilde olmayacağını gösterir. Koddaki farklı yerler arasında çapraz referansı önlemek istediğinizde, genellikle daha iyi olursunuz.

En iyi performans için satır içi olması gereken statik alan başlatma ile tutarlılık da söz konusudur. Yapıcı Tasarım için Çerçeve Tasarım Yönergeleri şunları söylüyor:

✓ Çalışma zamanı, açıkça tanımlanmış bir statik kurucuya sahip olmayan türlerin performansını optimize edebildiğinden, statik alanları açıkça statik kurucular kullanmak yerine satır içi başlatır.

Bu bağlamda “düşünün”, yapmamak için iyi bir neden olmadığı sürece bunu yapmak anlamına gelir. Statik başlatıcı alanları söz konusu olduğunda, başlatmanın satır içi kodlanamayacak kadar karmaşık olması iyi bir nedendir.

Tutarlı olmak önemlidir, ancak bu kendinize sormanız gereken soru: "Başka bir şey için bir kurucum var mı?"

Tipik olarak, veri aktarımları için sınıfın kendisinin değişkenler için konut olarak çalışmak dışında hiçbir şey yapmadığı modeller oluşturuyorum.

Bu senaryolarda genellikle herhangi bir yöntemim veya kurucum yoktur. Listelerimi başlatmak için özel bir kurucu oluşturmak benim için aptalca olurdu, özellikle de bunları beyan ile uyumlu olarak başlatabildiğim için.

Diğerlerinin söylediği gibi, bu sizin kullanımınıza bağlıdır. Basit tutun ve yapmak zorunda olmadığınız ekstra bir şey yapmayın.

Birden fazla kurucunuzun olduğu durumu düşünün. Başlatma farklı kurucular için farklı olacak mı? Aynı olacaklarsa, neden her kurucu için tekrar etsin? Bu kokos ifadesiyle uyumludur, ancak parametrelerle ilgili olmayabilir. Örneğin, nesnenin nasıl oluşturulduğunu gösteren bir bayrak tutmak istediğinizi varsayalım. Daha sonra bu bayrak, yapıcı parametrelerine bakılmaksızın farklı kurucular için farklı şekilde başlatılır. Öte yandan, her bir kurucu için aynı başlatmayı tekrarlarsanız, (kurmadan) bazı kurucularda başlatma parametresini değiştirme, ancak diğerlerinde yapma olasılığınız kalmaz. Dolayısıyla, buradaki temel kavram, ortak kodun ortak bir konuma sahip olması ve farklı yerlerde potansiyel olarak tekrarlanmaması gerektiğidir.

Beyannamede değeri belirlemenin hafif bir faydası vardır. Yapıcıda ayarlarsanız, aslında iki kez ayarlanır (önce varsayılan değere, sonra da ctorda sıfırlayın).

Normalde yapıcıyı bağımlılıkları almaktan ve onlarla ilgili örnek üyelerini başlatmaktan başka bir şey yapmamaya çalışırım. Bu, sınıflarınızı birim olarak test etmek istiyorsanız hayatınızı kolaylaştıracaktır.

Bir örnek değişkenine atayacağınız değer, kurucuya ileteceğiniz parametrelerin hiçbirinden etkilenmezse, bildirim zamanında atayın.

En iyi uygulama hakkında sorunuza doğrudan bir cevap değil, önemli ve ilgili bir tazeleme noktası, genel bir sınıf tanımı durumunda, varsayılan değerlerle başlatmak için derleyicide bırakmanız veya alanları başlatmak için özel bir yöntem kullanmamız gerektiğidir. varsayılan değerlerine (kod okunabilirliği için mutlaksa).

class MyGeneric<T>
{
    T data;
    //T data = ""; // <-- ERROR
    //T data = 0; // <-- ERROR
    //T data = null; // <-- ERROR        

    public MyGeneric()
    {
        // All of the above errors would be errors here in constructor as well
    }
}

Ve genel bir alanı varsayılan değerine başlatmak için özel yöntem şöyledir:

class MyGeneric<T>
{
    T data = default(T);

    public MyGeneric()
    {           
        // The same method can be used here in constructor
    }
}

Bazı mantık veya hata işlemeye ihtiyacınız olmadığında:

• Sınıf alanlarını bildirimde başlat

Bazı mantık veya hata işlemeye ihtiyacınız olduğunda:

• Sınıf alanlarını yapıcıda başlat

Başlatma değeri kullanılabilir olduğunda ve başlatma bir satıra yerleştirilebildiğinde bu işe yarar. Bununla birlikte, bu başlatma şeklinin basitliği nedeniyle sınırlamaları vardır. Başlatma işlemi bir mantık gerektiriyorsa (örneğin, karmaşık bir diziyi doldurmak için hata işleme veya bir for döngüsü), basit atama yetersizdir. Örnek değişkenleri, hata işlemenin veya diğer mantığın kullanılabileceği kurucularda başlatılabilir.

Gönderen https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html .