هذا محتوى جديد تم تقديمه بعد jdk1.5 وبما أنني أصر على أن النشر هو أفضل ذاكرة، فقد قررت استبدال ذاكرتي بمدونة:
تقول مواصفات لغة جافا: في كثير من الحالات، يتم إجراء عملية التعبئة والتفريغ بواسطة المترجم نفسه (في هذه الحالة تسمى عملية التعبئة والتغليف بالملاكمة، ويسمى التفريغ بالتفريغ)؛
في الواقع، وفقًا لفهمي الخاص، يمكن فهم الملاكمة التلقائية ببساطة على أنها تغليف أنواع البيانات الأساسية في أنواع الكائنات لتتوافق مع اتجاه كائن Java، على سبيل المثال، استخدم int كمثال:
انسخ رمز الكود كما يلي:
// قم بتعريف كائن عدد صحيح
عدد صحيح = 10؛
// يستخدم البيان أعلاه الملاكمة التلقائية: parsed as
Integer num = new Integer(10); ما ورد أعلاه هو مثال جيد، لأن 10 ينتمي إلى نوع البيانات الأساسي، من حيث المبدأ، لا يمكن تعيينه مباشرة إلى كائن Integer، ولكن بعد jdk1.5 يمكنك القيام بهذا البيان. هو سحر التشغيل التلقائي لتحويل أنواع البيانات الأساسية تلقائيًا إلى أنواع مغلفة مقابلة. بعد أن تصبح كائنًا، يمكنك استدعاء جميع الطرق المعلنة بواسطة الكائن لإخراجه تلقائيًا: ومن هنا الاسم، يعني إعادة تحويل الكائن إلى نوع بيانات أساسي:
//ملاكمة
عدد صحيح = 10؛
//فتح العلبة
int num1 = num; الاستخدام النموذجي جدًا للفتح التلقائي هو عند إجراء العمليات: لأن الكائنات لا يتم تشغيلها بشكل مباشر، ولكن يجب تحويلها إلى أنواع بيانات أساسية قبل إجراء عمليات الجمع والطرح والضرب والقسمة.
عدد صحيح = 10؛
// الفتح التلقائي يكون ضمنيًا عند إجراء العمليات الحسابية
System.out.print(num--); هاها، يجب أن يبدو الأمر بسيطًا جدًا الآن سأتحدث عن شيء أكثر صعوبة.
// الأرقام بالخارج -128~127
عدد صحيح num1 = 297؛ عدد صحيح num2 = 297؛
System.out.println("num1==num2: "+(num1==num2));
// الرقم ضمن -128~127
عدد صحيح num3 = 97؛ عدد صحيح num4 = 97؛
System.out.println("num3==num4: "+(num3==num4)); النتيجة المطبوعة هي: num1==num2: false num3==num4: true
إنه أمر غريب: ويرجع ذلك إلى تصميم Java للملاكمة التلقائية وفك عدد صحيح و int وهو وضع: يسمى وضع وزن الذبابة (وزن الذبابة).
من أجل زيادة إعادة استخدام الأرقام البسيطة، تحدد Java: أثناء الملاكمة التلقائية، للقيم بين 128 و127، بعد وضعها في كائنات عدد صحيح، سيتم تخزينها في الذاكرة لإعادة استخدامها، وسيكون هناك دائمًا واحد فقط إذا تجاوزت القيمة بين 128 و 127، فلن يتم إعادة استخدام الكائن الصحيح المعبأ، وهو ما يعادل إنشاء كائن عدد صحيح جديد في كل مرة يتم وضعها في المربع، والظاهرة المذكورة أعلاه ناتجة عن استخدام autoboxing، إذا كنت لا تستخدم autoboxing، ولكنك تستخدم new لإنشاء مثيل مثل فئة عامة، فسيتم إنشاء كائن جديد في كل مرة جديد؛
لا يتم استخدام هذه الملاكمة والفتح التلقائي في أنواع البيانات الأساسية فحسب، بل أيضًا في فئة السلسلة، على سبيل المثال، عندما نعلن غالبًا عن كائن سلسلة:
انسخ رمز الكود كما يلي:
سلسلة str = "sl";
// استبدل طريقة الإعلان التالية
String str = new String("sl");
تعتبر العلبة التلقائية وإلغاء علبتها لأنواع البيانات الأساسية (البدائية) من الوظائف المتوفرة منذ J2SE 5.0. على الرغم من أنه يوفر لك الراحة في حزم أنواع البيانات الأساسية، إلا أنه يخفي التفاصيل أيضًا. يوصى باستخدامه فقط عندما تتمكن من التمييز بين أنواع البيانات الأساسية والكائنات.
autoboxing وunboxing
في Java، كل شيء تقريبًا تتم معالجته هو كائن (كائن). على سبيل المثال، الماسح الضوئي المستخدم من قبل هو كائن، والسلسلة (String) هي أيضًا كائن. ومع ذلك، فإن أنواع البيانات الأساسية ليست كائنات، أي المتغيرات التي تحددها باستخدام int، double، boolean، وما إلى ذلك، والثوابت الحرفية التي تكتبها مباشرة.
في القسم السابق، رأينا تقريبًا مدى ملاءمة تشغيل الكائنات، وأي شخص يستخدم Java لفترة من الوقت يعرف أنه في بعض الأحيان يكون من الضروري تحويل أنواع البيانات الأساسية إلى كائنات. على سبيل المثال، عند استخدام طريقة put() لكائن Map، فإن المعلمات التي يجب تمريرها هي كائنات وليست أنواع بيانات أساسية.
تحتاج إلى استخدام أنواع الغلاف (أنواع الغلاف) لتغليف أنواع البيانات الأساسية في كائنات. في القسم السابق، تعلم بالفعل أنه قبل J2SE 5.0، تحتاج إلى استخدام العبارة التالية لالتفاف int في كائن عدد صحيح: Integer integer = new عدد صحيح(10) ؛
يتم توفير وظيفة الملاكمة التلقائية بعد J2SE 5.0. يمكنك استخدام العبارة التالية مباشرة لحزم أنواع البيانات الأساسية: Integer integer = 10;
عند التجميع، سيحدد المترجم تلقائيًا ما إذا كان سيتم إجراء الملاكمة التلقائية بناءً على البيانات التي كتبتها. في المثال أعلاه، يشير عدد صحيح إلى مثيل لفئة عدد صحيح. يمكن تطبيق نفس الإجراء على أنواع البيانات الأساسية مثل boolean، byte، short، char، long، float، double، إلخ. أنواع الأغلفة المقابلة (أنواع المجمعات) Boolean، Byte، Short، Character، Long، Float أو Double سوف استخدامها على التوالي. دعونا نستخدم مباشرة وظيفة autoboxing لإعادة كتابة المثال 4.4.
مثال 4.5 AutoBoxDemo.java
انسخ رمز الكود كما يلي:
الطبقة العامة AutoBoxDemo {
public static void main(String[] args) {
عدد صحيح data1 = 10؛
عدد صحيح data2 = 20؛
// تحويل إلى قيمة مضاعفة وتقسيمها على 3
System.out.println(data1.doubleValue() / 3);
// قارن بين قيمتين
System.out.println(data1.compareTo(data2));
}
}
يبدو البرنامج أبسط بكثير، data1 وdata2 هما مثيلان لـ Integer في وقت التشغيل ويمكنهما إجراء عمليات الكائن مباشرة. والنتيجة هي كما يلي:
3.3333333333333335
1
ويمكن أيضًا أن تكون طريقة استخدام الملاكمة الأوتوماتيكية كما يلي:
انسخ رمز الكود كما يلي:
إنت ط = 10؛
عدد صحيح عدد صحيح = أنا؛
يمكنك أيضًا استخدام فئة java.lang.Number الأكثر عمومية للتشغيل التلقائي. على سبيل المثال:
رقم الرقم = 3.14f؛
سيتم وضع 3.14f تلقائيًا في مربع Float ثم يتم تعيينه إلى رقم.
بدءًا من J2SE 5.0، تتوفر الملاكمة التلقائية والفتح التلقائي، أي أن معلومات نموذج البيانات الأساسية في الكائن يتم إخراجها تلقائيًا من الكائن. على سبيل المثال من الممكن كتابة ما يلي:
انسخ رمز الكود كما يلي:
عدد صحيح fooInteger = 10؛
int fooPrimitive = fooInteger;
بعد الإشارة إلى fooInteger إلى مثيل يتم وضعه في مربع تلقائيًا كعدد صحيح، إذا تم تعيينه لمتغير fooPrimitive من النوع int، فسيتم تغييره تلقائيًا إلى كتابة int ثم تعيينه إلى fooPrimitive. أثناء التشغيل، يمكن أيضًا إجراء الملاكمة والفتح التلقائي. على سبيل المثال:
انسخ رمز الكود كما يلي:
عدد صحيح ط = 10؛
System.out.println(i + 10);
System.out.println(i++);
في المثال أعلاه، سيتم عرض 20 و10. سيقوم المترجم تلقائيًا بإجراء الملاكمة والفك التلقائي، أي أنه سيتم وضع 10 في المربع أولاً، ثم يتم فك التغليف أولاً عندما يكون i + 10، وسيتم تنفيذ عملية الإضافة؛ سيتم أيضًا وضع علامة على الخط أولاً ثم إجراء عملية الزيادة. لننظر إلى مثال آخر:
انسخ رمز الكود كما يلي:
Boolean boo = true;
System.out.println(boo && false);
نفس boo هو في الأصل مثيل لـ Boolean، عند إجراء عملية AND، سيتم إخراج boo أولاً، ثم يتم إضافة خطأ إلى خطأ، وستعرض النتيجة خطأ.
////////////////////////////////////////////////////////////////// /// /////////////////
الملاكمة: التحويل من نوع أساسي إلى نوع كائن يسمى الملاكمة. ***Unboxing: عملية التحويل من كائن إلى نوع أساسي تسمى unboxing. تُستخدم هذه العملية بشكل شائع في عملية التفكير.
التعبئة: قم بإنشاء مثيل كائن في الكومة وانسخ القيمة التي تحددها ***الإخراج: تحديد ما إذا كانت المعلومات الموجودة في الكومة التي يشير إليها المرجع من النوع المراد تقسيمه، وأخذ القيمة من الكومة وإرسالها إلى متغير المكدس، وإلا سيتم الإبلاغ عن استثناء
////////////////////////////////////////////////////////////////// /// //////////////////
الملاكمة عبارة عن تحويل ناسك لنوع القيمة إلى نوع كائن أو إلى أي نوع واجهة ينفذه نوع القيمة.
يؤدي وضع نوع قيمة في الملاكمة إلى تخصيص مثيل كائن ونسخ القيمة إلى كائن جديد.
انسخ رمز الكود كما يلي:
كثافة العمليات ط = 123؛
كائن س = أنا؛
نتيجة هذه الجملة هي إنشاء كائن o على المكدس، والذي يشير إلى قيمة من النوع int على الكومة. يتم تعيين هذه القيمة للمتغير i
نسخة من قيمة نوع القيمة.
يوجد أدناه شاشة تقوم بإجراء تحويل الملاكمة
انسخ رمز الكود كما يلي:
كثافة العمليات ط = 123؛
كائن o=(كائن)i;
يقوم هذا المثال بتحويل المتغير الصحيح i إلى الكائن o من خلال الملاكمة. بهذه الطريقة تتغير القيمة المخزنة في المتغير i من 123 إلى 456. يوضح هذا المثال أن الكائن يحتفظ بنسخة أصلية من المحتوى. وهذا هو 123.
يعد Unboxing تحويلًا صريحًا من نوع الكائن إلى نوع القيمة أو من نوع الواجهة إلى نوع القيمة الذي ينفذ الواجهة. تشمل عمليات الفتح ما يلي:
يتحقق من مثيل الكائن للتأكد من أنه قيمة محاصر لنوع القيمة المحدد.
نسخ القيمة من المثيل إلى متغير نوع القيمة.
مثال:
انسخ رمز الكود كما يلي:
كثافة العمليات ط = 123؛
مربع الكائن = أنا؛
int j=(int)box;
