Java Vererbung

[Gansa]

Hallo, das ist ein Programm welches den durschntt einer übergebenen Liste berechnet. Ich verstehe nicht ganz was hinter dem Klassennamen passiert, ich muss zuerst von einer Number erben, damit das alles funktioniert. Ich kann danach wieder erben von einer ArrayList. Wieso muss ich erst von einer number erben? gibt es eine gute Seite die genau solche Sachverhalte sehr gut erklärt? Und wieso kann ich in der for schleife einen primitiven int benutzen statt Integer? Danke im Voraus!

public class Durchschnitt<T extends Integer> extends ArrayList<Integer> {


    public int getAverage() {

        int sum = 0;


          for (int value : this) {
            sum += value;

        }

        return sum / size();
    }


}

 

[White_Fox]

Deine Klasse erbt NICHT von Integer. Deine Klasse erbt nur von ArrayList<Integer>.

Der Ausdruck <T extends Integer> definiert einen Typen, der von Integer erbt (Stichwort Generics). Ansich ist dieses Generic momentan witzlos, da es nirgendwo verwendet wird.

Allerdings kennst du diesen Mechanismus bereits offensichtlich: Z.B. wird der auch bei ArrayList verwendet. Du mußt, wenn du eine ArrayList deklarierst, auch den Typen mitliefern: ArrayList<IrgendeineKlasse> list.
Damit weiß der Compiler, das nur Objekte vom Typ 'IrgendeineKlasse' da hineingehören.

Der Ausdruck <T extends Integer> hat im Prinzip die gleiche Funktion bei dir, mit einer zusätzlichen Einschränkung: T darf nicht irgendein Typ sein, sondern muß ein Integer oder einer daraus abgeleiteten Klasse sein.

 

[insert2020]

Also denkbar ist das durchaus... Es kann aber auch zu Problemen kommen, wie dieses Beispiel zeigt:

import java.util.ArrayList;

public class MyAvgList<T extends Number> extends ArrayList<T> {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public double getAvg() {
		return this.stream().mapToInt(Number::intValue).average().getAsDouble();
	}

	public double getAvg2() {
		double sum = 0;
		for (Number n : this) {
			sum += n.doubleValue();
		}
		return sum / this.size();
	}

	public static void main(String[] args) {
		MyAvgList<Double> list = new MyAvgList<>();
		list.add(1.9);
		list.add(2.9);
		list.add(3.9);
		System.out.println(list.getAvg()); // will print 2.0, because we use the integer value
		System.out.println(list.getAvg2()); // will print 2.9, because we use the double value
	}
}

Du musst dich also beim Zusammenrechnen auf int, long, float oder double festlegen...

 

[insert2020]

Und vorsichtshalber solltest du immer

return sum / (double) this.size();

schreiben,
denn der Durchschnitt ist ja eine reelle Zahl.

 

[httpdigest]

    public double getAvg() {
        return this.stream().mapToInt(Number::intValue).average().getAsDouble();
    }
    ...
    System.out.println(list.getAvg()); // will print 2.0, because we use the integer value

Nope. IntStream.average() liefert schon korrekt das arithmetische Mittel als double. Hier findet _keine_ Integer-Arithmetik statt!

Und vorsichtshalber solltest du immer

return sum / (double) this.size();

schreiben,
denn der Durchschnitt ist ja eine reelle Zahl.

Ein expliziter Cast nach double ist hier nicht notwendig, da `sum` in deinem Beispiel bereits ein double ist, und somit this.size() automatisch zu einem double für die Division gecastet wird.

 

[temi]

Also denkbar ist das durchaus...

Worauf bezieht sich denn diese Aussage? Also was ist denkbar?

 

[temi]

Und wieso kann ich in der for schleife einen primitiven int benutzen statt Integer?

Integer und int werden vom Compiler automatisch umgewandelt, siehe "Autoboxing".

int i = 42;
Integer j = i; // Boxing entspricht: j = Integer.valueOf(i);
int k = j; // Unboxing entspricht: k = j.intValue();

Die Klasse, wie sie im Eingangsbeitrag steht, könnte auch folgendermaßen aussehen, da du bei der ArrayList ja schon angegeben hast, dass es sich um eine Liste von Integers handelt. Sie erbt damit von einer ArrayList<Integer> (kann damit nur Integer-Werte aufnehmen) und erweitert diese um eine Methode getAverage()

public class Durchschnitt extends ArrayList<Integer> {

    public int getAverage() {
        int sum = 0;

        for (int value : this) {
            sum += value;
        }

        return sum / size();
    }
}

Der Ausdruck <T extends Integer> definiert einen Typen, der von Integer erbt (Stichwort Generics). Ansich ist dieses Generic momentan witzlos, da es nirgendwo verwendet wird.

Es ist sogar generell witzlos, weil Integer eine finale Klasse ist und es keinen Typen gibt, der davon erben könnte.

Sinnvoll wäre z.B. was @insert2020 geschrieben hat

public class Durchschnitt<T extends Number> extends ArrayList<T>

Damit hast du dann eine generische Klasse (wobei der Code in der Methode auch noch angepasst werden muss!), die alle Typen aufnehmen kann, die von Number erben.

Durchschnitt<Integer> intAverage = new Durchschnitt<>();
Durchschnitt<Long> longAverage = new Durchschnitt<>();

 

[insert2020]

Nope. IntStream.average() liefert schon korrekt das arithmetische Mittel als double. Hier findet _keine_ Integer-Arithmetik statt!

Du hast

.mapToInt(Number::intValue)

übersehen. Das wählt von Number den integer value, nicht den double value. Das anschließende Mittel wird natürlich richtigerweise als double value berechnet. Aber das war nicht was ich geschrieben hatte.

Ein expliziter Cast nach double ist hier nicht notwendig, da

Nein, hier nicht, weil ich double als Summe gewählt hatte - im Allgemeinen macht es aber Sinn, wenn zum Beispiel integer oder long als Summe gewählt wird...
A besser lesbar
B weniger fehleranfällig

 

[MoxxiManagarm]

Können wir bitte nicht ignorieren, dass die Klasse von einer ArrayList erbt?

Hallo, das ist ein Programm welches den durschntt einer übergebenen Liste berechnet.

Die Vererbung wie oben dargestellt wiederspricht sämtlichen Konventionen. Stichwort: Composition over inheritance. Ich wette die Aufgabenstellung lautete ähnlich dem Zitat, d.h.

Schreiben Sie ein Programm, welches den Durchschnitt einer übergebenen Liste berechnet.

Von einer Liste erben ist nicht übergeben. Übergeben heißt Funktionsparameter.