जावा कन्स्ट्रक्टर्स

Question

मैं जावा में कक्षा रचनाकारों को निर्दिष्ट करने का तरीका सीखने की कोशिश कर रहा हूं। मुझे यह समझना शुरू हो रहा है कि वे उस वर्ग से बने वस्तुओं के आवृत्ति चर के प्रकार निर्दिष्ट करते हैं। वे आवृत्ति चर प्रारंभिक मान सेट करने के लिए भी इस्तेमाल किया जा सकता है। अनुवर्ती उदाहरण सूर्य की वेबसाइट पर जावा ट्यूटोरियल से है:

public Bicycle(int startCadence, int startSpeed, int startGear) { 
    gear = startGear; 
    cadence = startCadence; 
    speed = startSpeed; 
} 

कहाँ अपनी कक्षाओं स्रोत कोड में आप निर्माता (रों) रखना चाहिए?

क्या ये तर्क चर के नाम हैं ?: (int startCadence, int startSpeed, int startGear) या वेयर, कैडेंस और चर के नामों को गति देते हैं?

(int startCadence, int startSpeed, int startGear) और गियर, ताल और गति के बीच क्या अंतर है?

संभावना है कि मेरे प्रशिक्षक या साल्ट लेक सामुदायिक कॉलेज से कोई भी प्रशासक कभी भी इस प्रश्न में आता है, तो मुझे अपना इरादा स्पष्ट कर दें। यह प्रश्न अकादमिक ईमानदारी की सबसे बड़ी भावना में पोस्ट किया गया है। मैं इस सवाल से सामान्य सलाह लेने और जावा प्रोग्रामिंग भाषा का उपयोग करने के उचित तरीके को समझने में मदद करता हूं। मैं किसी भी तरह से दूसरों के काम का उपयोग नहीं करता हूं और इसे अपने स्वयं के काम के रूप में प्रस्तुत करता हूं। मैं अपनी समझ में सामान्य सहायता के रूप में यहां दिए गए उत्तरों का उपयोग करता हूं। मैं अपना पूरा काम करता हूं और लोगों द्वारा दिए गए कार्यों की प्रतिलिपि नहीं करता हूं जो मेरे प्रश्न का उत्तर देते हैं।

Answer 1

रचनाकार कक्षा के लिए कोड में कहीं भी दिखाई दे सकते हैं। हालांकि, सम्मेलन से, अधिकांश लोग उन्हें किसी भी अन्य कार्यों से पहले रख देते हैं जो कि रचनाकार नहीं हैं।

परिवर्तनीय नामों के लिए, सभी 6 वास्तव में परिवर्तनीय नाम हैं, लेकिन दायरा differnet है। कन्स्ट्रक्टर (स्टार्ट कैडेंस, स्टार्टस्पेड, स्टार्टगियर) के पैरामीटर के रूप में निर्दिष्ट किए गए हैं केवल कन्स्ट्रक्टर के भीतर उपलब्ध हैं। अन्य 3 (गियर, ताल, गति) शायद सभी विधियों के लिए उपलब्ध वर्ग-व्यापी चर हैं। हालांकि परिभाषा आपके कोड स्निपेट में नहीं दिखाया गया है। पूर्ण श्रेणी में मरो दिखाई देगी:

class Bicycle 
{ 
    // class-level variables 
    private int gear; 
    private int cadence; 
    private int speed; 

    // constructor 
    public Bicycle(int startCadence, int startSpeed, int startGear) { 
     gear = startGear; 
     cadence = startCadence; 
     speed = startSpeed; 
    } 

    // another method (not a constructor) 
    public void ShiftUp() { 
     gear = gear + 1; // notice the 'gear' variable is available here too. 
    } 
} 

आशा है कि मदद करता है!

Answer 2

आप वास्तव में Head First Java

Answer 3

1. यह पूरी तरह से आप पर निर्भर है की एक प्रति की जरूरत है। मैं आमतौर पर सभी चर, फिर रचनाकारों, फिर विधियों से शुरू होता हूं, लेकिन यह सिर्फ व्यक्तिगत वरीयता है।
2. तर्कों के नाम पूरी तरह से अप्रासंगिक हैं, जब तक कि आप उन्हें अपने चर के समान नहीं मानते। इस उदाहरण में, gear, cadence, और speed चर हैं।
3. आप (या कोई है) कन्स्ट्रक्टर को तीन ints पास कर रहे हैं। नाम (startCadence, startSpeed, और startGearऔपचारिक पैरामीटर
   gear, cadence कहा जाता है, और वे जिस तरह से आप तर्क की पहचान कर सकते हैं। http://en.wikipedia.org/wiki/Parameter_(computer_science) देखें।, और speed कक्षा में कहीं और परिभाषित कर रहे हैं। में कोई भी तरीका वर्ग उन्हें का उल्लेख कर सकते

चिंता न करें -।। अगर आप इस पर काम, बात इस तरह की बहुत जल्द दूसरी प्रकृति हो जाएगा

ओह, और मैं सुझाव दे सकते हैं कि आप एक मिल अच्छा आईडीई? BlueJ मान लीजिए शुरुआती प्रोग्रामरों के लिए शुरुआती लोगों के लिए अच्छा होना, और NetBeans और Eclipse। स्रोत कोड हाइलाइटिंग अमूल्य हो सकता है।

Answer 4

मैं आमतौर पर पैकेज, आयात, जावाडोक, और स्थैतिक/आवृत्ति परिवर्तनीय घोषणा अनुभागों के बाद, मेरी रचनाकारों को अपनी फ़ाइल के शीर्ष के पास रखता हूं।

गियर, ताल, और गति वर्ग चर हैं, संभावित रूप से कहीं भी कन्स्ट्रक्टर के बाहर परिभाषित हैं। स्टार्ट कैडेंस, स्टार्टस्पेड, और स्टार्ट गियर भी चर हैं, लेकिन वे कन्स्ट्रक्टर को पास पैरामीटर हैं।

public Bicycle(int cadence, int speed, int gear) { 
    this.gear = gear; 
    this.cadence = cadence; 
    this.speed = speed; 
} 

जो एक ही नाम के मापदंडों से वर्ग चर सेट:

तुम भी कुछ इस तरह देख सकते हैं।

Answer 5

गियर, ताल और गति वर्ग के सदस्य चर (अन्यत्र घोषित) हैं और प्रारंभ करेंडेंस, स्टार्टस्पेड, और स्टार्ट गियर फ़ंक्शन पैरामीटर हैं।

class Bicycle 
{ 
    private int gear, cadence, speed; 

    public Bicycle(int startCadence, int startSpeed, int startGear) 
    { 
     // set the value of member variables from passed parameters 
     gear = startGear; 
     cadence = startCadence; 
     speed = startSpeed; 

    } 
} 

Answer 6

दरअसल, किसी कन्स्ट्रक्टर के तर्कों को ऑब्जेक्ट के सदस्य चर के रूप में संग्रहीत करने की आवश्यकता नहीं होती है। यहाँ एक उदाहरण है:

class NumberAsString { 

    private String numAsStr; 

    public NumberAsString(double number) { 
     this.numAsStr = Double.toString(number); 
    } 

} 

इस उदाहरण में, निर्माता तर्क वास्तव में कहीं भी संग्रहीत नहीं है, लेकिन अपने मूल्य एक या अधिक सदस्य चर मान की गणना के लिए आवश्यक है।

आपके द्वारा देखा गया व्यवहार, जहां सभी तर्क सीधे सदस्य चर के रूप में संग्रहीत होते हैं, काफी आम है। विशेष रूप से कुछ प्रकार के वर्गों के लिए जो अपने सदस्य चर के लिए "गेटटर" और "सेटर" विधियां प्रदान करते हैं (बिना किसी गणना या परिवर्तन कार्यों की पेशकश किए)। जावा दुनिया में, इन प्रकार के वर्गों को आमतौर पर "बीन्स" के रूप में जाना जाता है। (कौन सा, हाँ, एक बहुत बेवकूफ नाम है।)

Answer 7

int startCadence और ताल के बीच मूल अंतर चर में नहीं है, बल्कि उनके दायरे में है। यदि एक चर के रूप में एक चर के रूप में एक चर परिभाषित किया गया है, यह केवल इस विधि के अंदर मौजूद होगा, लेकिन बाहर नहीं। यदि किसी वर्ग में एक चर परिभाषित किया गया है, तो वह उस वर्ग में हर जगह मौजूद होगा, ऐसे चर के पास वैश्विक दायरा है। परिवर्तनीय स्टार्ट कैडेंस केवल कन्स्ट्रक्टर के अंदर मौजूद होगा, इसलिए यदि आप इसे कहीं और मूल्य का उपयोग करना चाहते हैं, तो आप इसे वैश्विक स्कोप के साथ किसी अन्य चर में भेज सकते हैं। यह वही होता है: कैडेंस = स्टार्ट कैडेंस;

Answer 8

आपके कक्षा स्रोत कोड में आप कन्स्ट्रक्टर को कहां रखना चाहिए?

package statement .... 
import statements.... 


public class MyClass { 
    // instance attributes 
    private int i; 

    // class attribute 
    private static int MAX; 

    // static methods 
    public static int getClassCount() { 
    } 

    // Constructor!! 
    public MyClass() { // constructor. 
    } 

    // public methods 
    // protected methods 
    // private methods 

    // public static void main 
} 

लेकिन वे कहीं भी जा सकते हैं:

मैं निम्नलिखित का उपयोग करें। मुझे लगता है कि दृश्यता के क्रम में चीजें बेहतर हैं। उदाहरण के लिए मेरे पास निजी तरीकों से पहले सार्वजनिक विधियां हैं (इसलिए यदि मैं एक विशिष्ट सार्वजनिक विधि की तलाश में हूं तो मुझे पता है कि यह फ़ाइल के शीर्ष पर है) इसी कारण से मैं आमतौर पर कन्स्ट्रक्टर को शीर्ष पर रखता हूं।

क्या ये तर्क चर के नाम हैं?:

आवश्यक नहीं है, आप उन्हें जितना चाहें नाम दे सकते हैं। मैं आमतौर पर एक ही नाम का उपयोग करता हूं।

... या वेयर के नाम, गियर, ताल और गति हैं? ...

वे उदाहरण चर नाम

(पूर्णांक startCadence, पूर्णांक startSpeed, पूर्णांक startGear) और गियर, ताल और गति में क्या अंतर है कर रहे हैं?

पहले कन्स्ट्रक्टर के लिए पैरामीटर नाम हैं और पूर्व ऑब्जेक्ट के गुणों के नाम हैं।

public class Person { 
    private String name; // a person has a name. 

    public Person(String nameParameter) { 
     this.name = nameParameter; 
    } 
    public String toString() { 
     return "My name is : " + this.name; 
    } 

    public static void main(String [] args) { 

      // creates a new "instance" and assign "Patrick" as its name. 
     Person one = new Person("Patrick"); 
     System.out.println(one); // prints "My name is: Patrick" 

     // each person have its own name. 
     Person two = new Person("Oscar"); 
     System.out.println(two); // prints "My name is: Oscar"   


    } 
} 

जो प्राप्त करता है जैसा कि आप देख, जब आप आप एक तर्क का उपयोग कर रहे निर्माता के लिए एक मूल्य गुजरती हैं, और जब आप निर्माता कोड देख आप पैरामीटर नाम देखते हैं (के रूप में:

यह अन्य नमूना ले लो वह तर्क) और फिर यह आवृत्ति विशेषता को सौंपा गया है।

Answer 9

(int startCadence, int startSpeed, int startGear) मापदंडों निर्माता तर्क होते हैं और वे साइकिल क्षेत्रों cadence, speed, और gear सेट हो जाएगा। वे केवल निर्माता के भीतर उपलब्ध हैं। gear, cadence, और speed प्रत्येक साइकिल उदाहरण के लिए आवृत्ति चर विशिष्ट हैं और अन्य विधियों से संदर्भित हैं। कन्स्ट्रक्टर तर्क आपको ऑब्जेक्ट के प्रारंभिकरण के लिए पैरामीटर प्रदान करने की अनुमति देता है। इस उदाहरण में, आप 1 के एक गियर, 0 का ताल, और 0 इतनी तरह की गति के साथ एक साइकिल वस्तु बना सकते हैं:

Bicycle bike = new Bicycle(0, 0, 1); 

या आप एक चलती साइकिल जहां ताल 60 आरपीएम है बनाते हैं, और कर सकते हैं गति इतनी तरह 10 मील प्रति घंटा है, 3 गियर में:

Bicycle bike = new Bicycle(60, 10, 3); 

निर्माता की नियुक्ति अप्रासंगिक है लेकिन आम तौर पर कंस्ट्रक्टर्स वर्ग परिभाषा की शुरुआत में रखा जाता है।

Answer 10

1) कन्स्ट्रक्टर का स्थान मामूली में कोई फर्क नहीं पड़ता। सम्मेलन से जा रहे हैं हालांकि, मैं व्यक्तिगत रूप से जगह यह इस प्रकार हैं:

public class Bicycle { 

    public int gear, cadence speed; 

    public Bicycle(int startCadence, int startSpeed, int startGear) { 
     gear = startGear; 
     cadence = startCadence; 
     speed = startSpeed; 
    } 

    public void otherFunction1() {} 
    public void otherFunction2() {} 
    public void otherFunction3() {} 

} 

2) गियर, लय और गति वर्ग के सदस्य चर रहे हैं; वे प्रत्येक साइकिल से संबंधित हैं, और प्रत्येक साइकिल के लिए अलग-अलग चर हैं। स्टार्ट कैडेंस, स्टार्टस्पेड, और स्टार्ट गियर, हालांकि, स्थानीय चर हैं, जो केवल उस फ़ंक्शन में हैं। जब मैं एक

new Bicycle(10, 15, 5); 

startCadence के लिए कॉल 10 के लिए सेट है, startSpeed ​​15 के लिए सेट है, और startGear फिर 5. के लिए सेट है, निर्माता उनके "शुरू" इसी चर के सदस्य चर initializes।

Answer 11

public class Account 

{ 

    private static final Exception InsufficientFundsException = null; 

    private int accountNumber; 
    private double availableBalance; 
    private int pin; 
    public Account(int account, int pin,double amount) 
    { 

     this.accountNumber = account; 
     this.pin = pin; 
     this.availableBalance = amount; 
    } 

    public void credit(double amount) 
    { 
     this.availableBalance= this.availableBalance+amount; 
    } 

    public void debit(double amount) throws Exception 
    { 
     if(this.availableBalance>=amount) 
     { 
     this.availableBalance= this.availableBalance-amount; 
     } 
     else 
     { 
      throw new InsufficientFundsException(); 
     } 

    } 

    public int getAccountNumber() 
    { 
     return accountNumber; 
    } 

    public double getAvailableBalance() 
    { 
     return availableBalance; 
    } 
    public String toString() 
    { 
     return "Account="+accountNumber+"pin="+pin+"balance"+availableBalance; 
    } 
    public boolean validatePIN(int pin) 
    { 
     if(this.pin==pin) 
      return true; 
     else return false; 
} 
}