[Naloga][Java] Ulomki

Ciao!

Simple nalogica, a meni dela tezave.
Imam glavni razred Ulomek. Razred se mi lepo prevede. Zraven sem se napisala, testni razred TestUlomek, da vidim, ce mi glavni razred dela kakor treba. Vendar se mi ne prevede.
###########################################################
Glavni razred.

public class Ulomek {

	// komponente
	private int st;  // komponenta za stevec
	private int im;   // komponenta za imenovalec

	// konstruktorji
	// konstruktor, ki sprejme vrednost stevca in imenovalca ter nastavi vrednost komponent st in im
	public Ulomek(int a, int b) throws Exception{
		if(b != 0){
			this.st = a;
	    	this.im = b;
		}
		else{
			throw new Exception("To ni ulomek. Imenovalec ne sme biti enak 0!");
		}
	}

	// konstruktor, ki sprejme celo stevilo a in naredi ulomek a/1
	public Ulomek(int a) {
		this.st = a;
		this.im = 1;
	}

	// prazni konstruktor
	public Ulomek(){
		this.st = 1;
	    this.im = 1;
	}

	// Metode

	// primerjava ulomkov
	// ce je ulomek x enak ulomku this
	public boolean equals(Ulomek x) {
		return x.st * this.im == this.st * x.im;
	}

    // vrne niz znakov, ki predstavlja ulomek (npr. new Ulomek(6,8), predstavimo z nizim "6/8")
	public String toString(){
		if(this.im == 1) {
			return Integer.toString(this.st);
		}
		return this.st + "/" + this.im;
	}

	/* primerja ulomka x in this in vrne:
	   negativnos tevilo, ce je this < a
	   stevilo 0, ce je this = a
	   pozitivno stevilo, ce je this > a
	*/
	public int compareTo(Ulomek x)throws java.lang.Exception {
		Ulomek razlika = this.razlika(x);
		razlika.okrajsaj();
		return razlika.st;
	}

	// pokrajsamo ulomek
	public void okrajsaj() {
		int d = gcd(this.st, this.im);
		this.st = this.st / d;
		this.im = this.im / d;
		if(this.im < 0) {
			this.im = -this.im;
			this.st = -this.st;
		}
	}

	// izracunamo najvecji skupni delitelj dveh celih stevil
	public static int gcd(int x, int y) {
		x = Math.abs(x);
		y = Math.abs(y);
		if (y == 0) {
			return x;
		}
		else {
			return gcd(y, x%y);
		}
	}

// Vsota
    /* metodi vsota in pristejUlomek imata enako funkcijo, sestejeta dva ulomka
	   razlikujeta pa se v tem, da metoda vsota, objekta, na katerm jo klicemo,
	   ne spremeni
	 */

	public Ulomek vsota (Ulomek x) throws java.lang.Exception{
		return new Ulomek(x.st * this.im + x.im * this.st, x.im * this.im);
	}
    // tu dobi stevec novo vrednost, ki je enaka vsoti
	public void pristejUlomek(Ulomek y) {
		this.st = this.st * y.im + this.im * y.st;
		this.im = this.im * y.im;
	}

// Razlika
    /* metodi razlika in odstej imata enako funkcijo, odstevanje dveh ulomkov
	   razlikujeta pa se v tem, da metoda razlika, objekta, na katerm jo klicemo,
	   ne spremeni
	 */
	public Ulomek razlika(Ulomek x) throws java.lang.Exception {
		return new Ulomek(this.st * x.im - this.im * x.st, this.im * x.im);
	}
	 // tu dobi stevec novo vrednost, ki je enaka razliki
    public void odstej(Ulomek x) {
		this.st = this.st * x.im - this.im * x.st;
		this.im = this.im * x.im;
	}

// Produkt
	/* metodi zmnozek in zmnozi imata enako funkcijo, zmnozita dva ulomka
	   razlikujeta pa se v tem, da metoda zmnozek, objekta, na katerm jo klicemo,
	   ne spremeni
	 */
	 // tu imenovalec in stevec ostaneta enaka
	public Ulomek zmnozek(Ulomek x) throws java.lang.Exception{
		return new Ulomek(this.st * x.st, x.im * this.im);
	}
    // tu stevec dobi novo vrednost, ki je enaka produktu
	public void zmnozi(Ulomek x) {
		this.st = this.st * x.st;
		this.im = this.im * x.im;
	}

// Kvocient
    /*metodi kvocient in deli imata enako funkcijo, delita dva ulomka
	 razlikujeta pa se v tem, da metoda kvocient, objekta, na katerm jo klicemo,
	 ne spremeni
	 */
	//Delenje ulomkov
	public Ulomek kvocient(Ulomek x)throws Exception {
		if (st != 0 && im != 0){
			return new Ulomek(this.st * x.im, x.st * this.im);
		}
		else{
			throw new Exception("To ni ulomek.");
		}
	}
     // tu dobi stevec novo vrednost, ki je enaka kvocientu
	public void deli(Ulomek x) {
		this.st = this.st * x.im;
		this.im = this.im * x.st;
	}

}

##################################################################
Testni razred:

// testni program

public class TestUlomek {
	public static void main(String[] args){

		// naredimo nekaj ulomkov
	    Ulomek a = new Ulomek(2,5);
	    Ulomek b = new Ulomek(3,4);
	    Ulomek c = new Ulomek(3);


	   // preizkusanje metod
	   // metodo equals
      // primerjava dveh ulomkov, v nasem primeru ulomka a in b
	   if (a.equals(b) == true)
	   System.out.println("Ulomka a = " + a +" in b = " + b +" sta enaka.");
	   else
	   System.out.println("Ulomka a = " + a +" in b = " + b +" sta razlicna.");
	   System.out.println();


      // objektna metoda comareTo
      // primerjava ulomkov
      // ce je ulomek a < c nam metoda vrne negativno stevilo
      // ce je ulomek a = c nam metoda vrne stevilo nic
      // ce je ulomek a > c nam metoda vrne pozitivno stevilo stevilo

	   System.out.println(a + " = " + c + " ? " +a.compareTo(c));
	   System.out.println();

// Vsota
	   // izracunamo vsota dveh ulomkov
	   System.out.println("Vsota ulomka: "+ a.vsota(b)+ " pri cemer je a = "+a+ " in b = " +b+ ".");
	   System.out.println();

        //ulomku a pristej ulomek b in od tu naprej ima ulomek a novo vrednost
	   System.out.println("a = " +a);
	   a.pristejUlomek(b);
	   System.out.println("Nova vrednsot ulomka a  = " + a);
	   System.out.println();


//Razlika
       // od novega ulomka a odstejemo staro vrednost ulomka b
       System.out.println("Od ulomka a odstejemo ulomek b.");
	   System.out.println(a + " - " + b + " = " + a.razlika(b));
	   System.out.println();

       // od novega a odstejemo b in a dobi novo vrednost
	   System.out.println("Od ulomka a = " +a+ " odstejemo ulomek b.");
	   a.odstej(b);
	   System.out.println("Nova vrednost ulomka a = " + a + ", po opravljeni operaciji.");
	   System.out.println();

// Produkt
       //Objektni metodi za mnozenje
       // zmnozimo ulomka skupaj
       System.out.println("Produkt ulomkov a in b.");
	   System.out.println(a + " * " + b + " = "  +a.zmnozek(b));
	   System.out.println();

        // Ulomek a mnozimo z ulomkom b, ter ulomek a dobi novo vrednost
	   	System.out.println("a = " +a);
	    a.zmnozi(b);
	    System.out.println("Nova vrednost ulomka a = "+ a + ", po opravljeni operaciji.");
	    System.out.println();

//Kvocient
        // Delenje ulomkov
        System.out.println("Ulomek a delimo z ulomkom b.");
	    System.out.println(a.kvocient(b));
	    System.out.println();

         // delimo ulomka in v ulomek a shranimo novo vrednost
	    System.out.println("a = " +a);
	    a.deli(b);
	    System.out.println("Nova vrednost ulomka a = " + a + ", po opravljeni operaciji.");

	}
}

##############################
ter napake ko zazenem testni program
TestUlomek.java:7: unreported exception java.lang.Exception; must be caught or declared to be thrown
Ulomek a = new Ulomek(2,5);
^
\TestUlomek.java:8: unreported exception java.lang.Exception; must be caught or declared to be thrown
Ulomek b = new Ulomek(3,4);
^
\TestUlomek.java:28: unreported exception java.lang.Exception; must be caught or declared to be thrown
System.out.println(a + " = " + c + " ? " +a.compareTo(c));
^
\TestUlomek.java:33: unreported exception java.lang.Exception; must be caught or declared to be thrown
System.out.println("Vsota ulomka: "+ a.vsota(b)+ " pri cemer je a = "+a+ " in b = " +b+ ".");
^
\TestUlomek.java:46: unreported exception java.lang.Exception; must be caught or declared to be thrown
System.out.println(a + " - " + b + " = " + a.razlika(b));
^
\TestUlomek.java:59: unreported exception java.lang.Exception; must be caught or declared to be thrown
System.out.println(a + " * " + b + " = " +a.zmnozek(b));
^
\TestUlomek.java:71: unreported exception java.lang.Exception; must be caught or declared to be thrown
System.out.println(a.kvocient(b));
^
######################
A kdo ve kako bi lahko odpravla te napake.

Hvala vsem!

Ciao ciao

Povsod kjer imaš throw exception moraš dati še catch.

Evo. K testnemu programu dodaš za try{ ... } catch(Exception e) {} . To potem izgleda takole:

public class TestUlomek {
public static void main(String[] args){
   try {
      Ulomek a = new Ulomek(2,5);

      ...telo programa...

      a.deli(b);
      System.out.println("Nova vrednost ulomka a = " + a + ", po opravljeni operaciji.");
   } catch (Exception e) {}
      ...
   }
}

Sem probal in dela.

Ali pa bi sam takole napisala glavo metode pa bi tud delalo, da se ne matraš s try-catch bloki, ki se mi zdi, da niso še predmet tvojega učenja?

public static void main(String[] args) throws Exception {

}