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

प्रथम श्रेणी, Fraction.java, में सभी अंकगणितीय संक्रियाओं के साथ-साथ सबसे बड़े सामान्य भाजक को खोजने, भिन्नों को कम करने और परिणामों को मुद्रित करने के लिए विधि परिभाषाएँ शामिल हैं। मैंने प्रिंटफ़्रैक्शन, कमफ़्रेक्शन, जीसीडी, और एडफ़्रेक्शन विधियों को बनाया है लेकिन मुझे अभी तक घटाना, गुणा करना या विभाजित करने का प्रयास करना है।

दूसरा वर्ग, TestFraction.java, भिन्न वर्ग को लागू करने और इसकी क्षमताओं का परीक्षण करने के लिए डिज़ाइन किया गया है। मैंने इस वर्ग में फ्रैक्शन क्लास का परीक्षण करने के लिए कुछ कोड लिखा है, जबकि मैं अभी भी काम कर रहा हूं और मेरे पास जो विधियां हैं (प्रिंट, कम करें, और जीसीडी) एडफ्रैक्शन के अलावा काम करती हैं। ऐसा लगता है कि यह मेरे द्वारा खोजे जा रहे अंश के बजाय एक मेमोरी एड्रेस या कुछ और प्रिंट करता है। मेरे पास एक विचार है क्यों लेकिन मुझे यकीन नहीं है कि इसे कैसे ठीक किया जाए।

यहाँ मेरा कोड अब तक है। जैसा कि मैंने कहा, मैं एक नौसिखिया हूं और मुझे यकीन है कि यह बहुत अच्छा नहीं है, लेकिन मैं ज्यादातर कार्यक्रम को पूरा करने और काम करने के लिए चिंतित हूं। यदि आपके पास कोई सलाह है, तो कृपया मुझे समझने में आसान बनाने का प्रयास करें। यहां एक नमूना आउटपुट दिया गया है: नमूना आउटपुट

भिन्न.जावा:

public class Fraction {
    private int numerator;
    private int denominator;

    //no-arg constructor
    Fraction() {
        numerator = 0;
        denominator = 1;
    }

    //constructor
    Fraction(int numerator, int denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    //accessor for numerator
    int getNumerator() {
        return numerator;
    }

    //mutator for numerator
    void setNumerator(int num) {
        numerator = num;
    }

    //accessor for denominator
    int getDenominator() {
        return denominator;
    }

    //mutator for denominator
    void setDenominator(int denom) {
        denominator = denom;
    }

    //printFraction method concatenates the numerator and denominator with a "/" string between them
    static void printFraction(int numerator, int denominator) {
        System.out.print(numerator + "/" + denominator);
    }

    //reduceFraction method uses the gcd method to print a reduced version of the fraction given
    public static void reduceFraction(int numerator, int denominator) {
        int smaller;
        if (numerator < denominator) {
            smaller = numerator;
        }
        else {
            smaller = denominator;
        }
        for (int i = smaller; i > 0; --i) {
            if (numerator % i == 0 && denominator % i == 0) {
                System.out.print("Reduced form: " + (numerator/gcd(numerator, denominator)) + "/" + (denominator/gcd(numerator, denominator)));
                break;
            }
        }
    }

    //recursive method that calls itself until it reduces completely to the gcd
    public static int gcd(int numerator, int denominator) {
        if (numerator % denominator == 0) {
            return denominator;
        }
        return gcd(denominator, numerator % denominator);
    }

    public static Fraction addFraction(Fraction a, Fraction b) {
        return new Fraction((a.numerator * b.denominator + a.denominator * b.numerator), (a.denominator * b.denominator));
    }

TestFraction.java (बहुत अधूरा, अभी के लिए केवल बुनियादी परीक्षण शामिल हैं):

import java.util.Scanner;
public class TestFraction {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Enter the first fraction's numerator and denominator separated by spaces: ");
        Fraction myFraction1 = new Fraction(input.nextInt(), input.nextInt());
        System.out.print("Enter the second fraction's numerator and denominator separated by spaces: ");
        Fraction myFraction2 = new Fraction(input.nextInt(), input.nextInt());

        Fraction.printFraction(myFraction1.getNumerator(), myFraction1.getDenominator());
        System.out.println();
        Fraction.printFraction(myFraction2.getNumerator(), myFraction2.getDenominator());
        System.out.println();

        System.out.print(Fraction.gcd(myFraction1.getNumerator(), myFraction1.getDenominator()));
        System.out.println();
        System.out.print(Fraction.gcd(myFraction2.getNumerator(), myFraction2.getDenominator()));
        System.out.println();

        Fraction.reduceFraction(myFraction1.getNumerator(), myFraction1.getDenominator());

        System.out.println();
        System.out.println(Fraction.addFraction(myFraction1, myFraction2));
    }
}
0
bobney 14 फरवरी 2020, 00:51
1
JUnit के साथ परीक्षण करने का प्रयास करें junit.org/junit5 यह अधिक कुशल होगा!
 – 
Xbattlax
14 फरवरी 2020, 01:23

3 जवाब

यहाँ कुछ सुझाव हैं:

  • अपनी कक्षा को अपरिवर्तनीय बनाएं (यानी कोई सेटर्स/म्यूटेटर नहीं और 2 चर अंतिम होना चाहिए)। इस तरह के 'मूल्य' वर्ग को बदलने की अनुमति देने के लिए वास्तव में कोई महान तर्क नहीं है और यह चीजों को बहुत सरल कर देगा क्योंकि आपको वस्तु के निर्माण के बाद चीजों को बदलने के बारे में चिंता करने की आवश्यकता नहीं है। यह जावा एपीआई में सभी Number वर्गों के अनुरूप भी है - उनमें से कोई भी आपको निर्माण के बाद मूल्य बदलने की अनुमति नहीं देता है।
  • अपवाद फेंक कर निर्माता में शून्य भाजक को संभालें - फिर आपको उस मामले के बारे में कहीं और चिंता करने की आवश्यकता नहीं है
  • कंस्ट्रक्टर में नकारात्मक अंशों को संभालें। सबसे आसान तरीका यह है कि कंस्ट्रक्टर को हमेशा सकारात्मक के साथ समाप्त किया जाए। इस तरह आप "3/-4" जैसे अजीब दिखने वाले अंशों के साथ कभी समाप्त नहीं होते हैं
  • Fraction.UNIT और Fraction.ZERO स्थिरांक जोड़ें
  • equals (और hashCode) विधियां जोड़ें - आप चाहते हैं कि new Fraction(1, 1).equals(new Fraction(1, 1)) true लौटाएं और वर्तमान में यह false वापस आ जाएगा
  • यदि आप सभी अंशों को सरलतम रूप में कम करना चाहते हैं, तो कंस्ट्रक्टर में सबसे सरल रूप में कमी को भी संभालें।
  • यदि आप भिन्नों को सरलतम रूप में नहीं संभालना चाहते हैं तो reduce को Fraction में एक विधि बनाएं। इसके सार्वजनिक स्थैतिक होने का कोई कारण नहीं है
  • एक negate विधि है जो सिर्फ अंश के चिह्न को बदल देती है
  • एक inverse विधि है जो सिर्फ हर और अंश को बदल देती है
  • तब substract केवल negate और add का संयोजन हो सकता है और divide inverse और multiply का संयोजन हो सकता है
  • String में बदलने के लिए toString का उपयोग करें

अंतिम सुझाव है कि जूनिट और (आईएमओ) एसर्टज का उपयोग करना सीखें और कस्टम अभिकथन और अपने परीक्षण काल ​​में नए अंश बनाने के लिए एक विधि लिखें। फिर आप बहुत अधिक प्राकृतिक परीक्षण मामलों के साथ समाप्त होते हैं जैसे कि:

assertThat(fraction(2, 4)).isEqualTo(fraction(1, 2));
assertThat(fraction(1, 7).negate()).isEqualTo(fraction(-1, 7));
assertThat(fraction(4, 16)).hasNumerator(1).hasDenominator(4);
assertThatExceptionOfType(ArithmeticException.class)
    .isThrownBy(() -> fraction(1, 0)); 

यह विफल परीक्षणों को त्रुटि संदेशों को समझने में बहुत आसान देगा।

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

2
sprinter 14 फरवरी 2020, 02:03
मैं निश्चित रूप से आपके सुझावों पर गौर करूंगा। यद्यपि आप जिन चीजों के बारे में बात कर रहे हैं उनमें से अधिकांश ऐसी चीजें हैं जिनके बारे में मैंने कभी नहीं सुना है, मैं अपने कौशल में सुधार करना चाहता हूं ताकि मैं और अधिक जटिल समस्याओं को संभाल सकूं। और जहां तक ​​कक्षा को अपरिवर्तनीय बनाने की बात है, मुझे डर है कि मैं अपने प्रोफेसर के निर्देशों के अनुसार ऐसा नहीं कर सकता। लेकिन सभी सलाह के लिए धन्यवाद।
 – 
bobney
14 फरवरी 2020, 03:53

आप किसी ऑब्जेक्ट को System.out.print करने का प्रयास कर रहे हैं। इसे ठीक करने के लिए आप भिन्न वर्ग में एक toString() फ़ंक्शन यहां पसंद करें लिख सकते हैं।

और अपना परिणाम अभी की तरह प्रिंट करें

public string toString(){
    return this.numerator+'/'+ this.denominator;

}
1
Xbattlax 14 फरवरी 2020, 01:29
धन्यवाद। मुझे लग रहा था कि मुझे यह करना होगा लेकिन मुझे नहीं पता था कि कैसे करना है।
 – 
bobney
14 फरवरी 2020, 03:58

स्टैक ओवरफ्लो में आपका स्वागत है।

आप addFraction पर एक println को कॉल कर रहे हैं, जो एक ऐसी विधि है जो Fraction प्रकार का ऑब्जेक्ट लौटाती है। जब आप किसी Java ऑब्जेक्ट पर कोई Println कॉल करते हैं, तो वह ऑब्जेक्ट की toString() विधि लौटाता है। डिफ़ॉल्ट रूप से, यह विधि "छिपी हुई" है और ऑब्जेक्ट का हैश कोड (वह अजीब संख्या जो आप देख रहे हैं) वापस कर देगी।

इसे ठीक करने के लिए यहां कुछ विकल्प दिए गए हैं:

A) toString() विधि को ओवरराइड करें। बस Fraction वर्ग के अंदर कोड का निम्नलिखित ब्लॉक जोड़ें:

@Override
public String toString() {
    return "numerator=" + numerator + ", denominator=" + denominator + "]";
}

बी) इसके बजाय वस्तु के गुणों को प्रिंट करें। अपनी अंतिम प्रिंटलाइन लाइन को निम्नलिखित से बदलें:

Fraction fraction = Fraction.addFraction(myFraction1, myFraction2);
System.out.println( String.format("numerator=%d, denominator=%d", fraction.getNumerator(), fraction.getDenominator()) );

@sprinter द्वारा समझाई गई अवधारणाओं को समझने के लिए कुछ समय निकालें, क्योंकि इससे आपको भविष्य में बेहतर कोड लिखने में मदद मिलेगी। आपको कामयाबी मिले!

1
Fapaz 14 फरवरी 2020, 02:30
बहुत बहुत धन्यवाद, यह जानकर अच्छा लगा। मैंने मदद करने से पहले toString विधियों को देखा है लेकिन मुझे यकीन नहीं था कि मुझे एक की आवश्यकता है या नहीं।
 – 
bobney
14 फरवरी 2020, 03:58