-
ความเหมือนและความแตกต่างระหว่าง C++ และ Java
1. ตัวชี้ ★★★★★
พอยน์เตอร์ใน C C++ ให้ความยืดหยุ่นสูง แต่ความยืดหยุ่นก็นำมาซึ่งอันตรายเช่นกัน การทำงานของพอยน์เตอร์ที่ไม่เหมาะสมอาจทำให้เกิดปัญหาได้ง่าย เช่น หน่วยความจำรั่วหรือพอยน์เตอร์ห้อย
Java ยกเลิกพอยน์เตอร์ แต่ในความเป็นจริงแล้ว ชื่อของประเภทข้อมูลอ้างอิงทั้งหมดที่ประกาศใน Java สามารถเข้าใจได้ว่าเป็นพอยน์เตอร์ ชื่อจะถูกเก็บไว้ในหน่วยความจำสแต็กและชี้ไปยังพื้นที่ที่เปิดโดยสิ่งใหม่ในหน่วยความจำ
ชอบ:
int[] array = ใหม่ int[10]
อาร์เรย์ชื่ออาร์เรย์จำนวนเต็มอยู่บนหน่วยความจำสแต็ก และพื้นที่ 10*4 ไบต์ถูกเปิดบนหน่วยความจำฮีป และอาร์เรย์ชี้ไปที่บล็อกของหน่วยความจำ
อาร์เรย์สามารถเข้าใจได้ว่าเป็นตัวชี้ และที่อยู่ที่เก็บไว้ในนั้นคือพื้นที่ที่สร้างขึ้นโดยใหม่
ชอบ:
บุคคลในชั้นเรียน{
-
-
บุคคล p = บุคคลใหม่ ();
ชื่อวัตถุ p ถูกเปิดในหน่วยความจำสแต็ก และใช้ใหม่เพื่อเปิดพื้นที่ในหน่วยความจำฮีปสำหรับวัตถุ ชื่อวัตถุ p ชี้ไปที่หน่วยความจำฮีป
แต่ในความเป็นจริงแล้ว ชื่อไม่เหมือนกับตัวชี้ในภาษา C++ โดยเฉพาะเมื่อส่งพารามิเตอร์
Java ระบุว่าการส่งพารามิเตอร์นั้นขึ้นอยู่กับค่าทั้งหมด
แต่เมื่อใช้ประเภทข้อมูลอ้างอิงเป็นพารามิเตอร์ของฟังก์ชัน เมื่อส่งผ่านอ็อบเจ็กต์ p1 ไปแล้ว สำเนาของอ็อบเจ็กต์ p2 จะถูกสร้างขึ้นจริง ๆ p2 นี้ชี้ไปที่ p1 ดังนั้นเมื่อเรียกสมาชิกของ p1 ถึง p2 ก็สามารถทำได้ ให้เสร็จสิ้น แก้ไข รอจนกว่าการเรียกใช้ฟังก์ชันจะเสร็จสิ้น และคงการแก้ไขไว้ ชอบ:
บุคคลในชั้นเรียน{
ชื่อสตริงสาธารณะ
อายุสาธารณะ ;
บุคคลสาธารณะ (ชื่อสตริง, อายุ int) {
this.name = ชื่อ;
this.age = อายุ;
-
-
การทดสอบในชั้นเรียนสาธารณะ{
โมฆะคงที่สาธารณะ main (String [] args) {
บุคคล p = บุคคลใหม่ ("จางซาน", 10);
System.out.println("ก่อนแก้ไข-->ชื่อ: "+ p.name+", อายุ: "+p.age);
changePro(p); //Object p ถูกส่งผ่าน และสร้างสำเนาของ p ขึ้นมา สมมติว่าเป็น p1 ซึ่งชี้ไปที่ p //ผ่านสำเนานี้ p1 สมาชิกของ p สามารถเรียกได้
System.out.println("หลังจากแก้ไข-->ชื่อ: "+ p.name+", อายุ: "+p.age);
-
โมฆะสาธารณะคงที่ changePro (บุคคล p) {// สมาชิกของวัตถุต้นฉบับสามารถเรียกผ่านการคัดลอก
p.name = "李思";
หน้าอายุ = 30;
-
-
ผลลัพธ์:
ก่อนแก้ไข-->ชื่อ: จางซาน อายุ: 10 ปี
หลังแก้ไข-->ชื่อ: หลี่ซือ อายุ: 30
แต่เมื่อคุณส่ง p1 เข้าไป สำเนาของ p2 จะถูกสร้างขึ้น และการพยายามเปลี่ยนการชี้ของ p1 ถึง p2 นั้นเป็นไปไม่ได้อย่างเห็นได้ชัด ในเวลานี้ มีเพียงการชี้ของ p2 เท่านั้นที่เปลี่ยนไป หลังจากการเรียกใช้ฟังก์ชันเสร็จสิ้น การชี้ ของ p1 ยังคงไม่เปลี่ยนแปลง ชอบ:
บุคคลในชั้นเรียน{
ชื่อสตริงสาธารณะ
อายุสาธารณะ ;
บุคคลสาธารณะ (ชื่อสตริง, อายุ int) {
this.name = ชื่อ;
this.age = อายุ;
-
-
การทดสอบในชั้นเรียนสาธารณะ{
โมฆะคงที่สาธารณะ main (String [] args) {
บุคคล p = บุคคลใหม่ ("จางซาน", 10);
System.out.println("ก่อนแก้ไข-->ชื่อ: "+ p.name+", อายุ: "+p.age);
changeObj(p); //วัตถุ p ถูกส่งผ่านเข้ามา ซึ่งเป็นสำเนาของ p สมมติว่าเป็น p1 ซึ่งชี้ไปที่ p //ในฟังก์ชัน เฉพาะตัวชี้ของสำเนานี้เท่านั้นที่มีการเปลี่ยนแปลง
System.out.println("หลังจากแก้ไข-->ชื่อ: "+ p.name+", อายุ: "+p.age);
-
บุคคลคงที่สาธารณะ newP = บุคคลใหม่ ("李思", 30);
โมฆะสาธารณะคงที่ changeObj (บุคคล p) {
p = newP; // พยายามเปลี่ยนพอยน์เตอร์ แต่สิ่งที่เปลี่ยนแปลงจริงๆ คือพอยน์เตอร์ของการคัดลอก
//หลังจากฟังก์ชันสิ้นสุดลง การชี้ของวัตถุต้นฉบับจะไม่เปลี่ยนแปลง
-
-
ผลลัพธ์:
ก่อนแก้ไข-->ชื่อ: จางซาน อายุ: 10 ปี
หลังแก้ไข-->ชื่อ: จางซาน อายุ: 10 ปี
2. การจัดสรรหน่วยความจำแบบไดนามิก
ใน C ++ จะใช้ใหม่และลบเพื่อจัดสรรและรีไซเคิลหน่วยความจำแบบไดนามิก ใหม่ คือการเปิดพื้นที่บนหน่วยความจำฮีป หลังจากใช้หน่วยความจำแล้ว ต้องใช้การลบด้วยตนเองเพื่อรีไซเคิล
ตราบใดที่มีการประกาศประเภทข้อมูลอ้างอิงใน Java จะต้องใช้ใหม่เพื่อเปิดพื้นที่หน่วยความจำก่อนใช้งาน แต่หลังจากที่วัตถุนั้นตาย ก็ไม่จำเป็นต้องเรียกคืนหน่วยความจำด้วยตนเอง กลไกการรีไซเคิลหน่วยความจำของ Java จะรีไซเคิลอ็อบเจ็กต์ขยะโดยอัตโนมัติ (สิ่งที่เรียกว่าอ็อบเจ็กต์ขยะอ้างถึงหน่วยความจำอ็อบเจ็กต์ที่เปิดไว้ก่อนหน้านี้ ซึ่งไม่ได้อ้างอิงโดยหน่วยความจำสแต็กอีกต่อไป) แน่นอนว่า การรีไซเคิลด้วยตนเองสามารถทำได้โดยใช้วิธี System.gc()
3. ผู้ทำลายล้าง
ฟังก์ชั่นของตัวทำลาย C++ (ไม่มีพารามิเตอร์ ไม่มีค่าส่งคืน) คือการปล่อยพื้นที่หน่วยความจำที่จัดสรรแบบไดนามิกในตัวสร้าง นั่นคือเพื่อเรียก (การเรียกนี้สามารถเรียกผ่านอ็อบเจ็กต์ destructor หรือระบบสามารถรอโดยอัตโนมัติจนกว่า อายุการใช้งานของวัตถุสิ้นสุดลง โทร) destructor
ไม่มีตัวทำลายใน Java และอ็อบเจ็กต์ขยะจะถูกรีไซเคิลโดยอัตโนมัติผ่านกลไกการรวบรวมขยะ อย่างไรก็ตาม คุณสามารถบรรลุผลแบบเดียวกับ destructor ใน C++ ได้โดยการแทนที่เมธอด fanalize() ในคลาส Object เมื่อวัตถุถูกทำลายด้วยตนเองหรือโดยอัตโนมัติ เมธอด fanalize() จะถูกเรียกโดยอัตโนมัติ
4.เนื้อหาในชั้นเรียนว่าง
คลาสว่างของ C++ ต้องมี 4 ฟังก์ชัน: ตัวสร้างเริ่มต้น ตัวทำลายเริ่มต้น และตัวสร้างการคัดลอกเริ่มต้น
คลาสว่างของ Java ประกอบด้วย: Constructor เริ่มต้น, เมธอดที่สืบทอดมาจากคลาส Object เช่น
คุณลักษณะเริ่มต้นในคลาส มีสิทธิ์การเข้าถึงของสมาชิกสามประเภทในคลาส C++: public>protected>private หากไม่ได้ประกาศ การอนุญาตเริ่มต้นจะเป็นแบบส่วนตัว
สิทธิ์การเข้าถึงของสมาชิกมีสี่ประเภทในคลาส Java: public>protected>defalt>private ค่าเริ่มต้นคือการอนุญาตเริ่มต้น
5. การใช้งานฟังก์ชั่นสมาชิกในชั้นเรียน
เป็นเรื่องปกติในภาษา C++ h ฟังก์ชั่นถูกประกาศในคลาสของไฟล์ส่วนหัว; หากต้องการใช้ฟังก์ชันในไฟล์ cpp ให้ #include ไฟล์ส่วนหัว
ชอบ:
//demo.h
บุคคลในชั้นเรียน{
สาธารณะ:
ถือเป็นโมฆะ(); //ประกาศในชั้นเรียน
-
//demo.cpp
#รวม “demo.h”
Void Person::fun(){/ // การใช้งานภายนอกคลาส
- - - - //เนื้อหาการดำเนินการ
-
Java เป็นวิธีการประกาศ + การใช้งานในคลาส หากไม่ได้นำไปใช้ในคลาส การเพิ่มคีย์เวิร์ด abstract ถือเป็นวิธี abstract
ชอบ:
บุคคลในชั้นเรียน{
Public void fun(){//Declaration + การนำไปใช้ในชั้นเรียน
- - - - //เนื้อหาการดำเนินการ
-
-
6. การสร้างอินสแตนซ์ของวัตถุ
บุคคลในชั้นเรียน{
ส่วนตัว:
อายุจริง;
สาธารณะ:
บุคคล(){}
บุคคล (int a) {
อายุ = ก ;
-
สนุกเป็นโมฆะ(){….}
-
- - - - //เริ่มต้นฟังก์ชันหลัก
บุคคล p1; // เรียกตัวสร้างที่ไม่มีพารามิเตอร์
บุคคล p2 (18); // เรียกตัวสร้างพารามิเตอร์
p1.fun(); //เรียกฟังก์ชันสมาชิก
p2.สนุก();
หากต้องการสร้างอินสแตนซ์ของอ็อบเจ็กต์ใน Java คุณต้องใช้คีย์เวิร์ดใหม่
บุคคลในชั้นเรียน{
ชื่อสตริงส่วนตัว
อายุ int ส่วนตัว ;
บุคคลสาธารณะ(){}
บุคคลสาธารณะ (ชื่อสตริง, อายุ int) {
this.name = ชื่อ;
this.age = อายุ;
-
สนุกเป็นโมฆะสาธารณะ () {… .. }
-
- - - - - //เริ่มต้นฟังก์ชันหลัก
บุคคล p1 = โมฆะ ;
p1 = new Person(); // คุณต้องใช้คีย์เวิร์ดใหม่เพื่อเปิดพื้นที่หน่วยความจำและเรียก Constructor แบบไม่มีพารามิเตอร์
บุคคล p2 = บุคคลใหม่ ("จางซาน", 18); // เรียกตัวสร้างพารามิเตอร์
p1.fun(); // วิธีการโทร
p2.สนุก();
7. คำสำคัญนี้
มันถูกเรียกว่าตัวชี้นี้ในภาษา C++ เมื่อวัตถุถูกสร้างอินสแตนซ์ ตัวชี้นี้จะถูกสร้างขึ้นโดยค่าเริ่มต้นเพื่อชี้ไปที่วัตถุนี้ คอมไพเลอร์ใช้เพื่อแยกแยะวัตถุต่าง ๆ ของคลาสเดียวกัน นั่นก็คือเป็นวัตถุ เมื่อใช้ฟังก์ชันสมาชิก คุณจะรู้ว่าวัตถุใดผ่านตัวชี้นี้ และเรียกใช้ฟังก์ชันสมาชิกเพื่อดำเนินการคุณสมบัติสมาชิกของวัตถุ
สิ่งนี้มีประโยชน์สามประการใน Java:
1. แสดงถึงคุณลักษณะหรือวิธีการในชั้นนี้ เช่นนี้. วิธีการนี้. คุณสมบัติ.
2. แสดงถึงวัตถุปัจจุบัน
3. เรียกเมธอด Constructor ของคลาสนี้ เช่น this(), this(parameter 1, parameter 2...)
[ฟังก์ชั่นการใช้งาน 1 และ 2 คล้ายกับตัวชี้นี้ใน C ++ -
8. การเรียกสมาชิกของวัตถุ
C ++ ส่งผ่านวัตถุ ฟังก์ชันสมาชิกหรือตัวชี้คลาส -> ฟังก์ชันสมาชิกที่จะโทร
ใน Java คุณสามารถส่งผ่านวัตถุได้เท่านั้น การเรียกใช้ฟังก์ชันสมาชิก
สมาชิกของแอตทริบิวต์แบบคงที่ของทั้งสองสามารถส่งผ่านชื่อคลาสได้โดยตรง ฟังก์ชันสมาชิกจะถูกเรียกโดยตรง
9. คลาสย่อย-->คลาสพาเรนต์ พารามิเตอร์ที่ส่งผ่านโดยคอนสตรัคเตอร์มีบางอย่างที่เหมือนกัน: หากคอนสตรัคเตอร์ในคลาสย่อยไม่ได้ระบุอย่างชัดเจนว่าคอนสตรัคเตอร์ตัวใดของคลาสพาเรนต์ที่จะเรียก ระบบจะใช้ค่าเริ่มต้นในการเรียกคอนสตรัคเตอร์แบบไม่มีพารามิเตอร์ของพาเรนต์ ระดับ. ในเวลาเดียวกัน หากคลาสพาเรนต์กำหนดคอนสตรัคเตอร์ด้วยพารามิเตอร์ วิธีที่ดีที่สุดคือกำหนดคอนสตรัคเตอร์โดยไม่มีพารามิเตอร์
บุคคลในชั้นเรียน{
ส่วนตัว:
อายุจริง;
สาธารณะ:
บุคคล(){}
บุคคล (int a) {
อายุ = ก ;
-
-
นักศึกษาชั้น: บุคคลสาธารณะ{
ส่วนตัว:
คะแนนอินท์ ;
สาธารณะ:
Student(int a, int s):Person(a){ //ส่งผ่านไปยังตัวสร้างคลาสหลัก
คะแนน = s;
-
-
บุคคลในชั้นเรียน{
ชื่อสตริงส่วนตัว
อายุ int ส่วนตัว ;
บุคคลสาธารณะ(){}
บุคคลสาธารณะ (ชื่อสตริง, อายุ int) {
this.name = ชื่อ;
this.age = อายุ;
-
-
นักเรียนชั้นขยายบุคคล{
คะแนน int ส่วนตัว
นักเรียนสาธารณะ (ชื่อสตริง, อายุ int, คะแนน int) {
super (ชื่อ, อายุ); // ส่งผ่านไปยังตัวสร้างคลาสหลัก
this.score = คะแนน;
-
-
10. ความแตกต่าง
ความหลากหลายใน C++ จะต้องบรรลุโดย [ฟังก์ชันเสมือนหรือฟังก์ชันเสมือนแท้ + การครอบคลุมคลาสย่อยของฟังก์ชันเสมือนหรือฟังก์ชันเสมือนแท้]
ฟังก์ชั่นเสมือนถูกประกาศด้วย virtual,
ชอบ:
virtual void fun(); //ประกาศภายในคลาส
ชื่อคลาสเป็นโมฆะ: fun() {….}//การใช้งานนอกคลาส
Java ใช้คลาสย่อยเพื่อแทนที่วิธีธรรมดาในคลาสพาเรนต์ทั่วไป คลาสย่อยเพื่อแทนที่วิธีธรรมดาหรือวิธีนามธรรมในคลาสนามธรรม และคลาสย่อยเพื่อแทนที่วิธีนามธรรมในอินเทอร์เฟซ + แปลงร่างขึ้น
วิธีการเชิงนามธรรมถูกประกาศด้วยนามธรรมและไม่มีการนำเนื้อหาไปใช้
ชอบ:
abstract void fun(); //ไม่มีการใช้งานภายในคลาส
11. คลาสนามธรรม คลาสนามธรรมทั้งสองคลาสไม่สามารถสร้างอินสแตนซ์ของวัตถุได้ ฟังก์ชันเสมือนแท้และวิธีการเชิงนามธรรมมีแนวคิดและฟังก์ชันที่คล้ายคลึงกัน
อาจกล่าวได้ว่ามีคลาสนามธรรมใน C++ ซึ่งเป็นคลาสที่มีฟังก์ชันเสมือนล้วนๆ
ฟังก์ชันเสมือนล้วนเป็นฟังก์ชันเสมือนที่ไม่มีการใช้เนื้อหาและ "=0" และไม่สามารถสร้างอินสแตนซ์ของวัตถุได้
ชอบ:
virtual void fun() = 0; // ประกาศเป็น =0 ภายในคลาส แต่จะไม่นำไปใช้ภายนอกคลาส
คลาสนามธรรมใน Java เป็นคลาสที่ประกาศด้วยคีย์เวิร์ด abstract และมีวิธีการแบบนามธรรม ไม่สามารถสร้างอินสแตนซ์ของวัตถุได้
อินเทอร์เฟซใน Java เป็นคลาสพิเศษหรือคลาสนามธรรมพิเศษ ประกอบด้วยค่าคงที่คงที่และฟังก์ชันนามธรรมทั้งหมด
12. สิทธิ์การเข้าถึง
C++ ใช้วิธีการสืบทอดสามวิธีเพื่อเปลี่ยนสิทธิ์การเข้าถึงของสมาชิกระหว่างคลาสย่อยและคลาสพาเรนต์
นักศึกษาชั้น: บุคคลสาธารณะ{
สาธารณะ:
- - - - - -
ส่วนตัว:
- - - - - -
-
คนงานในชั้นเรียน: บุคคลที่ได้รับการคุ้มครอง {
สาธารณะ:
- - - - - -
ส่วนตัว:
- - - - - -
-
เกษตรกรระดับ: บุคคลธรรมดา{
สาธารณะ:
- - - - - -
ส่วนตัว:
- - - - - -
-
Java ใช้สิทธิ์การเข้าถึงให้กับสมาชิกระหว่างคลาสที่แตกต่างกันผ่านกลไกแพ็คเกจ
แพ็คเกจ org.tyut.a
บุคคลในชั้นเรียน{
ส่วนตัว…..
ส่วนตัว……
สาธารณะ…….
สาธารณะ…
-
แพ็คเกจ org.tuyt.b
บุคคลในชั้นเรียน{
ส่วนตัว…..
ส่วนตัว……
สาธารณะ…….
สาธารณะ…
-
แพ็คเกจ org.tuyt.c
บุคคลในชั้นเรียน{
ส่วนตัว…..
ส่วนตัว……
สาธารณะ…….
สาธารณะ…
-
13. แนวคิดของแพ็คเกจการประมวลผลล่วงหน้าและนำเข้า Java ของ C++ นั้นเหมือนกัน: เมื่อคุณต้องการใช้คลาสอื่นที่ไม่ใช่คลาสปัจจุบัน
ใน C++ ให้ใช้คำสั่ง #include ก่อนการคอมไพล์ล่วงหน้าของคลาสเพื่อรวมไลบรารีของคลาสที่จะรวมไว้ด้วย
ไลบรารีคลาสมาตรฐานใช้วงเล็บเหลี่ยม < > โดยไม่มี h ใช้เครื่องหมายคำพูดคู่ "" กับ h ในไลบรารีคลาสที่กำหนดเอง และจะถูกค้นหาจากเส้นทางปัจจุบันก่อน
ชอบ:
#รวม <iostream>
#รวม “demo.h”
ใน Java หากต้องการนำเข้าคลาสที่คุณต้องการใช้ ให้ใช้คำสั่งนำเข้าและระบุแพ็คเกจที่มีคลาสนั้นอยู่
ชอบ:
นำเข้าจาวา หรั่ง. -
นำเข้าองค์กร คุณ -