# Konstruktoren überladen



## alge (21. Mrz 2007)

Hallo zusammen. Schlage mich grade mit folgender Aufgabe rum:

"Schreiben Sie eine Klasse NaturalNumber (Naturliche Zahl), die wie folgt aussieht:
class NaturalNumber {
public NaturalNumber()
public NaturalNumber(NaturalNumber other)
public int getValue()
public void add(NaturalNumber other)
public void multiply(NaturalNumber other)
public void power(NaturalNumber other)
private int value;
}
Der Konstruktor: public NaturalNumber() erzeugt ein NaturalNumber-Objekt mit value=0.
Der Konstruktor: public NaturalNumber(NaturalNumber other) erzeugt ein NaturalNumber-Objekt mit value=other.getValue()+1. Die Methoden add, multiply, und power (addieren, multiplizieren, potenzieren) sollen
zur Berechnung nur die Operatoren ++ und -- verwenden. Schreiben Sie ebenfalls
eine main-Methode, die die verschiedenen Methoden der Klasse NaturalNumber testet."

Allerdings scheitert daß bei mir an der Anlage der Konstruktoren, denn wenn ich die teste, wird die Instanzvariable value immer mit 0 ausgegeben, auch bei Objekten wo das nicht sein kann. Warum das? Danke.

Mein Code:

```
import java.io.*;
import java.util.*;

class Natural {
		
public Natural() {
	int value = 0;
}

public Natural(Natural other) {
	int value = (other.getValue())+1;
}
		
		public int getValue() {
		return this.value;
			}	
			
		public void add(Natural other) {
			int grenze = other.getValue();
			int count = 0;
			while (count < grenze) {
			value++;
			count++;
		}
		}
		
		public void multiply(Natural other) {
			int grenze = other.getValue();
			int count = 1;
			while (count < grenze) {
				this.add(this);
				count++;
			}
		}
		
		public void power(Natural other) {
			int grenze = other.getValue();
			int count = 1;
			if (grenze == 1) {
				value = 0;
			}
			while (count < grenze) {
				this.multiply(this);
			}
		}
	
	private int value;
}
```


----------



## Leroy42 (21. Mrz 2007)

Durch das

```
public Natural(Natural other) { 
   int value = (other.getValue())+1; 
}
```
erzeugst du ein methoden-lokales _value_ das die Instanzvariable überdeckt.

So ists richtig:

```
class Natural { 
  private int value;       
  public Natural() { 
     value = 0; 
  }
  ...
}
```


----------



## alge (21. Mrz 2007)

Danke schonmal. Aber wie soll ich den Konstruktor mit dem NaturalNumber-Objekt im Parameter jetzt schreiben? Ich steh irgendwie auf der Leitung, denn wie soll das anders gehen?


----------



## JPKI (21. Mrz 2007)

```
public class Natural {
 private int value;

 public Natural() {
  this(0);
 }

 public Natural(int value) {
  this.value = value;
 }

 public Natural(Natural other) {
  this.value = (other.getValue())+1;
 }

  public int getValue()...
}
```


----------



## Leroy42 (21. Mrz 2007)

JPKI hat gesagt.:
			
		

> ```
> public Natural() {
> this(0);
> }
> ```


Sehr schön!   



			
				JPKI hat gesagt.:
			
		

> ```
> public Natural(Natural other) {
> this.value = (other.getValue())+1;
> }
> ```



Och nööh!   

```
public Natural(Natural other) {
  value = (other.getValue())+1;
 }
```
Oder schreibst du sonst *immer* _this._?

Oder, um in deinem Stil zu bleiben:

```
public Natural(Natural other) {
  value = (other.getValue())+(1);
 }
```
 :bae:


----------



## JPKI (21. Mrz 2007)

Wer macht denn wegen *einem* Wort so einen Aufstand  ...
Es funktioniert doch, das ist doch das wichtigste, gelle  ;-) ?

Und *ja*, ich bin bekennender *this-Schreiber* und stehe dazu  :autsch:  :bae:  :toll:   !


----------



## alge (21. Mrz 2007)

Ich muss euch kurz unterbrechen: mein Grosshirn will nicht mehr :roll:. Die power-Methode in meinem Programm gibt leider schwachsinnige Werte aus, aber ich find den Fehler nicht.



```
public void power(Natural other) {
         int grenze = other.getValue();
         int count = 1;
        Natural p = new Natural(this.getValue());
         if (grenze == 1) {
            value = 0;
         }
         while (count < grenze) {
            this.multiply(p);
            count++;
         }
      }
```


----------



## Marco13 (21. Mrz 2007)

Probier mal' deine multiply-Methode mit 6 und 3 aus. 
Dort hast du den gleichen Fehler gemacht, wie anfangs bei der Power-Methode.

Wenn du denjenigen, der die Aufgabe gestellt hat, ein bißchen ärgern willst, präsntier' ihm doch mal das hier

```
import java.io.*;
import java.util.*;

class Natural {

    public static void main(String args[])
    {
        Natural a, b;

        a = new Natural(4);
        b = new Natural(3);
        System.out.print(a+" + "+b+" = ");
        a.add(b);
        System.out.println(a);

        a = new Natural(4);
        b = new Natural(3);
        System.out.print(a+" * "+b+" = ");
        a.multiply(b);
        System.out.println(a);

        a = new Natural(4);
        b = new Natural(3);
        System.out.print(a+" ^ "+b+" = ");
        a.power(b);
        System.out.println(a);
    }


      private int value;

      public Natural() {
         value = 0;
      }

      public Natural(int value) {
         this.value = value;
      }

      public Natural(Natural other) {
         value = _(0,value,other.value);
      }

      public void add(Natural other)
      {
         value = _(1,value,other.value);
      }

      public void multiply(Natural other)
      {
         value = _(2,value,other.value);
      }

      public void power(Natural other)
      {
         value = _(3,value,other.value);
      }

      public int getValue()
      {
         return this.value;
      }

      static int _(int __, int ___, int ____)
      {
          if(__==0){____++;return ____;}else if(____==0){return __==1?___:__==2?0:1;}
          else{____--;int _____=_(__,___,____);__--;return _(__,___,_____);}
      }

      public String toString()
      {
          return String.valueOf(value);
      }
}
```
(edit: Code noch ein bißchen editiert)


*fies grins* Ich liebe sowas


----------



## Marco13 (22. Mrz 2007)

Vielleicht noch eine Preisfrage: Was kommt raus, wenn man der Funktion als ersten Parameter eine 4 übergibt?
Wer es errät, gewinnt ein byte seiner Wahl


----------



## Marco13 (22. Mrz 2007)

Ich lös' dann mal auf: Wenn man eine 4 übergibt, berechnet die Funktion für die weiteren Argumente x und y den Wert
((..(x^x)^x)^x ... (y-mal)... )^x
Also x "hoch hoch" y


----------

