Neden Java, Javascript ve C # gibi bellekle yönetilen diller `new 'anahtar sözcüğünü korudu?

newJava, JavaScript ve C # gibi dillerde kelime bir sınıfın yeni bir örneğini oluşturur.

Bu sözdiziminin newözellikle öbek üzerinde bir sınıfın yeni bir örneğini ayırmak ve yeni örneğe bir işaretçi döndürmek için kullanılan C ++ 'dan miras alınmış gibi görünüyor . C ++ 'da, nesne oluşturmanın tek yolu bu değildir. Ayrıca, yığın kullanmadan da bir nesne oluşturabilirsiniz new- ve aslında, bu nesne oluşturma yöntemi C ++ 'da çok daha yaygındır.

Böylece, bir C ++ arkaplanından geliyorsanız, newJava, Javascript ve C # gibi dillerde anahtar kelime bana doğal geliyordu. Sonra newanahtar kelimesi olmayan Python'u öğrenmeye başladım . Python'da, bir örnek basitçe yapıcıyı çağırarak inşa edilir, örneğin:

f = Foo()

İlk başta, bu biraz aklıma geldi, aklıma gelene kadar Python'un bir nedeni olmadı new, çünkü her şey bir nesneydi, bu yüzden her şey çeşitli yapıcı sözdizimleri arasında karartmaya gerek kalmadı.

Ama sonra düşündüm - newJava'nın gerçekte ne anlamı var ? Neden demeliyim Object o = new Object();? Neden sadece değil Object o = Object();? C ++ 'da kesinlikle bir ihtiyaç var new, çünkü yığında tahsis etmekle yığında tahsis etmek arasında ayrım yapmak zorundayız, ancak Java'da tüm nesneler öbek üzerinde inşa edilmiş, o zaman neden newanahtar kelimeye bile sahipsin ? Aynı soru Javascript için de istenebilir. Daha az aşina olduğum C # 'da, newnesne türleri ile değer türleri arasında ayrım yapmada bazı amaçları olabileceğini düşünüyorum , ancak emin değilim.

Her şeye rağmen, C ++ 'dan sonra gelen birçok dilin newanahtar kelimeyi gerçekten "gerek kalmadan " aldığını düşünüyorum. Neredeyse vestigial bir anahtar kelime gibi . Herhangi bir sebepten dolayı ihtiyacımız yok gibi görünüyor, ama yine de orada.

Soru: Bu konuda doğru muyum? Ya da newJava, Javascript ve C # gibi ama Python değil C ++ 'dan ilham alan bellekle yönetilen dillerde olması gereken zorlayıcı bir neden var mı?

Gözlemlerin doğru. C ++, karmaşık bir canavardır ve newanahtar kelime, deletedaha sonra ihtiyaç duyulan ve otomatik olarak geri kazanılabilecek bir şey arasında ayrım yapmak için kullanılmıştır . Java ve C # 'da, deleteçöp toplayıcıları sizin için ilgileneceği için anahtar kelimeyi düşürdüler .

O zaman sorun, neden newanahtar kelimeyi korudular? Dili yazan insanlarla konuşmadan cevaplamak biraz zor. En iyi tahminlerim aşağıda listelenmiştir:

• Öyleydi semantik doğru. C ++ ile aşina iseniz, newanahtar kelimenin öbek üzerinde bir nesne oluşturduğunu biliyordunuz . Peki neden beklenen davranışı değiştirelim?
• Bir yöntemi çağırmak yerine bir nesneyi başlattığınız gerçeğine dikkat çekiyor. Microsoft kod stili önerileriyle, yöntem adları büyük harflerle başlar, böylece karışıklık olabilir.

Ruby, Python ile Java / C # arasında bir yerdedir new. Temel olarak, böyle bir nesneyi başlatırsınız:

f = Foo.new()

Anahtar kelime değil, sınıf için statik bir yöntem. Bunun anlamı, eğer bir singleton istiyorsanız, new()her seferinde aynı örneği döndürmek için varsayılan uygulamasını geçersiz kılabilirsiniz . Bu mutlaka tavsiye edilmez, ancak mümkün.

Kısacası haklısın. Yeni anahtar kelime, Java ve C # gibi dillerde gereksiz. 1990'larda C ++ Standard Comitee üyesi olan ve daha sonra Java ile ilgili kitaplar yayınlayan Bruce Eckel'in bazı görüşleri: http://www.artima.com/weblogs/viewpost.jsp?thread=260578

yığın nesnelerini yığın nesnelerinden ayırmanın bir yolu olmalıydı. Bu sorunu çözmek için, yeni anahtar kelime Smalltalk'tan ayrılmıştır. Bir yığın nesnesi oluşturmak için, basitçe, Cat x; veya, bağımsız değişkenlerle, Cat x ("mittens"); Bir yığın nesnesi oluşturmak için, yeni Cat'teki gibi yeni kullanın; veya yeni Kedi ("eldivenler"); Kısıtlamalar göz önüne alındığında, bu zarif ve tutarlı bir çözümdür.

C ++ 'ya her şeyin kötü yapıldığına ve aşırı karmaşık olduğuna karar verdikten sonra Java’ya girin. Buradaki ironi, Java'nın yığın tahsisini çöpe atma kararını verebildiği ve verdiğini (başka bir yerde ele aldığım ilkellerin alçalışını dikkatlice görmezden geldi). Ve tüm nesneler öbek üzerinde tahsis edildiğinden, yığın ve öbek tahsisini ayırt etmeye gerek yoktur. Kolayca Cat x = Cat () veya Cat x = Cat ("eldivenler") diyebilirlerdi. Daha da iyisi, tekrarı ortadan kaldırmak için birleşik türden çıkarım (ancak bu - ve kapanma gibi diğer özellikler - "çok uzun" olurdu, bu yüzden Java'nın vasat bir sürümüyle sıkışıp kaldık; bunun yerine tür çıkarımı tartışıldı ama ben bunun mümkün olmayacağı ihtimalini yerine getirin. Ve, Java'ya yeni özellikler eklerken sorun yaşanmamalıydı).

Düşünebilmemin iki nedeni var:

• new Bir nesne ile ilkel arasındaki farkı ayırt eder
• newSözdizimi biraz daha okunabilir (IMO)

Birincisi önemsiz. İkisine de iki şekilde anlatmanın daha zor olduğunu sanmıyorum. İkincisi, OP'nin noktalarına bir örnektir, ki bu newgereksizdir.

Yine de isim alanı çatışmaları olabilir; düşünmek:

public class Foo {
   Foo() {
      // Constructor
   }
}

public class Bar {
   public static void main(String[] args) {
      Foo f = Foo();
   }

   public Foo Foo() {
      return Foo();
   }
}

Çok fazla hayal gücü olmadan, kolayca sonsuz özyinelemeli bir çağrı ile sonuçlanabilir. Derleyici "nesne ile aynı işlev adı" hatası uygulamak zorunda kalacak. Bu gerçekten acı vermez, ancak kullanımı çok daha kolaydır new, ki Go to the object of the same name as this method and use the method that matches this signature.Java'nın ayrıştırılması çok basit bir dil olduğunu ve bunun o alanda yardımcı olduğunu düşünüyorum.

Java, biri için, hala C ++ ikiliğini vardır: değil oldukça her şey bir nesnedir. Java'nın dinamik olarak atanması gerekmeyen yerleşik türleri (örn. charVe int) vardır.

Bu newJava'da gerçekten gerekli olduğu anlamına gelmez - dinamik olarak tahsis edilmesi gerekmeyen türler kümesi sabittir ve bilinir. Bir nesneyi tanımladığınızda, derleyici basit bir değer charveya dinamik olarak tahsis edilmesi gereken bir nesne olup olmadığını bilir (ve aslında bilir) .

Java'nın tasarımının kalitesi için bunun ne anlama geldiğini (ya da durumunun olmadığı gibi) düşünmekten (yine bir daha) kaçınacağım.

Yapıcı normal bir işleve benziyor çünkü JavaScript'te buna ihtiyacınız var, JS yeni anahtar kelime için değilse yeni bir nesne oluşturmak istediğinizi nasıl bilmeli?

İlginçtir, VB yapar arasındaki ayrımı - lüzum

Dim f As Foo

atanmamış bir değişkeni bildirir Foo f;, C # eşdeğer

Dim f As New Foo()

değişkeni bildirir ve sınıfın yeni bir örneğini atar var f = new Foo();, C # 'ya eşdeğerdir . Pre-.NET VB, hatta kullanabilirsiniz Dim f As Fooveya Dim f As New Foo- yapıcıları üzerinde aşırı yükleme olmadığı çünkü.

Cevapları çok severim ve şunu da eklemek isterim:
Kodun okunmasını kolaylaştırır
Bu durumun çok sık gerçekleşmeyeceğini, ancak isim ile aynı adı paylaşan bir fiil adına bir yöntem istediğinizi düşünün. C # ve diğer diller doğal olarak objectayrılmış kelimeye sahiptir . Ancak, o zaman olmasaydı Foo = object(), nesne yöntemi çağrısının sonucu olurdu ya da yeni bir nesneyi başlatıyordu. Umarım newanahtar kelimesi olmayan dilin bu duruma karşı korumaları vardır, ancak newbir inşaatçının çağrılmasından önce anahtar kelimenin şartına göre bir nesnenin aynı adı taşıyan bir yöntemin varlığına izin vermiş olursunuz.

Pek çok programlama dilinde çok fazla kayda değer şeyler var. Bazen tasarım gereği orada (C ++ C ile mümkün olduğunca uyumlu olacak şekilde tasarlandı), bazen de orada. Daha korkunç bir örnek için, kırık C switchifadesinin ne kadar yayıldığını düşünün .

Javascript ve C # söyleyecek kadar iyi bilmiyorum, ama newJava için C ++ 'ın olması dışında bir sebep görmüyorum .

C # 'da, bir üye tarafından gizlenebileceği bağlamlarda görünür tiplere izin verir. Türü ile aynı adı taşıyan bir özelliğe sahip olmanızı sağlar. Aşağıdakileri göz önünde bulundur,

class Address { 
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Zip { get; set; }
}

class Person {
    public string Name { get; set; }
    public Address Address { get; set; }

    public void ChangeStreet(string newStreet) {
        Address = new Address { 
            Street = newStreet, 
            City = Address.City,
            State = Address.State,
            Zip = Address.Zip
        };
    }
}

Kullanımına dikkat newbunun açıkça olmasını sağlar Addressolduğunu Addresstürü değil Addressüyesi. Bu, bir üyenin türüyle aynı ada sahip olmasını sağlar. Bu olmadan, gibi ad çarpışmasını önlemek için türün adını öneklemeniz gerekir CAddress. Anders hiçbir zaman Macar gösterimini veya benzer bir şeyi sevmediği ve C # 'ya onsuz kullanılabilir olmasını istediği için çok kasıtlıydı. Aynı zamanda tanıdık olması çifte bonus oldu.

İlginçtir ki, mükemmel iletimin gelmesi ile birlikte, yerleştirme newyapılmaması da C ++ 'da gerekmemektedir. Bu nedenle, tartışmalı olarak, belirtilen dillerden hiçbirinde artık gerekli değildir.

Java tasarımcılarının bunu aklında tutup oluşturmadığından emin değilim, ancak nesneleri özyinelemeli kayıtlar olarak düşündüğünüzde, bunun Foo(123)bir nesneyi döndürmediğini ancak fikrinin oluşturulduğu nesneyi (yani, geri dönecek işlevi olan bir işlev) döndürdüğünü hayal edebilirsiniz . eğer argüman olarak verilmişse, inşa edilen nesne). Ve amacı new"düğümü bağlamak" ve bu fiksaj noktasını döndürmektir. Başka bir deyişle new“nesneden nesneye” onun farkında olmasını sağlar self.

Bu tür bir yaklaşım, örneğin kalıtımın resmileştirilmesine yardımcı olabilir: bir nesne işlevini başka bir nesne işleviyle genişletebilir ve sonunda bunları selfkullanarak ortak bir şekilde sağlayabilirsiniz new:

cp = new (Colored("Blue") & Line(0, 0, 100, 100))

Burada &iki nesne fonksiyonunu birleştiriyor.

Bu durumda newşöyle tanımlanabilir:

def new(objectFunction) {
    actualObject = objectFunction(actualObject)
    return actualObject
}

'Sıfır' izin vermek için.

Java, yığın tabanlı tahsisatın yanı sıra nil nesnelerin kullanımını da benimsedi. Sadece bir eser olarak değil, bir özellik olarak. Nesneler sıfır durumuna sahip olduğunda, bildirimi ilklendirmeden ayırmanız gerekir. Dolayısıyla yeni anahtar kelime.

C ++ 'ta bir satır

Person me;

Anında varsayılan kurucu çağırır.

Python'un buna ihtiyaç duymamasının nedeni, tip sistemidir. Temel olarak, foo = bar()Python'da gördüğünüzde , bar()çağrılan bir yöntemin, başlatılan bir sınıfın mı yoksa bir functor nesnenin; Python'da, bir işlev ve işlev arasında temel bir fark yoktur (çünkü yöntemler nesnelerdir); ve bir örneğin somutlaştırılmasının bir functor olayı olduğunu bile iddia edebilirsin. Bu nedenle, olanlarda yapay bir fark yaratmak için hiçbir neden yoktur (özellikle bellek yönetimi Python'da çok gizli olduğundan).

Farklı bir yazım sistemine sahip bir dilde veya yöntem ve sınıfların nesne olmadığı bir dilde, bir nesne oluşturma ile bir işlev veya işlev çağrısı çağırma arasında daha güçlü bir kavramsal fark olasılığı vardır . Bu nedenle, derleyici / tercüman newanahtar kelimeye ihtiyaç duymasa bile , Python'un tüm sınırlarını aşmamış dillerde tutulması anlaşılabilir.

Aslında Java'da, Dizeleri kullanırken fark vardır:

String myString = "myString";

olandan farklı

String myString = new String("myString");

Dize "myString"daha önce hiç kullanılmamış olduğunu varsayalım, ilk ifade, Dize havuzunda tek bir Dize nesnesi (öbek özel bir alanı) oluştururken, ikinci ifade, biri normal nesneler için dize havuzunda diğeri de Dize havuzunda iki nesne oluşturur. . İkinci ifadenin bu özel senaryoda faydasız olduğu, ancak dilin izin verdiği oldukça açıktır.

Bu, yeni nesnenin normal nesnenin başlatılması için tahsis edilen özel bir yığın alanında yaratıldığını garanti eder, ancak nesnelerin onsuz başlatılmasının başka yolları olabilir; yukarıdaki örnek bir örnektir ve genişletilebilirlik için boş alan kalmıştır.

C # 'da, yığında yaratılan nesneler ile öbek arasındaki farkı ayırt etmek önemlidir. Sık sık, daha iyi performans için yığında nesneler oluştururuz. Yığındaki bir nesne kapsam dışına çıktığında, yığın ilkel gibi çözüldüğünde derhal yok olur. Çöp toplayıcısının izini sürmesine gerek yoktur ve öbek üzerinde gerekli alanı ayırmak için bellek yöneticisinin ek yükü yoktur.