سؤال حول الصنف Object و سؤال اخر ،،

Object is the largest data type available in java. every thing in java, all data types are Objects (String, Char, Boolean, long...etc)

About that System.out.println®

it soulg print out the location of that r Object in memory.

thanx a lot brother Khobaib .. but why we difine the class as subclass from Object ..i mean what for ??

for the second part i'v tried that but the result wasn't form of memory address !!! what do u think ..?

again .. thanx a lot ..

Bent_ElYemen ...

اولا ملاحظة صغيرة : يا عالم هذا المنتدى عربي لماذا لا تقومون بالرد باللغة العربية.

بالنسبة لجواب السؤال الاول المختص بالصنف Object طبعا لغة الجافا هي لغة مبنية على الكائنات Objects وتعتبر الاصناف(classes) هي بمثابة تعريف للكائن حيث تعرف فيها الوظائف الخاصة بالكائن بالنسبة للسؤال

"لماذا يتم توريث هذا الصنف الى جميع الاصناف ضمنيا؟"

يحتوي الصنف Object على الوظائف الأساسية التي يجب توفرها في كل صنف اخر لكي يعمل ويتفاعل بشكل صحيح في لغة جافا مثل الوظيفة toString التي تقوم بإعطاء معلومات نصية على الصنف وتوجد وظائف اخرى.

هذا هو الغرض من عملية توريث الصنف Object حيث غالبا ما نحتاج الى الوظائف التي تكون موجودة بداخله للحصول على معلومات عن صنف معين او وظائف للتعامل مع الصنف بشكل صحيح ويتم وراثته ضمنيا لهذه الاسباب اما اذا قمت بوراثة صنف اخر فليس هناك داعي لوراثة الصنف Obejct حيث كل الاصناف في لغة الجافا ترث من الصنف Obejct.

بالنسبة لخصائص الصنف Object ودواله تستطيعون ان تذهبوا الى موقع الجافا java.sun.com وفي من ثم الذهاب الى Documentation وهو قسم التوثيق او المساعدة ويوجد به معلومات عن كل الاصناف الموجودة في الجافا وخواصها والدوال الموجودة بها.

جواب السؤال الثاني : سيعطيك البرنامج عنوان البرنامج في الذاكرة.

اشكرك اخي thamood الشكر الجزيل على توضيح السؤال الاول ، لقد فهمت الفكرة كاملة الآن منك و من الأخ Khobaib ...

الآن بالنسبة للسؤال الثاني ، المسألة اني جربت البرنامج و لم يطبع لي ما يشبه العنوان ، فلم اعد متأكدة هل من المفروض ان يطبع لي العنوان او لا !!! و قد قرأت في كتاب Java How To Program لــ DETTEL & DETTEL عن مثال اخر فيما معناه انه في هذه الحالة سوف يستدعي الدالة toString الموجودة في الصنف Object على ما اعتقد ليدمجها مع سلسلة النص المراد طباعتها !!! طبعاً انا لم استوعب شيء ، و لمن لديه هذا الكتاب فأنا اقصد المثال الموضح في صفحة 328 السطر رقم 63 من الشفرة ،،

خالص الشكر مرة اخرى ،،

بنت اليمن ،،

http://java.sun.com/j2se/1.4.2/docs/api/ja...ang/Object.html

تعلم من المصادر!!

بالتوفيق!

بالنسبة للمثال فعندما تقوم بوضع إسم اي صنف في جملة الطباعة فإنه يقوم ذاتيا بإستدعاء الوظيفة toString التي تقوم بإرسال سلسلة حرفية (String) ليقوم بطباعتها.

بالنسبة للمثال انا معاي هذا الكتاب بس اي إصدارة تقصدين ((انا معاي الـ5th edition)) بس حاولي تقري المثال تمام لأن في الكتاب بعد كل برنامج يوجد شرحه بالتفصيل واذا ما فهمتي ممكن تعطيني إسم الفصل chapter الي فيه المثال عشان اقراه.

بالضبط اخي thamood هذا ما اريد معرفته (فإنه يقوم ذاتيا بإستدعاء الوظيفة toString التي تقوم بإرسال سلسلة حرفية (String) ليقوم بطباعتها.) ما هي السلسلة التي يتم ارسالها للطباعة ؟؟؟ بغض النظر عن هذا المثال و بشكل عام ،،، و بالنسبة للكتاب عندي الاصدارة الثالثة ، و المثال هو اول مثال في الفصل الثامن ،،

اشكرك اخي ابو مازن على الرابط المهم ، شيء لم احلم اني سوف افهمه بهذا التفصيل ،،،، :)

بنت اليمن ،،

السلام عليكم ورحمة الله وبركاته

إن الصنف class Object هو في أعلى هرمية الأصناف بلغة جافا وكل الفئات ترث منه تلقائيا أم بشكل غير مباشر، ويدعم هذا التنظيم للأصناف بلغة جافا أمكانية كتابة برامج عامة تعمل على أي نوع من أنواع البيانات. مثال من المعروف أن الهيكل البياني stack له آلية ثابتة بالعمل أي أن أخر عنصر يضع فيه يكون أول عنصر يسحب منه، وبما أن آلية العمل ثابتة فمن الأفضل برمجتها مرة واحدة فقط، ولكن يمكن أن نعمل على عدة stacks تخزن فيها أنواع بيانات مختلفة، فهنا يتعلق الأمر بنوع البيانات المخزن في الرصة stack. فبعض لغات البرمجة الغير object oriented تطلب انشاء رصة خاصة بكل نوع بيانات (إلى حد ما).

أما لغة جافا فيمكن إنشاء صنف واحد فقط يمثل stack وتكون عناصره من النوع Object وبعد ذلك يمكن انشاء كائن Object من الصنف Stack ويمكن تخزين فيه أي كائنات من أي صنف بلغة جافا،

لإذا استعمالنا مصففوفة array لتخزين عناصر الرصة stack فتكون عناصر المصفوفة عبارة عن مراجع references من الصنف Object وبما أنها الصنف الذي يرث منه كل باقي الاصناف فيمكن لمراجع الصفوفة أن تشير إلى أي كائن Object من الاصناف الأخرى وذلك بفعل الوراثة، وبالتالي فهذا الصنف stack of Object يعتبر general stack ويمكن استعماله لتخزين أي نوع بيانات فيه، وبالنهاية انشأنا برنامج عام،

والصنف Object هو تطبيق فعلي لمبدأ التعميم generalization بالبرمجة أي الاشياء المشتركة بين الاصناف نضعها بصنف عام ترث منه الاصناف الاخرى ونبرمج الاشياء العامة داخل هذا الصنف العام والاختلافات بين الاصناف الاخرى تتم إعادة تعريفها overriding في الاصناف الفرعية كل حسب طريقته الخاصة.

بالنسبة لمحتوع الصنف Object فلا أعرف بالضبط كل محتواها ولكن معرف فيها كل الاشياء المشتركة بين كل الاصناف مثل الطرق equals, toString, finalize, ...

بالنسبة لما تطبعة التعليمة( System.out.print(R بالحالة التي ذكرت فيتم على ما اعتقد لأني لم اجربها طباعة اسم الفئة الكامل ثم الرمز @ ثم عنوان الكائن الذي يشير إليه المرجع R في الذاكرة، وذلك لأنه لم تتم إعادة تعريف الطريقة toString في الصنف Red وعند وضع اسم مرجع في مضمون يتطلب String بشكل عام أو عند طباعة مرجع فيتم استدعاء الطريقة toString بشكل تلقائي وتطبيقها على الكائي الذي يشير إليه المرجع المستعمل وتكون نتيجة الطريقة toString هي التي ستطبع أو ستستعمل في المضمون النصي. وبما أنه في المثال المذكور لم تتم إعادة تعريف الطريقة toString في الصنف Red فتم تطبيق (على ما اعتقد) الطريقة المعرفة في الصنف الذي يرث منه الصنف Red أي الصنف Object.

أتمنى أن يكون الشرح واضح نسبيا واعتذر عن حبكة الشرح لأن هناك امور كثيرة تلعب دور مثل inheritance, overriding and polymorphism

سائلين المولى عز وجل الافادة ومنكم الدعاء

اولاً مرحباً بك اخي kkhalil2005 في منتدانا .. ثم اشكرك فعلأً على ما تفضلت بشرحه ،، لأتي الآن فهمت السؤال الثاني بشكل وافي و كامل و الحمدلله ،، و كلامك فعلاً مضبوط و اليك الصورة التالية التي هي ناتج طباعة اسم الكائن :

بارك الله فيك اخي kkhalil2005 ، و خالص الشكر مرة اخرى للأخوة thamood و ابو مازن و Khobaib ،،

بسم الله الرحمن الرحيم

ما شاء الله ما شاء الله

بداية كم انا فرح جدا انا يكون من ابناء اليمن ناس في هذا المنتدى وعلى قدر كبير من الوعي وفي هذا التخصص

وايضا ان تكون اخت

كم انا فخور باليمن

لعل الموضوع قديم

لا ادري

لكن لفت انتباهي اسم اليمن

فمررت فيه

فاحب ان اضيف ما عندي

اختي الكريمه

قلتي

السؤال الآول حول الصنف Object ، حيث انه يورّث ضمنياً لكل صنف class يتم انشاءه ما لم يرث هذا الصنف اي صنف اخر

هنا معلومة غلط في سؤالك على حسب فهمي (ولعله خطأ لفظي فقط لا غير)

ومعلش انا لست متاقلما مع المصطلحات العربية

فانتي تقولين

ان الصنف Object يورث ضمنيا لعلك تعنين تلقائياً لكل صنف مالم يرث هذا الصنف صنف اخر

من عند ما لم عنا اعتقد فيه لبس

والصحيح

ان الصنف Object يورث ضمنياً لأي صنف سؤاء كان هذا الصنف يرث صنف اخر او لا

وكلامي 100% صحيح ومنطقي جدا والدليل

انه اي صنف يرث صنف اخر

الصنف الاخر بيرث الصنف الاب ال Object

يعني الصنف بيرث الصنف الاخر والصنف الاخر بيرث ال Object

فبالتالي الصنف يرث ال Object

وايضا ما يدل على ذلك هو

امكانية استخدام مثدات الصنف Object داخل اي صنف اخر سواء كان الصنف يرث كلاس او لا يرث

اما سؤالك لماذا يتم توريث هذا الصنف ضمنياً لكل الاصناف الاخرى

فقد اجاد الاخوان التوضيح

وبالنسبة لمحتويات الكلاس Object

فسهل يمكن معرفة ذلك اما من API من موقع شركة سن

او من جهازكم

اكيد انتم تملكون الجي دي كي JDK

ففي مكان الجي دي كي JDK

بوجد ملف مضغوط اسمه

src.zip

هذا الملف يحتوي على كل الكلاسات الموجودة في الجافا ابتدائا

فافتوحوا واختاروا java

وبعدها اختاروا lang

وبعدها بتلقوا كل الكلااسات اللي في lang

اختاروا Object.java

وبتلقوا الكود اللي في هذا الصنف

ومن باب الاستزادة بنقله لكم هنا

/*
 * @(#)Object.java	1.61 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.lang;

/**
 * Class <code>Object</code> is the root of the class hierarchy. 
 * Every class has <code>Object</code> as a superclass. All objects, 
 * including arrays, implement the methods of this class. 
 *
 * @author  unascribed
 * @version 1.61, 01/23/03
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
     * Returns the runtime class of an object. That <tt>Class</tt> 
     * object is the object that is locked by <tt>static synchronized</tt> 
     * methods of the represented class.
     *
     * @return  the object of type <code>Class</code> that represents the
     *          runtime class of the object.
     */
    public final native Class getClass();

    /**
     * Returns a hash code value for the object. This method is 
     * supported for the benefit of hashtables such as those provided by 
     * <code>java.util.Hashtable</code>. 
     * <p>
     * The general contract of <code>hashCode</code> is: 
     * <ul>
     * <li>Whenever it is invoked on the same object more than once during 
     *     an execution of a Java application, the <tt>hashCode</tt> method 
     *     must consistently return the same integer, provided no information 
     *     used in <tt>equals</tt> comparisons on the object is modified.
     *     This integer need not remain consistent from one execution of an
     *     application to another execution of the same application. 
     * <li>If two objects are equal according to the <tt>equals(Object)</tt>
     *     method, then calling the <code>hashCode</code> method on each of 
     *     the two objects must produce the same integer result. 
     * <li>It is <em>not</em> required that if two objects are unequal 
     *     according to the {@link java.lang.Object#equals(java.lang.Object)} 
     *     method, then calling the <tt>hashCode</tt> method on each of the 
     *     two objects must produce distinct integer results.  However, the 
     *     programmer should be aware that producing distinct integer results 
     *     for unequal objects may improve the performance of hashtables.
     * </ul>
     * <p>
     * As much as is reasonably practical, the hashCode method defined by 
     * class <tt>Object</tt> does return distinct integers for distinct 
     * objects. (This is typically implemented by converting the internal 
     * address of the object into an integer, but this implementation 
     * technique is not required by the 
     * Java<font size="-2"><sup>TM</sup></font> programming language.)
     *
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.util.Hashtable
     */
    public native int hashCode();

    /**
     * Indicates whether some other object is "equal to" this one.
     * <p>
     * The <code>equals</code> method implements an equivalence relation
     * on non-null object references:
     * <ul>
     * <li>It is <i>reflexive</i>: for any non-null reference value
     *     <code>x</code>, <code>x.equals(x)</code> should return
     *     <code>true</code>.
     * <li>It is <i>symmetric</i>: for any non-null reference values
     *     <code>x</code> and <code>y</code>, <code>x.equals(y)</code>
     *     should return <code>true</code> if and only if
     *     <code>y.equals(x)</code> returns <code>true</code>.
     * <li>It is <i>transitive</i>: for any non-null reference values
     *     <code>x</code>, <code>y</code>, and <code>z</code>, if
     *     <code>x.equals(y)</code> returns <code>true</code> and
     *     <code>y.equals(z)</code> returns <code>true</code>, then
     *     <code>x.equals(z)</code> should return <code>true</code>.
     * <li>It is <i>consistent</i>: for any non-null reference values
     *     <code>x</code> and <code>y</code>, multiple invocations of
     *     <tt>x.equals(y)</tt> consistently return <code>true</code>
     *     or consistently return <code>false</code>, provided no
     *     information used in <code>equals</code> comparisons on the
     *     objects is modified.
     * <li>For any non-null reference value <code>x</code>,
     *     <code>x.equals(null)</code> should return <code>false</code>.
     * </ul>
     * <p>
     * The <tt>equals</tt> method for class <code>Object</code> implements 
     * the most discriminating possible equivalence relation on objects; 
     * that is, for any non-null reference values <code>x</code> and
     * <code>y</code>, this method returns <code>true</code> if and only
     * if <code>x</code> and <code>y</code> refer to the same object
     * (<code>x == y</code> has the value <code>true</code>).
     * <p>
     * Note that it is generally necessary to override the <tt>hashCode</tt>
     * method whenever this method is overridden, so as to maintain the
     * general contract for the <tt>hashCode</tt> method, which states
     * that equal objects must have equal hash codes. 
     *
     * @param   obj   the reference object with which to compare.
     * @return  <code>true</code> if this object is the same as the obj
     *          argument; <code>false</code> otherwise.
     * @see     #hashCode()
     * @see     java.util.Hashtable
     */
    public boolean equals(Object obj) {
	return (this == obj);
    }

    /**
     * Creates and returns a copy of this object.  The precise meaning 
     * of "copy" may depend on the class of the object. The general 
     * intent is that, for any object <tt>x</tt>, the expression:
     * <blockquote>
     * <pre>
     * x.clone() != x</pre></blockquote>
     * will be true, and that the expression:
     * <blockquote>
     * <pre>
     * x.clone().getClass() == x.getClass()</pre></blockquote>
     * will be <tt>true</tt>, but these are not absolute requirements. 
     * While it is typically the case that:
     * <blockquote>
     * <pre>
     * x.clone().equals(x)</pre></blockquote>
     * will be <tt>true</tt>, this is not an absolute requirement. 
     * <p>
     * By convention, the returned object should be obtained by calling
     * <tt>super.clone</tt>.  If a class and all of its superclasses (except
     * <tt>Object</tt>) obey this convention, it will be the case that
     * <tt>x.clone().getClass() == x.getClass()</tt>.
     * <p>
     * By convention, the object returned by this method should be independent
     * of this object (which is being cloned).  To achieve this independence,
     * it may be necessary to modify one or more fields of the object returned
     * by <tt>super.clone</tt> before returning it.  Typically, this means
     * copying any mutable objects that comprise the internal "deep structure"
     * of the object being cloned and replacing the references to these
     * objects with references to the copies.  If a class contains only
     * primitive fields or references to immutable objects, then it is usually
     * the case that no fields in the object returned by <tt>super.clone</tt>
     * need to be modified.
     * <p>
     * The method <tt>clone</tt> for class <tt>Object</tt> performs a 
     * specific cloning operation. First, if the class of this object does 
     * not implement the interface <tt>Cloneable</tt>, then a 
     * <tt>CloneNotSupportedException</tt> is thrown. Note that all arrays 
     * are considered to implement the interface <tt>Cloneable</tt>. 
     * Otherwise, this method creates a new instance of the class of this 
     * object and initializes all its fields with exactly the contents of 
     * the corresponding fields of this object, as if by assignment; the
     * contents of the fields are not themselves cloned. Thus, this method 
     * performs a "shallow copy" of this object, not a "deep copy" operation.
     * <p>
     * The class <tt>Object</tt> does not itself implement the interface 
     * <tt>Cloneable</tt>, so calling the <tt>clone</tt> method on an object 
     * whose class is <tt>Object</tt> will result in throwing an
     * exception at run time.
     *
     * @return     a clone of this instance.
     * @exception  CloneNotSupportedException  if the object's class does not
     *               support the <code>Cloneable</code> interface. Subclasses
     *               that override the <code>clone</code> method can also
     *               throw this exception to indicate that an instance cannot
     *               be cloned.
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
     * Returns a string representation of the object. In general, the 
     * <code>toString</code> method returns a string that 
     * "textually represents" this object. The result should 
     * be a concise but informative representation that is easy for a 
     * person to read.
     * It is recommended that all subclasses override this method.
     * <p>
     * The <code>toString</code> method for class <code>Object</code> 
     * returns a string consisting of the name of the class of which the 
     * object is an instance, the at-sign character `<code>@</code>', and 
     * the unsigned hexadecimal representation of the hash code of the 
     * object. In other words, this method returns a string equal to the 
     * value of:
     * <blockquote>
     * <pre>
     * getClass().getName() + '@' + Integer.toHexString(hashCode())
     * </pre></blockquote>
     *
     * @return  a string representation of the object.
     */
    public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * Wakes up a single thread that is waiting on this object's 
     * monitor. If any threads are waiting on this object, one of them 
     * is chosen to be awakened. The choice is arbitrary and occurs at 
     * the discretion of the implementation. A thread waits on an object's 
     * monitor by calling one of the <code>wait</code> methods.
     * <p>
     * The awakened thread will not be able to proceed until the current 
     * thread relinquishes the lock on this object. The awakened thread will 
     * compete in the usual manner with any other threads that might be 
     * actively competing to synchronize on this object; for example, the 
     * awakened thread enjoys no reliable privilege or disadvantage in being 
     * the next thread to lock this object.
     * <p>
     * This method should only be called by a thread that is the owner 
     * of this object's monitor. A thread becomes the owner of the 
     * object's monitor in one of three ways: 
     * <ul>
     * <li>By executing a synchronized instance method of that object. 
     * <li>By executing the body of a <code>synchronized</code> statement 
     *     that synchronizes on the object. 
     * <li>For objects of type <code>Class,</code> by executing a 
     *     synchronized static method of that class. 
     * </ul>
     * <p>
     * Only one thread at a time can own an object's monitor. 
     *
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    public final native void notify();

    /**
     * Wakes up all threads that are waiting on this object's monitor. A 
     * thread waits on an object's monitor by calling one of the 
     * <code>wait</code> methods.
     * <p>
     * The awakened threads will not be able to proceed until the current 
     * thread relinquishes the lock on this object. The awakened threads 
     * will compete in the usual manner with any other threads that might 
     * be actively competing to synchronize on this object; for example, 
     * the awakened threads enjoy no reliable privilege or disadvantage in 
     * being the next thread to lock this object.
     * <p>
     * This method should only be called by a thread that is the owner 
     * of this object's monitor. See the <code>notify</code> method for a 
     * description of the ways in which a thread can become the owner of 
     * a monitor. 
     *
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#wait()
     */
    public final native void notifyAll();

    /**
     * Causes current thread to wait until either another thread invokes the 
     * {@link java.lang.Object#notify()} method or the 
     * {@link java.lang.Object#notifyAll()} method for this object, or a 
     * specified amount of time has elapsed. 
     * <p>
     * The current thread must own this object's monitor. 
     * <p>
     * This method causes the current thread (call it <var>T</var>) to 
     * place itself in the wait set for this object and then to relinquish 
     * any and all synchronization claims on this object. Thread <var>T</var> 
     * becomes disabled for thread scheduling purposes and lies dormant 
     * until one of four things happens:
     * <ul>
     * <li>Some other thread invokes the <tt>notify</tt> method for this 
     * object and thread <var>T</var> happens to be arbitrarily chosen as 
     * the thread to be awakened. 
     * <li>Some other thread invokes the <tt>notifyAll</tt> method for this 
     * object. 
     * <li>Some other thread {@link java.lang.Thread#interrupt() interrupts} 
     * thread <var>T</var>. 
     * <li>The specified amount of real time has elapsed, more or less.  If 
     * <tt>timeout</tt> is zero, however, then real time is not taken into 
     * consideration and the thread simply waits until notified. 
     * </ul>
     * The thread <var>T</var> is then removed from the wait set for this 
     * object and re-enabled for thread scheduling. It then competes in the 
     * usual manner with other threads for the right to synchronize on the 
     * object; once it has gained control of the object, all its 
     * synchronization claims on the object are restored to the status quo 
     * ante - that is, to the situation as of the time that the <tt>wait</tt> 
     * method was invoked. Thread <var>T</var> then returns from the 
     * invocation of the <tt>wait</tt> method. Thus, on return from the 
     * <tt>wait</tt> method, the synchronization state of the object and of 
     * thread <tt>T</tt> is exactly as it was when the <tt>wait</tt> method 
     * was invoked. 
     * <p>
     * If the current thread is 
     * {@link java.lang.Thread#interrupt() interrupted} by another thread 
     * while it is waiting, then an <tt>InterruptedException</tt> is thrown. 
     * This exception is not thrown until the lock status of this object has 
     * been restored as described above.
     * <p>
     * Note that the <tt>wait</tt> method, as it places the current thread 
     * into the wait set for this object, unlocks only this object; any 
     * other objects on which the current thread may be synchronized remain 
     * locked while the thread waits.
     * <p>
     * This method should only be called by a thread that is the owner 
     * of this object's monitor. See the <code>notify</code> method for a 
     * description of the ways in which a thread can become the owner of 
     * a monitor. 
     *
     * @param      timeout   the maximum time to wait in milliseconds.
     * @exception  IllegalArgumentException      if the value of timeout is
     *       negative.
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @exception  InterruptedException if another thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
     * Causes current thread to wait until another thread invokes the 
     * {@link java.lang.Object#notify()} method or the 
     * {@link java.lang.Object#notifyAll()} method for this object, or 
     * some other thread interrupts the current thread, or a certain 
     * amount of real time has elapsed. 
     * <p>
     * This method is similar to the <code>wait</code> method of one 
     * argument, but it allows finer control over the amount of time to 
     * wait for a notification before giving up. The amount of real time, 
     * measured in nanoseconds, is given by:
     * <blockquote>
     * <pre>
     * 1000000*timeout+nanos</pre></blockquote>
     * <p>
     * In all other respects, this method does the same thing as the 
     * method {@link #wait(long)} of one argument. In particular, 
     * <tt>wait(0, 0)</tt> means the same thing as <tt>wait(0)</tt>.
     * <p>
     * The current thread must own this object's monitor. The thread 
     * releases ownership of this monitor and waits until either of the 
     * following two conditions has occurred: 
     * <ul>
     * <li>Another thread notifies threads waiting on this object's monitor 
     *     to wake up either through a call to the <code>notify</code> method 
     *     or the <code>notifyAll</code> method. 
     * <li>The timeout period, specified by <code>timeout</code> 
     *     milliseconds plus <code>nanos</code> nanoseconds arguments, has 
     *     elapsed. 
     * </ul>
     * <p>
     * The thread then waits until it can re-obtain ownership of the 
     * monitor and resumes execution.
     * <p>
     * This method should only be called by a thread that is the owner 
     * of this object's monitor. See the <code>notify</code> method for a 
     * description of the ways in which a thread can become the owner of 
     * a monitor. 
     *
     * @param      timeout   the maximum time to wait in milliseconds.
     * @param      nanos      additional time, in nanoseconds range
     *                       0-999999.
     * @exception  IllegalArgumentException      if the value of timeout is
     *       negative or the value of nanos is
     *       not in the range 0-999999.
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @exception  InterruptedException if another thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     */
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
    "nanosecond timeout value out of range");
        }

	if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
     timeout++;
	}

	wait(timeout);
    }

    /**
     * Causes current thread to wait until another thread invokes the 
     * {@link java.lang.Object#notify()} method or the 
     * {@link java.lang.Object#notifyAll()} method for this object. 
     * In other words, this method behaves exactly as if it simply 
     * performs the call <tt>wait(0)</tt>.
     * <p>
     * The current thread must own this object's monitor. The thread 
     * releases ownership of this monitor and waits until another thread 
     * notifies threads waiting on this object's monitor to wake up 
     * either through a call to the <code>notify</code> method or the 
     * <code>notifyAll</code> method. The thread then waits until it can 
     * re-obtain ownership of the monitor and resumes execution. 
     * <p>
     * This method should only be called by a thread that is the owner 
     * of this object's monitor. See the <code>notify</code> method for a 
     * description of the ways in which a thread can become the owner of 
     * a monitor. 
     *
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @exception  InterruptedException if another thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final void wait() throws InterruptedException {
	wait(0);
    }

    /**
     * Called by the garbage collector on an object when garbage collection
     * determines that there are no more references to the object.
     * A subclass overrides the <code>finalize</code> method to dispose of
     * system resources or to perform other cleanup. 
     * <p>
     * The general contract of <tt>finalize</tt> is that it is invoked 
     * if and when the Java<font size="-2"><sup>TM</sup></font> virtual 
     * machine has determined that there is no longer any
     * means by which this object can be accessed by any thread that has
     * not yet died, except as a result of an action taken by the
     * finalization of some other object or class which is ready to be
     * finalized. The <tt>finalize</tt> method may take any action, including
     * making this object available again to other threads; the usual purpose
     * of <tt>finalize</tt>, however, is to perform cleanup actions before 
     * the object is irrevocably discarded. For example, the finalize method 
     * for an object that represents an input/output connection might perform
     * explicit I/O transactions to break the connection before the object is
     * permanently discarded. 
     * <p>
     * The <tt>finalize</tt> method of class <tt>Object</tt> performs no 
     * special action; it simply returns normally. Subclasses of 
     * <tt>Object</tt> may override this definition.
     * <p>
     * The Java programming language does not guarantee which thread will 
     * invoke the <tt>finalize</tt> method for any given object. It is 
     * guaranteed, however, that the thread that invokes finalize will not 
     * be holding any user-visible synchronization locks when finalize is 
     * invoked. If an uncaught exception is thrown by the finalize method, 
     * the exception is ignored and finalization of that object terminates.
     * <p>
     * After the <tt>finalize</tt> method has been invoked for an object, no 
     * further action is taken until the Java virtual machine has again 
     * determined that there is no longer any means by which this object can 
     * be accessed by any thread that has not yet died, including possible
     * actions by other objects or classes which are ready to be finalized, 
     * at which point the object may be discarded.
     * <p>
     * The <tt>finalize</tt> method is never invoked more than once by a Java
     * virtual machine for any given object.
     * <p>
     * Any exception thrown by the <code>finalize</code> method causes 
     * the finalization of this object to be halted, but is otherwise 
     * ignored. 
     *
     * @throws Throwable the <code>Exception</code> raised by this method
     */
    protected void finalize() throws Throwable { }
}

لي عودة

تحياتي والسلام ختام

بالنسبة للقسم الثاني من السؤال

فالاخوان قد اجادوا وافادوا

بس من باب التوضيح لا اكثر

System.out.print(Object o);

لو تتعبنا هذا التسلسل عشان نوصل الى الكود حق المثد

فرحنا الى src.zip

ومن هناك نروح java

ونروح lang

ونروح System.java

بنلقى هناك انستنس فيربل باسم out

public final static PrintStream out

علمنا ان نوعه PrintStream

فلذلك نروح لهذا الكلاس

بلقى المثد print اللي تأخذ اوبجكت

    /**
     * Print an object.  The string produced by the <code>{@link
     * java.lang.String#valueOf(Object)}</code> method is translated into bytes
     * according to the platform's default character encoding, and these bytes
     * are written in exactly the manner of the
     * <code>{@link #write(int)}</code> method.
     *
     * @param      obj   The <code>Object</code> to be printed
     * @see        java.lang.Object#toString()
     */
    public void print(Object obj) {
	write(String.valueOf(obj));
    }

فهنا نجد انه يتم استدعاء المثد write اللتي تاخذ بارامتر

 String.valueOf(obj)

فبداية نشوف البرامتر ونتتبه

نروح كلاس String

ونروح المثد valueOf اللي تاخذ اوبجكت

فهذا كودها

 
   /**
     * Returns the string representation of the <code>Object</code> argument.
     *
     * @param   obj   an <code>Object</code>.
     * @return  if the argument is <code>null</code>, then a string equal to
     *          <code>"null"</code>; otherwise, the value of
     *          <code>obj.toString()</code> is returned.
     * @see     java.lang.Object#toString()
     */
    public static String valueOf(Object obj) {
	return (obj == null) ? "null" : obj.toString();
    }

فبنلاحظ ان هذا المثد بيفحص البرامتر فاذا هو null رد سترنق باسم null

والا استدعى المثد toString من الكلاس اللي منه البرامتر

وفي مثال الاخت بنت اليمن البرامتر من نوع Red

وطبعاً هذا الكلاس يرث الكلاس الاب Object والكلاس Red لم يقم بتعديل المثد toString فيستم استدعاء المثد toString من الكلاس الاب Object

فنروح هناك

من الكلاس Object نشوف المثد toString

    /**
     * Returns a string representation of the object. In general, the 
     * <code>toString</code> method returns a string that 
     * "textually represents" this object. The result should 
     * be a concise but informative representation that is easy for a 
     * person to read.
     * It is recommended that all subclasses override this method.
     * <p>
     * The <code>toString</code> method for class <code>Object</code> 
     * returns a string consisting of the name of the class of which the 
     * object is an instance, the at-sign character `<code>@</code>', and 
     * the unsigned hexadecimal representation of the hash code of the 
     * object. In other words, this method returns a string equal to the 
     * value of:
     * <blockquote>
     * <pre>
     * getClass().getName() + '@' + Integer.toHexString(hashCode())
     * </pre></blockquote>
     *
     * @return  a string representation of the object.
     */
    public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

فنلاحظ ان المثد هذه ترجع String

وبالتركيز في السطر التالي

  return getClass().getName() + "@" + Integer.toHexString(hashCode());

نجد ان الاسترنق متكون من

1- getClass().getName() اختصاراً لو تتبعنا هذا السطر لوجدنا انه يرجع لنا اسم الكلاس

2- @

3- Integer.toHexString(hashCode()); هذا السطر مهم فلنتتبعه بتمعن

المثد hashCode مستدعاه هنا وهذا كودها

    /**
     * Returns a hash code value for the object. This method is 
     * supported for the benefit of hashtables such as those provided by 
     * <code>java.util.Hashtable</code>. 
     * <p>
     * The general contract of <code>hashCode</code> is: 
     * <ul>
     * <li>Whenever it is invoked on the same object more than once during 
     *     an execution of a Java application, the <tt>hashCode</tt> method 
     *     must consistently return the same integer, provided no information 
     *     used in <tt>equals</tt> comparisons on the object is modified.
     *     This integer need not remain consistent from one execution of an
     *     application to another execution of the same application. 
     * <li>If two objects are equal according to the <tt>equals(Object)</tt>
     *     method, then calling the <code>hashCode</code> method on each of 
     *     the two objects must produce the same integer result. 
     * <li>It is <em>not</em> required that if two objects are unequal 
     *     according to the {@link java.lang.Object#equals(java.lang.Object)} 
     *     method, then calling the <tt>hashCode</tt> method on each of the 
     *     two objects must produce distinct integer results.  However, the 
     *     programmer should be aware that producing distinct integer results 
     *     for unequal objects may improve the performance of hashtables.
     * </ul>
     * <p>
     * As much as is reasonably practical, the hashCode method defined by 
     * class <tt>Object</tt> does return distinct integers for distinct 
     * objects. (This is typically implemented by converting the internal 
     * address of the object into an integer, but this implementation 
     * technique is not required by the 
     * Java<font size="-2"><sup>TM</sup></font> programming language.)
     *
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.util.Hashtable
     */
    public native int hashCode();

قد تستغربون الان لا يوجد كود المثد فاضية

لا تستعجلوا اقرأو الدكمنتيشن حق المثد

وركزا على هذه الكلام الموجود في الدكمتييشن

This is typically implemented by converting the internal

* address of the object into an integer, but this implementation

* technique is not required by the

* Java TM programming language.

*

ومعنى هذا الكلام

ان المثد تقوم بتحويل عنوان الاوبجكت الى ارقام ولكن هذا التكنيك مش معمول بالجافا (طبعا مش ترجمه حرفيه هههههه)

فهنا عرفنا ان المثد تقوم بتحويل عنوان الاوبجكت الى ارقام

ولتكملة فهم السطر

Integer.toHexString(hashCode());

نجد ان ما ترجعه المثد hashCode ياخذ كبارمتر لمثد اخرى toHexString الموجودة في الكلاس Integer

ولو رحنا لذلك الكلاس Integer

وشفنا المثد بنلقى ان المثد

تقوم بتحويل الارقام المأخوذه من hashCode الى ارقام Hex وجعلها String

وبهذا عرفنا ايش السطر الي بترجعه المثد toString

وطبعاً لن اكمل اعتقد الفكرة وصلت

فلذلك الاخت بنت اليمن حصلت على

test@7ced01

test اسم الكلاس هههههههههه كفشناها كما قال الاخ سابقا

@ هذه من عندهم

7ced01 هذا رقم بالهكس ناتج من المثد toHexString

اعتقد الان اتضح كل شيء

ما ادري اذا كلامي كان واضح والا لا

اكرر الاعتذار من المصطلحات اللتي استخدمها

فانا درست الجافا في بلاد غربية ولم اتعامل مع المصطلحات العربية

ولكن من قرأتي لكلامكم تعبت في فهم مقاصدكم

الفئة ؟ ما هي هل هي ال class

لكن الصنف class

بس ملاحظة بسيطة

من لديه الجي بلدر JBuilder

فيستطيع تتبع كل هذا بكل سهولة ويسر باستخدام ميزة الديبق Debug

ومن لديه الجي بلدر ولا يعلم كيف يتتبع كل هذا بالديبق فليخبرني وانا بساعده (الامر سهل جدا ) ههههه

طبعا كما قال الإخوان قبلي, عند استدعاء

System.out.println(R)

سيتم استدعاء

R.toString()

و طباعة الـ String اللذي يقوم الـmethod بإرجاعه.

طبعا لا تحتاج لتعريف هذا الـ method لأنه معرف في الـ Object, لكن التعريف الأصلي بصراحة عديم الفائدة. لذلك يمكنك إعادة تعريفه ليكون شيئا ذو فائدة .. (و من الأفضل عمل ذلك إذا كنت تنوي طباعة معلومة معينة عن الكائن بشكل متكرر)

مثلا انا كان لدي مرة class Money, قمت بإعادة تعريف toString() ليطبع القيمة النقدية, مثلا:

$143.00

و هكذا .. ففي السابق كنت إذا اردت طباعة القيمة النقدية للكائن أقوم بشيء مثل:

Money amount = new Money(12300);
System.out.println(amount.GetString());

أما الآن فيكفي:

System.out.println(amount);

اولاً دعني احييك اخي الصنعاني ، و ان اقول لك اني انا التي افخر بكل شباب بلدي الحبيب ، الذين يقدمون الواجهة الجيدة التي تستحقها بلادنا التي ظلمناها كثيراً !!!

بالنسبة للشق الأول ، فنعم لقد قصدت ما فهته انت (السؤال الآول حول الصنف Object ، حيث انه يورّث ضمنياً لكل صنف class يتم انشاءه ما لم يرث هذا الصنف اي صنف اخر ) ، و لكن كلامك فعلاً منطقياُ ، حيث انه اذا لم تتم الوراثة ضمنياً بشكل مباشر من الكلاس object فإنها سوف تتم بشكل غير مباشر ، لأن في النهاية كل الكلاسس لابد ان يكون فيها الـ super_class قد ورث فعلياً الكلاس object .. و عليه كلامك منطقي ...

و اما عن محتويات الكلاس object .. فأنا اشكرك ايضاً على اضافتك لملف محتويات الكلاس object .. و الذي سوف اطلع عليه على مهلي :) ،،

بالنسبة للشق الثاني ،، ففي الحقيقة لقد فتح لي افاق و معلومات لم اتوقعها ،، فقط دعني اراجع الكود مرة اخرى ،، و ان كان لي سؤال فلي اكيد عودة ،،

و خالص تحياتي لك اخي الكريم ابن اليمن ،،، :)

بنت اليمن ،،

حياكي استاذتنا اي وقت