# nicht-instanzierbare Klassen



## johannesK (19. Jun 2011)

Nicht-instanzierbare Klassen sind, wenn ich das richtig verstanden habe, abstrakte Klassen, die Ihren Subklassen nur als Methodengeber dienen und die Subklassen implementieren diese Methoden dann.

Wenn ich also folgende Aufgabe bekomme :
Implementieren Sie eine nicht-instanzierbare Klasse RobotShell, die eine Benutzersteuerung fur einen Roboter enthalt. Diese Klasse soll auch die main-Methode enthalten, welche die Shell startet.

Ich habe folgendes versucht:

```
public abstract class RobotShell {
  ....
  public void walk(int distance) {}
  public void turnLeft() {}
  public void turnRight() {}
  ...

  public static void main(String[] args) {
  ......
```


```
public class Robot extends RobotShell {
  ...
 public void walk(int distance) {
    if (batteryStatus >= batteryConsumption() * distance) {
      int steps = distance;
      switch (orientation) {
        
      case 0 : y = y + steps;
      break;
        
      case 1 : x = x + steps;
      break;
      
      case 2 : y = y - steps;
      break;
        
      case 3 : x = x - steps;
      break;
    
      default : break;
      }
      batteryStatus = batteryStatus - steps * batteryConsumption();
  }
  ...
}
```

Meine Frage ist: Wie "starte" ich die Shell und wie kann ich aus der main methode auf die (nicht-staischen) methoden walk(), turnLeft(), .... zugreifen, da ich ja in der main keine Instanz von RobotShell erzeugen kann ?


Vielen Dank.

Johannes


----------



## Ark (19. Jun 2011)

Nicht-instanziierbar heißt in dem Fall: Es gibt kein Objekt vom Typ RobotShell. Das heißt insbesondere: der einzige Konstruktor ist der Default-Konstruktor (der ohne Parameter), und dieser ist private (damit niemand von außen eine Instanz erzeugen kann). Auch die Klasse RobotShell selbst erzeugt keine Instanz (ruft also ihren einzigen privaten Konstruktor niemals auf). Ich denke auch, dass die Klasse RobotShell final sein muss, damit keiner auf die Idee kommt, RobotShell abzuleiten und dort einen Konstruktor reinzupflanzen, aber da bin ich mir nicht so sicher.

Schau dir mal die Klasse java.lang.Math an, sie ist das Paradebeispiel für eine nicht-instanziierbare Klasse. Dort sind alle Methoden aus gutem Grunde static. 

Das, was du in deinen ersten Sätzen beschrieben hast, sind abstrakte Klassen. Diese sind instanziierbar, aber nur über ihre Ableitungen. Hilfsklassen wie java.lang.Math sind niemals instanziierbar.

… oder reden wir hier gerade aneinander vorbei, und du meinst eigentlich nur abstrakte Klassen?

Ark


----------



## johannesK (19. Jun 2011)

Danke für die Hilfe. Ich habe die Shell jetzt folgendermassen umgestellt :


```
public final class RobotShell {
  ...
  public static void walk(Robot r, int distance) {
    r.walk(distance);
  }
  ...
public static void main(String[] args) {
...
r = new Robot(shellWorld);
...
walk(r, distanceToEdge);
...
```

und die Klasse Robot (nicht mehr als Unterklasse zu RobotShell)

```
public class Robot{
    public void walk(int distance) {
    ...
    }
}
```

Meine Frage bleibt jetzt aber noch was mit "starten der Shell" innerhalb der main methode gemeint ist?


Vielen Dank 

Johannes


----------



## Ark (19. Jun 2011)

Mit "Shell starten" ist wahrscheinlich gemeint, dass dem Nutzer die Möglichkeit der Kommunikation (über eine Shell) bereitgestellt werden soll. _Nicht_ damit gemeint ist, dass du so was wie meineRobotShell.starte() machst, da das nur was Internes ist.

Also: [c]System.out.println("Ich bin deine Shell, sag mir was.");[/c] könnte die erste Anweisung in der main()-Methode sein, und damit meldet sich schon die Shell (also das Ding, wo der Benutzer was eingeben kann) gegenüber diesem Benutzer.

Ich denke, so ist das gemeint.

Ark


----------

