# Objekt Cannot instantiate the type ...



## matt89 (26. Jun 2011)

Objekte Stromkosten Wasserkosten und Kabelanschluss Cannot instantiate the type Kabelanschluss  weis nicht wieso?? danke im voraus

Das Programm hat noch ein interface Rechnung, die klassen(Verbrauchkosten in die das interface implementiert wird, und die zwei klassen Stromkosten und Wasserkosten die von Verbrauchkosten abgeleitet sind;


```
public abstract class Nebenkostenrechnung  {
public static void main(String[] args) {
    Rechnung januar[]=new Rechnung[4];
    
    januar[0]= new Stromkosten( 180, 20);
    januar[1]= new Wasserkosten(20 ,160,5);
    januar[2]= new Kabelanschluss(1450);
    int gesamtbetrag=0;
    for(int i=0;i<januar.length;i++){
        String text;
        System.out.println(januar[i].getRechnungstext(text));
        double rechnung;
        gesamtbetrag=gesamtbetrag+januar[i].getRechnungsbetrag(rechnung);
    }
}
}
```


----------



## Noctarius (26. Jun 2011)

Vielleicht sollte man die Klasse Kabelanschluss auch mal zeigen...

Ist die Klasse abstract, ist Kabelanschluss ein Interface, ist Kabelanschluss ...?


----------



## bLaSt (26. Jun 2011)

matt89 hat gesagt.:


> Objekte Stromkosten Wasserkosten und Kabelanschluss Cannot instantiate the type Kabelanschluss  weis nicht wieso?? danke im voraus
> 
> Das Programm hat noch ein interface Rechnung, die klassen(Verbrauchkosten in die das interface implementiert wird, und die zwei klassen Stromkosten und Wasserkosten die von Verbrauchkosten abgeleitet sind;
> 
> ...



Hey du hast da eine grundlegenden Fehler gemacht. In einer abstrakten Klasse können keine Objekte erzeugt werden. Und genau das kreidet er dir grad an. Des Weiteren werden in abstrakten Klassen für gewöhnlich nach meinem Wissensstand nur Methoden Signaturen gegeben. Die implementierung folgt dann in den davon erbenden Klassen. Deshalb weiß ich gar nicht ob er die Main-Methode überhaupt ausführen kann, da eine abstrakte Klasse für sowas eigentlich gar nicht gemacht ist.


----------



## eRaaaa (26. Jun 2011)

bLaSt du verwechselt glaube ich Interfaces mit abstrakten Klassen 
Und *von* abstrakten Klassen kann man keine Objekte anlegen, aber *in* sollte das schon gehen ;D


----------



## matt89 (26. Jun 2011)

hab meinen fehler schon gefunden


----------



## Noctarius (26. Jun 2011)

bLaSt hat gesagt.:


> Hey du hast da eine grundlegenden Fehler gemacht. In einer abstrakten Klasse können keine Objekte erzeugt werden. Und genau das kreidet er dir grad an. Des Weiteren werden in abstrakten Klassen für gewöhnlich nach meinem Wissensstand nur Methoden Signaturen gegeben. Die implementierung folgt dann in den davon erbenden Klassen. Deshalb weiß ich gar nicht ob er die Main-Methode überhaupt ausführen kann, da eine abstrakte Klasse für sowas eigentlich gar nicht gemacht ist.



In abstrakten Klassen können keine Objekte erzeugt werden?

```
public abstract class Foo {
  private final Object test = new Object();
}
```

In abstrakten Klassen können nur Methoden-Signaturen existieren?

```
public abstract class Foo {
  public void foo() {
    System.out.println("foo");
    bar();
  }

  public void bar();
}
```


----------



## bLaSt (26. Jun 2011)

eRaaaa hat gesagt.:


> bLaSt du verwechselt glaube ich Interfaces mit abstrakten Klassen
> Und *von* abstrakten Klassen kann man keine Objekte anlegen, aber *in* sollte das schon gehen ;D





Noctarius hat gesagt.:


> In abstrakten Klassen können keine Objekte erzeugt werden?
> 
> ```
> public abstract class Foo {
> ...



Joa da habt ihr zwei Recht. Kleine Verwechslung. Ich meinte genau das das von abstrakten Klassen keine objekte erzeugt werden können. Und wir habens halt so gelernt,dass man in abstrakten Klassen oft nur die Signatur reischreibt, da sie später oft von den abgeleiteten Klassen eh überschrieben werden. Man merkt halt,dass ich au erst seit nem halben Jahr programmier,sry und thy fürs verbessern


----------



## Noctarius (26. Jun 2011)

bLaSt hat gesagt.:


> Joa da habt ihr zwei Recht. Kleine Verwechslung. Ich meinte genau das das von abstrakten Klassen keine objekte erzeugt werden können. Und wir habens halt so gelernt,dass man in abstrakten Klassen oft nur die Signatur reischreibt, da sie später oft von den abgeleiteten Klassen eh überschrieben werden. Man merkt halt,dass ich au erst seit nem halben Jahr programmier,sry und thy fürs verbessern



Also abstrakte Klassen bündeln normalerweise Funktionalität die in allen Subclasses gebraucht wird. Das Prinzip nennt sich dann einfach Vermeidung von Codedopplern. Als abstract werden die Methoden definiert, welche später das spezifische Verhalten der Subclasses wiederspiegeln sollen. Diese Methoden kann ich aber wieder innerhalb der abstrakten Klasse nutzen,


----------



## bLaSt (26. Jun 2011)

Noctarius hat gesagt.:


> Also abstrakte Klassen bündeln normalerweise Funktionalität die in allen Subclasses gebraucht wird. Das Prinzip nennt sich dann einfach Vermeidung von Codedopplern. Als abstract werden die Methoden definiert, welche später das spezifische Verhalten der Subclasses wiederspiegeln sollen. Diese Methoden kann ich aber wieder innerhalb der abstrakten Klasse nutzen,



Vielen Dank. Auch wieder was gelernt


----------



## q4q4q4t45643564 (23. Jun 2012)

Hallo,

ich muss mich mal aufregen! Man sucht bei Google nach Lösungen... Da findet man DIESES Forum als 2ten Eintrag! Was liest man: "matt89: hab meinen fehler schon gefunden  " Ja schön! Und wo war er??? Desweiteren wird auch von den anderen Postern keine Lösungsidee vorgetragen! Fazit: Dieser Forumseintrag ist an Nutzlosigkeit nicht zu übertreffen! Und Menschen die ersthaft nach einer Lösung suchen vergschwenden ihre Zeit! Danke für nichts! 

Gruß!


----------



## Uhm...? (23. Jun 2012)

Auch wenn du dich bemüht hast GooGLe zu verwenden hast du es offenbar nicht richtig getan, denn ein paar Links weiter hättest du die Antwort bekommen :

Von Interfaces und abstract class kann man keine direkten Instanzen erstellen.

Der Fehler liegt bei dir also vermutlich daran das du "new" auf ein Interface oder eine abstract class anwendest, was nun mal nicht möglich ist.

Beispiel wie man von einem Interfaces bzw einer abstract class eine Instanz erzeugen kann :


```
Thread thread=new Thread(new Runnable()
{
public void run()
{
}
});
```

Wobei Runnable hier das Interface ist welches implementiert wird. Sowas nennt man dann eine "inner anonymous class". Es gibt noch andere Typen : "inner named class" sowie "nested class".

Das ganze kann man so auch abstract class machen, z.b. [japi]WindowAdapter[/japi]


```
JFrame.addWindowListener(new WindowAdapter()
{
//...
});
```

Der Unterschied ist das Interfaces grundsätzlich nur die Methoden und deren Signaturen vorgeben die eine implementierende Klasse haben muss. Man kann in Interfaces auch Konstanten definieren, aber das macht niemand.
abstract class sind Klassen welche grundsätzlich erweitert werden müssen, also statt implements halt extends. Hat so seine Vor- und Nachteile.
Einer der größeren Nachteile ist z.B. das es in Java keine Mehrfachvererbung gibt. Wenn man also schon irgendeine Klasse erweitert kann man keine andere mehr erweitern. Hier liegt der Vorteil bei Interfaces da man mit ihnen eine Art pseudo-Polymorphismus erzeugen kann.
Ein Vorteil von abstract class ist aber das man in diesen bereits Code implementieren kann. Dies geht dann aber nur in den Methoden die selbst nicht mit abstract gekennzeichnet wurden (denn eine abstract method in einer abstract class ist vergleichbar mit der Signatur in einem Interface).
Der genaue Vorteil ist das man in abgeleiteten Klassen diesen Code nicht immer wieder neu implementieren muss sondern einfach [c]super.XXX()[/c] callen kann.


Auch wenn diese Erklärung jetzt weniger mit dem Problem selbst zu tun hat hilft es dir vielleicht die Verwendungsweise zu verstehen damit du in Zukunft nicht mehr in diesen Error rennst.


----------

