Örnek oluşturma neden olduğu gibi?

C # 'yı son altı ay boyunca öğrendim ve şimdi Java'ya giriyorum. Sorum, örnek oluşturma (gerçekten her iki dilde) hakkında ve daha da fazlası: Neden bu şekilde yaptıklarını merak ediyorum. Bu örneği ele alalım

Person Bob = new Person();

Nesnenin iki kez belirtilmesi için bir neden var mı? Hiç var something_else Bob = new Person()mı?

Sözleşmeden takip ediyor olsaydım daha fazla olurdu:

int XIsAnInt;
Person BobIsAPerson;

Ya da belki bunlardan biri:

Person() Bob;
new Person Bob;
new Person() Bob;
Bob = new Person();

Sanırım "bu şekilde yapılıyor" ifadesinden daha iyi bir cevap olup olmadığını merak ediyorum.

Bir şey var mı? Bob = new Person ()?

Evet, miras yüzünden. Eğer:

public class StackExchangeMember : Person {}

Sonra:

Person bob = new StackExchangeMember();
Person sam = new Person();

Bob da bir kişidir ve hüzünle, herkesten farklı muamele görmek istemez.

Ayrıca, Bob'u süper güçlerle donatabiliriz:

public interface IModerator { }
public class StackOverFlowModerator : StackExchangeMember, IModerator {}

IModerator bob = new StackOverFlowModerator();

Ve böylece, kaba bir şekilde, diğer herhangi bir moderatörden farklı muamele görmesi için ayakta durmayacak. Ve gizli moddayken herkesi aynı çizgide tutmak için forumun etrafında gizlice dolaşmayı sever:

StackExchangeMember bob = new StackOverFlowModerator();

Sonra kötü bir 1. poster bulduğunda görünmezlik pelerini fırlatır ve atlar.

((StackOverFlowModerator) bob).Smite(sam);

Ve sonra tüm masum ve şeyleri daha sonra hareket edebilir:

((Person) bob).ImNotMeanIWasJustInstantiatedThatWay();

İlk kod satırınızı alıp inceleyelim.

Person Bob = new Person();

Birincisi Personbir tür belirtimidir. C # 'da, bunu sadece

var Bob = new Person();

ve derleyici olacak sonucuna yapıcı çağrısından değişken Bob türünü Person().

Ama böyle bir şey yazmak isteyebilirsiniz:

IPerson Bob = new Person();

Kişinin tüm API sözleşmesini değil, yalnızca arayüz tarafından belirtilen sözleşmeyi yerine getirdiğiniz yerdir IPerson.

1. Bu sözdizimi, C ++ 'dan bir miras, bu arada, her ikisine de sahip:

   Person Bob;

   ve

   Person *bob = new Bob();

   Geçerli kapsam içinde bir nesne yaratan ilki, ikincisi dinamik bir nesneye işaretçi yaratır.

2. Kesinlikle sahip olabilirsiniz something_else Bob = new Person()

   IEnumerable<int> nums = new List<int>(){1,2,3,4}

   Burada, yerel değişkenin türünü belirten iki farklı şey yapıyorsunuz numsve 'List' türünde yeni bir nesne oluşturmak ve oraya koymak istediğinizi söylüyorsunuz.

3. C # türü sizi kabul eder, çünkü çoğu zaman değişkenin türü, içine koyduğunuz şeyle aynıdır:

   var nums = new List<int>();

4. Bazı dillerde, F # gibi değişken türlerini belirtmekten kaçınmak için elinizden geleni yaparsınız :

   let list123 = [ 1; 2; 3 ]

int xVe arasında büyük bir fark vardır Person bob. An intbir ' intdir intve her zaman bir olmalı intve asla bir şeyden başka bir şey olamaz int. Başlatılmasanız bileintBildirdiğiniz zaman ( int x;) , yine intde varsayılan değere ayarlanmıştır.

Person bobBununla birlikte, beyan ettiğinizde, adın bobherhangi bir zamanda gerçekte ne anlama gelebileceği konusunda büyük bir esneklik vardır . A Personya da başka bir sınıfa, örneğin Programmer,Person ; nullhiç bir nesneye atıfta bulunmadan bile olabilir .

Örneğin:

  Person bob   = null;
  Person carol = new Person();
  Person ted   = new Programmer();
  Person alice = personFactory.functionThatReturnsSomeKindOfPersonOrNull();

Dil tasarımcıları kesinlikle daha Person carol = new Person()az sembolle aynı şeyi başaracak alternatif bir sözdizimi yapabilirlerdi , ancak yine de izin vermek zorunda kalacaklardı Person carol = new Person() (veya yukarıdaki dört örnekten birini yasadışı yapmak için garip bir kural koymak zorunda kalacaklardı ). Dili son derece özlü kod yazmaktan çok "basit" tutmakla daha fazla ilgileniyorlardı. Bu, daha kısa alternatif sözdizimi sağlama kararlarını etkilemiş olabilir, ancak her durumda, gerekli değildi ve vermediler.

İki bildirim farklı olabilir, ancak çoğu zaman aynıdır. Java'da yaygın olarak önerilen bir desen şöyle görünür:

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();

Bu değişkenler listve maparayüzler kullanılarak bildirilir Listve Mapkod belirli uygulamaları başlatırken. Bu şekilde, kodun geri kalanı yalnızca arayüzlere bağlıdır ve kodun TreeMapgeri kalanı arayüzün HashMapdışındaki API'nin herhangi bir kısmına bağlı olamayacağı için , örnek oluşturmak için farklı bir uygulama sınıfı seçmek kolaydır Map.

İki türün farklı olduğu diğer bir örnek, örneklemek için belirli bir alt sınıfı seçen, daha sonra bunu taban türü olarak döndüren bir fabrika yönteminde yer alır;

Tür çıkarımı kaynak kodu yedekliliğini düzeltebilir. Örneğin Java ile

List<String> listOne = Collections.emptyList();

tür çıkarımı ve beyanı sayesinde doğru türde bir liste oluşturacak

static <T> List<T> emptyList(); 

Bazı dillerde, tür çıkarım daha da ileri gider, örneğin C ++

auto p = new Person();

Layman'ın sözleriyle:

• Bildirimi somutlaştırmadan ayırmak, nesneleri kullananların onları yaratanlardan ayrılmasına yardımcı olur
• Bunu yaptığınızda, örneklenen tür bildirme türünün bir alt türü olduğu sürece, değişkeni kullanan tüm kodlar çalışacağı için polyporphism etkinleştirilir.
• Güçlü yazılan dillerde, bir değişkeni türünü bildirmeniz gerekir, bunu yaparak var = new Process()ilk önce değişkeni bildirmezsiniz.

Aynı zamanda olanları kontrol etme seviyesiyle de ilgilidir. Bir nesnenin / değişkenin bildirimi otomatik olarak bir yapıcı çağırırsa, örneğin,

Person somePerson;

olduğu otomatik aynı

Person somePerson = new Person(blah, blah..);

varsayılan kurucular yerine nesneleri somutlaştırmak için (örneğin) statik fabrika yöntemlerini hiçbir zaman kullanamazsınız, yani yeni bir nesne örneği için bir kurucu çağırmak istemediğiniz zamanlar vardır.

Bu örnek açıklanmıştır Joshua Bloch 'ın Etkili Java (Madde ironik yeterli 1!)