เหตุใดการสร้างอินสแตนซ์จึงเป็นแบบนี้

ฉันได้เรียนรู้ C # ในช่วงหกเดือนที่ผ่านมาและตอนนี้ฉันกำลังขุดหา Java คำถามของฉันเกี่ยวกับการสร้างอินสแตนซ์ (ในทั้งสองภาษาจริง ๆ ) และมีมากกว่า: ฉันสงสัยว่าทำไมพวกเขาถึงทำแบบนั้น นำตัวอย่างนี้

Person Bob = new Person();

มีเหตุผลที่ระบุวัตถุสองครั้งหรือไม่ เคยมีsomething_else Bob = new Person()บ้างไหม?

ดูเหมือนว่าถ้าฉันทำตามจากการประชุมมันจะเป็นเหมือน:

int XIsAnInt;
Person BobIsAPerson;

หรืออาจเป็นหนึ่งในสิ่งเหล่านี้:

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

ฉันคิดว่าฉันอยากรู้ว่าถ้ามีคำตอบที่ดีกว่า "นั่นเป็นเพียงวิธีที่มันทำ"

จะมีบางสิ่งที่ Bob = คนใหม่ ()?

ใช่เพราะมรดก ถ้า:

public class StackExchangeMember : Person {}

แล้ว:

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

บ๊อบก็เป็นคนเช่นกันและด้วยความเขลาเขาไม่ต้องการได้รับการปฏิบัติที่แตกต่างจากคนอื่น

นอกจากนี้เราสามารถมอบบ๊อบด้วยพลังพิเศษได้:

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

IModerator bob = new StackOverFlowModerator();

ดังนั้นโดย golly เขาจะไม่ยืนรับการปฏิบัติที่แตกต่างจากผู้ดูแลคนอื่น ๆ และเขาชอบแอบไปรอบ ๆ ฟอรัมเพื่อให้ทุกคนอยู่ในบรรทัดขณะที่ไม่ระบุตัวตน:

StackExchangeMember bob = new StackOverFlowModerator();

จากนั้นเมื่อเขาพบโปสเตอร์แรกที่ไม่ดีเขาก็โยนเสื้อคลุมล่องหนของเขาออกมา

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

จากนั้นเขาก็สามารถแสดงความไร้เดียงสาและทุกสิ่งได้ในภายหลัง:

((Person) bob).ImNotMeanIWasJustInstantiatedThatWay();

ลองนำโค้ดบรรทัดแรกของคุณมาตรวจสอบดู

Person Bob = new Person();

ที่แรกPersonก็คือสเปคประเภท ใน C # เราสามารถจัดการกับสิ่งนี้โดยเพียงแค่พูดว่า

var Bob = new Person();

และเรียบเรียงจะอนุมานPerson()ประเภทของตัวแปรบ๊อบจากการเรียกตัวสร้าง

แต่คุณอาจต้องการเขียนสิ่งนี้:

IPerson Bob = new Person();

ที่คุณไม่ปฏิบัติตามสัญญา API ทั้งหมดของบุคคล IPersonแต่สัญญาที่ระบุโดยอินเตอร์เฟซ

1. ไวยากรณ์นี้ค่อนข้างเก่าจาก C ++ ซึ่งทั้งสองมี:

   Person Bob;

   และ

   Person *bob = new Bob();

   คนแรกที่สร้างวัตถุภายในขอบเขตปัจจุบันที่สองเพื่อสร้างตัวชี้ไปยังวัตถุแบบไดนามิก

2. คุณสามารถมีได้แน่นอน something_else Bob = new Person()

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

   คุณกำลังทำสองสิ่งที่แตกต่างกันที่นี่ระบุประเภทของตัวแปรท้องถิ่นnumsและคุณบอกว่าคุณต้องการสร้างวัตถุใหม่ของ 'รายการ' ประเภทและวางไว้ที่นั่น

3. ชนิดC #เห็นด้วยกับคุณเพราะส่วนใหญ่เวลาชนิดของตัวแปรจะเหมือนกันกับสิ่งที่คุณใส่มันดังนั้น:

   var nums = new List<int>();

4. ในบางภาษาคุณทำอย่างดีที่สุดเพื่อหลีกเลี่ยงการระบุประเภทของตัวแปรเช่นในF # :

   let list123 = [ 1; 2; 3 ]

มีความแตกต่างกันมากระหว่างเป็นและint x เป็นเป็นและมันก็จะต้องเป็นและไม่เคยได้อะไรอื่นนอกจาก แม้ว่าคุณจะไม่เริ่มต้นเมื่อคุณประกาศมัน ( ) มันยังคงตั้งค่าเป็นค่าเริ่มต้นPerson bobintintintintintintint x;int

อย่างไรก็ตามเมื่อคุณประกาศPerson bobมีความยืดหยุ่นอย่างมากกับสิ่งที่ชื่อbobอาจอ้างถึงในเวลาใดก็ตาม มันสามารถอ้างถึงPersonหรือมันอาจหมายถึงชั้นอื่น ๆ เช่นProgrammerมาจากPerson; มันอาจnullหมายถึงไม่มีวัตถุใด ๆ เลย

ตัวอย่างเช่น:

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

นักออกแบบภาษาสามารถสร้างไวยากรณ์ทางเลือกที่จะทำให้สิ่งเดียวกันเป็นPerson carol = new Person()สัญลักษณ์ที่น้อยลง แต่พวกเขายังคงต้องยอมให้Person carol = new Person() (หรือสร้างกฎแปลก ๆ ที่ทำให้หนึ่งในสี่ตัวอย่างข้างต้นผิดกฎหมาย) พวกเขากังวลกับการรักษาภาษา "ง่าย" มากกว่าในการเขียนรหัสที่รัดกุมมาก นั่นอาจมีอิทธิพลต่อการตัดสินใจของพวกเขาที่จะไม่ให้ทางเลือกทางเลือกที่สั้นกว่า แต่ในกรณีใด ๆ มันไม่จำเป็นและพวกเขาไม่ได้ให้มัน

การประกาศสองครั้งอาจแตกต่างกัน แต่มักจะเหมือนกัน รูปแบบทั่วไปที่แนะนำใน Java ดูเหมือนว่า:

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

ตัวแปรเหล่านี้listและmapถูกประกาศโดยใช้อินเตอร์เฟสListและMapในขณะที่รหัสจะทำให้การใช้งานที่เฉพาะเจาะจงเป็นอินสแตนซ์ ด้วยวิธีนี้ส่วนที่เหลือของรหัสขึ้นอยู่กับอินเทอร์เฟซและง่ายต่อการเลือกคลาสการใช้งานที่แตกต่างกันเพื่ออินสแตนซ์TreeMapเนื่องจากส่วนที่เหลือของรหัสไม่สามารถขึ้นอยู่กับส่วนใดส่วนหนึ่งของHashMapAPI ที่อยู่นอกMapอินเทอร์เฟซ

อีกตัวอย่างหนึ่งที่ทั้งสองประเภทแตกต่างกันในวิธีการของโรงงานที่เลือกคลาสย่อยเฉพาะเพื่อสร้างอินสแตนซ์จากนั้นส่งคืนเป็นประเภทฐานเพื่อให้ผู้โทรไม่จำเป็นต้องทราบรายละเอียดการใช้งานเช่นตัวเลือก "นโยบาย"

การอนุมานชนิดสามารถแก้ไขความซ้ำซ้อนของซอร์สโค้ดได้ เช่นใน Java

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

จะสร้างรายการที่เหมาะสมโดยใช้การอนุมานและการประกาศ

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

ในบางภาษาการอนุมานประเภทจะดำเนินต่อไปเช่นใน C ++

auto p = new Person();

ในคำพูดของคนธรรมดา:

• การแยกการประกาศจาก instantiation ช่วย decouple ผู้ใช้วัตถุจากผู้ที่สร้างพวกเขา
• เมื่อคุณทำเช่นนั้น polyporphism จะถูกเปิดใช้งานตราบใดที่ชนิดอินสแตนซ์เป็นประเภทย่อยของประเภทการประกาศรหัสทั้งหมดที่ใช้ตัวแปรจะทำงานได้
• ในภาษาที่พิมพ์อย่างรุนแรงคุณจะต้องประกาศตัวแปรที่ระบุชนิดของมันโดยทำเพียงแค่var = new Process()คุณไม่ได้ประกาศตัวแปรก่อน

นอกจากนี้ยังเกี่ยวกับระดับการควบคุมสิ่งที่เกิดขึ้น หากการประกาศของวัตถุ / ตัวแปรเรียกตัวสร้างโดยอัตโนมัติเช่นถ้า

Person somePerson;

เป็นอัตโนมัติเช่นเดียวกับ

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

จากนั้นคุณจะไม่สามารถใช้ (ตัวอย่าง) วิธีคงที่จากโรงงานเพื่อสร้างอินสแตนซ์ของวัตถุแทนตัวสร้างเริ่มต้นนั่นคือมีบางครั้งที่คุณไม่ต้องการเรียกตัวสร้างสำหรับอินสแตนซ์วัตถุใหม่

ตัวอย่างนี้มีการอธิบายในJava ที่มีประสิทธิภาพของJoshua Bloch (รายการ 1 แดกดันพอ!)