# Beispiel für ein möglichst einfaches Interface



## ernst (31. Mrz 2010)

Hallo allerseits,
um Interfaces zu verstehen, habe ich versucht ein maximal _einfaches_  Beispiel zu konstruieren, in dem ein Interface und Polymorphie vorkommt.

Beispiel:
1) Eine Firma stellt verschiedene Produkte her:
Radios, Telefone, Ballerspiele.
Konkret:
Die Klassen Radio, Telefon, Ballerspiel sind Unterklassen der Klasse Produkt.
Die Klassen Radio und Telefon besitzen im Gegensatz zu der Klasse Ballerspiel das Attribut farbe. Ballerspiel besitzt im Gegensatz zu Produkt das Attribut dateigrösse.
Die Klasse Produkt besitzt das Attribut name. 
Jede dieser Klasse soll auch die Methode getBeschreibung() besitzen, die die jeweiligen Attribute der Klasse (zu Testzwecken) auf dem Bildschirm ausgibt.
Um Polymorphie zu demonstrieren, kann man ein paar Radios, Telefone und Ballerspiele in das Array produkte[] mit dem Datentyp Produkt abspeichern und mit getBeschreibung() die Werte der Attribute dieser Radios, Telefone und Ballerspiele auf dem Bildschirm ausgeben.
So weit so gut.

2)
Um ein Interface zu „motivieren“ habe ich folgendes gemacht:
In dem Interface GegenstandIF wird die Methode getFarbe() deklariert.
Die Klassen Radio und Telefon implementieren dieses Interface GegenstandIF
Um Polymorphie zu demonstrieren, kann man ein paar Radios und Telefone in das Array gegenstaende [] mit dem Datentyp GegenstandIF abspeichern und mit getFarbe() die Werte der Attribute dieser Radios und Telefone auf dem Bildschirm ausgeben.
Man kann damit zwar Interface und Polymorphie demonstrieren, doch habe ich mit dem Beispiel ein Problem:
Ich kann in der Schleife, die aus dem Array gegenstande[] die Farbe der Radios und Telefone (mit getFarbe()) ausliest nicht auch noch den Namen der Produkte ausgeben.

Kann mir jemand mein Beispiel so abändern, dass es sinnvoller wird ?

Mit freundlichen Grüßen
Ernst


```
package sinninterface15;

public interface GegenstandIF {
    void setFarbe(int pFarbe);
    int getFarbe();

}
```


```
package sinninterface15;

public class MainSinnInterface15 {
	public static void main(String[] args) {
		int i;
        Produkte produkte[];
        GegenstandIF  gegenstaende[];

		produkte = new Produkte[3];
		gegenstaende = new GegenstandIF[2];

        produkte[0] = new Radio("RadioVatikan", 120);
        gegenstaende[0] = new Radio("RadioHoliday", 12);

		produkte[1] = new Telefon ("Teletron", 321);
        gegenstaende[1] = new Telefon ("Urlaubstelefon", 3);

        produkte[2] = new Ballerspiel("BallerinaI", 30);


        System.out.println("Beschreibung der Gegenstaende:");
		for(i=0;i<3;i++){
			System.out.println(produkte[i].getBeschreibung());
		}
        System.out.println("\nFarbe der Gegenstaende:");
		for(i=0;i<2;i++){
			System.out.println("Farbe="+gegenstaende[i].getFarbe());
		}
	}
}

abstract class Produkte{
    protected String name;

	public Produkte(String pName){
		name = pName;
    }

	public String getName(){
		return(name);
	}

    abstract public String getBeschreibung();
}

class Telefon extends Produkte implements GegenstandIF{
     int farbe;

    public Telefon(String pName, int pFarbe){
        super(pName);
        farbe = pFarbe;
    }

    public String getBeschreibung(){
        String s;
        s="Produktname="+name+" Produktfarbe="+farbe;
        return s;
    }

    public void setFarbe(int pFarbe){
        farbe = pFarbe;
    }
    public int getFarbe(){
        return farbe;
    }
}

class Radio extends Produkte implements GegenstandIF{
	private int farbe;

    public Radio(String pName, int pFarbe){
        super(pName);
        farbe = pFarbe;
    }

    public String getBeschreibung(){
        String s;
        s="Produktname="+name+" Produktfarbe="+farbe;
        return s;
    }

    public void setFarbe(int pFarbe){
        farbe = pFarbe;
    }

    public int getFarbe(){
        return farbe;
    }
}

class Ballerspiel extends Produkte{
	private int dateigroesse;

    Ballerspiel(String pName, int pDateigroesse){
        super(pName);
        dateigroesse = pDateigroesse;
    }

    public String getBeschreibung(){
        String s;
        s="Produktname="+name+" Dateigroesse="+dateigroesse;
        return s;
    }

    public double getDateigroesse(){
        return dateigroesse;
    }
}
```


----------



## Wildcard (31. Mrz 2010)

> Ich kann in der Schleife, die aus dem Array gegenstande[] die Farbe der Radios und Telefone (mit getFarbe()) ausliest nicht auch noch den Namen der Produkte ausgeben


Und das ist auch genau der Sinn des Interface. Dein Interface sagt 'ich habe eine Farbe'. Du kannst wohl kaum davon ausgehen das alles was eine Farbe hat auch ein Produkt ist.


----------



## faetzminator (31. Mrz 2010)

Ganz unabhängig von deiner Fragestellung solltest du folgende Punkte beachten:
- Interfaces sieht man oft mit "I<Name>" oder "<Beschreibung>", "<Name>IF" finde ich eine schlechte Wahl. "Farbig" währ da die bessere Wahl, siehe aber nächsten Punkt.
- Du hast im Code zumindest keine Umlaute verwendet, aber der Code sollte möglichst in Englisch gehalten werden (über die Comments kann man sich streiten).
- [c]System.out.println("\n[/c] sieht auch nicht gerade toll aus, zumal da an Stelle des systemweiten Trennzeichen einfach [c]\n[/c] verwendet wird. Schreib einfach noch [c]System.out.println()[/c] vor diese Linie.
- Die dreizeilige Methode [c]getBeschreibung()[/c] finde ich etwas unnötig, das geht auch in einer Zeile (oder mit StringBuffer/-Builder).
- In "normalem" Code sollte man keine Arrays verwenden (objektorientierung etc.), verwende lieber [c]List<Produkte>[/c].

Ja, ich weiss, dieser Code wurde nicht bei den Anfängerthemen gepostet, trotzdem darf man ab und zu etwas zum Codestil sagen


----------



## agentone (31. Mrz 2010)

Die Klasse Produkte beschreibt doch eig. nur ein Produkt, oder? 
-> Umbennen in "Produkt"

Das Interface GegenstandIF besitzt diese hässliche Endung "IF".
Ich weiß nicht, wo du die her hast, aber lass sie weg!
(In der Java-API besitzt kein einziges Interface so eine Endung.)

Zu den Klassen und Interfaces:

Ich würde zunächst eine kleine Änderung vorschlagen: 
-interface Produkt
-abstract class AbstractProdukt implements Produkt

Sehr interessant ist, dass Produkte keine Gegenstände sind. (Produkt implements Gegenstand)
Wenn es so wäre, könntest du genau das machen, was du willst.

Aber gegenstaende[] ist nun mal bloß ein Gegenstände-Array und folglich kannst du bloß Methoden dieses Typs oder von Sup-Typen aufrufen.
Eine Lösung wäre, die Gegenstände des Arrays in Produkte zu casten (zumindest zu versuchen) und dann getBeschreibung aufzurufen.


----------



## André Uhres (31. Mrz 2010)

ernst hat gesagt.:


> Kann mir jemand mein Beispiel so abändern, dass es sinnvoller wird ?


Versuch mal so was in dieser Art:

```
public class InterfaceDemo {
    public static void main(final String[] args) {
        int i;
        Product[] produkte = new Product[3];
        Item[] gegenstaende = new Item[2];
        produkte[0] = new Radio("RadioVatikan", 120);
        gegenstaende[0] = new Radio("RadioHoliday", 12);
        produkte[1] = new Telefon("Teletron", 321);
        gegenstaende[1] = new Telefon("Urlaubstelefon", 3);
        produkte[2] = new Ballerspiel("BallerinaI", 30);
        System.out.println("Beschreibung der Gegenstaende:");
        for (i = 0; i < 3; i++) {
            System.out.println(produkte[i]);
        }
        for (i = 0; i < 2; i++) {
            System.out.println(gegenstaende[i]);
        }
        System.out.println("\nFarbe der Gegenstaende:");
        for (i = 0; i < 2; i++) {
            System.out.println("Farbe=" + gegenstaende[i].getColor());
        }
    }
}
abstract class AbstractProduct implements Product {
    protected String name;
    public AbstractProduct(final String pName) {
        name = pName;
    }
    public String getName() {
        return (name);
    }
    public void setName(String pName){
        name = pName;
    }
    @Override
    public String toString() {
        return " Beschreibung=" + name;
    }
}
abstract class AbstractItem extends AbstractProduct implements Item {
    int color;
    public AbstractItem(final String pName, final int pColor) {
        super(pName);
        color = pColor;
    }
    public void setColor(final int pColor) {
        color = pColor;
    }
    public int getColor() {
        return color;
    }
    @Override
    public String toString() {
        return super.toString() + " Produktfarbe=" + color;
    }

}
class Telefon extends AbstractItem {
    public Telefon(final String pName, final int pColor) {
        super(pName, pColor);
    }
}
class Radio extends AbstractItem {
    public Radio(final String pName, final int pColor) {
        super(pName, pColor);
    }
}
class Ballerspiel extends AbstractProduct {
    private int dateigroesse;
    Ballerspiel(final String pName, final int pDateigroesse) {
        super(pName);
        dateigroesse = pDateigroesse;
    }
    public double getDateigroesse() {
        return dateigroesse;
    }
    @Override
    public String toString() {
        return super.toString();
    }
}
interface Product {
    public void setName(final String pName);
    public String getName();
}
interface Item {
    public void setColor(final int pColor);
    public int getColor();
}
```


----------



## ernst (1. Apr 2010)

André Uhres hat gesagt.:


> Versuch mal so was in dieser Art:



In meinem Beispiel geht es darum, ein Interface zu motivieren, d.h. ein Argument anzugeben, dass ich um ein Interface _nicht_ herumkomme.
Bei deinem Beispiel kann ich die Interfaces aus dem Programmcode entfernen und folgendes machen:

//abstract class AbstractProduct implements Product {
class AbstractProduct {
...
}

//abstract class AbstractItem extends AbstractProduct implements Item {
class AbstractItem extends AbstractProduct {
...
}

//Product[] produkte = new Product[3];
AbstractProduct[] produkte = new AbstractProduct[3];

//Item[] gegenstaende = new Item[2];
AbstractItem[] gegenstaende = new AbstractItem[2];

Das heißt ich komme ohne diese Interfaces aus.
Ich will aber unbedingt, dass man um ein Interface _nicht_ herumkommt

mfg
Ernst

Übrigens kommt in der Klasse AbstractProduct keine einzige abstract Methode vor.
Warum soll man dann die Klasse abstract machen?


----------



## ernst (1. Apr 2010)

agentone hat gesagt.:


> Die Klasse Produkte beschreibt doch eig. nur ein Produkt, oder?
> -> Umbennen in "Produkt"


Stimmt, das war ein Denkfehler von mir



agentone hat gesagt.:


> Das Interface GegenstandIF besitzt diese hässliche Endung "IF".
> Ich weiß nicht, wo du die her hast, aber lass sie weg!
> (In der Java-API besitzt kein einziges Interface so eine Endung.)


Ich würde mich gerne an eine Regel halten, wie ich Interfaces benennen soll.
Ich weiß nicht mehr, wie ich auf das IF am Ende gekommen bin.
Gibt es eine Regel an, die sich die Java-Community hält?
Wenn nicht, gibt es eine Regel an, die sich die Mehrheit der Java-Community hält?



agentone hat gesagt.:


> Zu den Klassen und Interfaces:
> Ich würde zunächst eine kleine Änderung vorschlagen:
> -interface Produkt
> -abstract class AbstractProdukt implements Produkt
> Sehr interessant ist, dass Produkte keine Gegenstände sind. (Produkt implements Gegenstand)


Ein Produkt muß nicht notwendigerweise ein Gegenstand sein:
Wenn man z.B. ein Programm schreibt, hat man ein Produkt hergestellt.
Dieses Produkt ist aber kein Gegenstand.



agentone hat gesagt.:


> Wenn es so wäre, könntest du genau das machen, was du willst.
> Aber gegenstaende[] ist nun mal bloß ein Gegenstände-Array und folglich kannst du bloß Methoden dieses Typs oder von Sup-Typen aufrufen.
> Eine Lösung wäre, die Gegenstände des Arrays in Produkte zu casten (zumindest zu versuchen) und dann getBeschreibung aufzurufen.


Ich suche mit "Teufelsgewalt" ein _einfaches_ Beispiel, wo ich ohne ein Interface _nicht_ auskomme, also ein Beispiel, das man eben dann _nicht_  so abändern kann, dass man das Interface weglassen kann (bzw. wenn man es wegläßt der Code zwar kompiliert wird und das Programm auch lauffähig ist , aber die Logik nicht mehr stimmen würde).
Die Logik würde z.B. nicht mehr stimmen, wenn ein Ballerspiel eine Methode getFarbe() hätte.

mfg
Ernst


----------



## faetzminator (1. Apr 2010)

Ein einfaches Beispiel mit Interface? Mach eine Methode, welche eine ArrayList und eine LinkedList mit ein paar Strings erstellt. Dann eine Methode, welche eine List entgegennimmt und die Werte ausgibt. Du rufst mit beiden Listen dann diese Methode auf.


----------



## Janus (1. Apr 2010)

```
interface Console
{
  void print( String str );
}

class SwingConsole extends JFrame implements Console
{
  // code
}

class FileConsole extends Writer implements Console
{
  // code
}

void someMethod( Console console )
{
  // do stuff
  console.print( result );
}
```


----------



## Empire Phoenix (1. Apr 2010)

Oder bei Netzwerkcode über Udp der Reliable sein soll, der Server/Client verarbeiten das dann wenn sie das Interface vorfinden entsprechend. Daraus folgt jede Nachchricht bei mir kann mit einem einfachen implements zu einer zuverlässigen inorder Nachchricht aufgewertet werden.


```
package de.empirephoenix.network.messages;

public interface ReliableServerMessage{

	public void setStreamid(short streamid);

	public short getStreamid();
}
```


----------



## ernst (1. Apr 2010)

faetzminator hat gesagt.:


> Ein einfaches Beispiel mit Interface? Mach eine Methode, welche eine ArrayList und eine LinkedList mit ein paar Strings erstellt. Dann eine Methode, welche eine List entgegennimmt und die Werte ausgibt. Du rufst mit beiden Listen dann diese Methode auf.



Eine gutes Beispiel. Leider ist es nicht einfach, da man ArrayList und LinkedList kennen  muss.

mfg
Ernst


----------



## ernst (1. Apr 2010)

Janus hat gesagt.:


> ```
> interface Console
> {
> void print( String str );
> ...



Eine gutes Beispiel. Leider ist es nicht einfach, da man die Java-Klassen Writer und JFrame kennen muss.

mfg
Ernst


----------



## ernst (1. Apr 2010)

Empire Phoenix hat gesagt.:


> Oder bei Netzwerkcode über Udp der Reliable sein soll, der Server/Client verarbeiten das dann wenn sie das Interface vorfinden entsprechend. Daraus folgt jede Nachchricht bei mir kann mit einem einfachen implements zu einer zuverlässigen inorder Nachchricht aufgewertet werden.
> 
> 
> ```
> ...



Das Beispiel ist meiner Meinung nach nicht einfach, da es Einiges an Grundwissen voraussetzt.
(Meine Klassen Produkt, Radio, usw. sind elementarer und setzen weniger Kenntnisse voraus).

mfg
Ernst



mfg
Ernst


----------



## bygones (1. Apr 2010)

lol ... darf jeder mal was machen...

```
interface Liar {
 public String lie(String origin);
}

class Men implements Liar {
  public String lie(String origin) {
    return "I didnt " + origin + " _ went to the bar with friends";
  }
}

class Women implements Liar {
  public String lie(String origin) {
    return "I didnt " + origin + " _ went shoppingwith friends";
  }
}
```

ansonsten versteh ich nicht so recht was du nun erwartest...


----------



## faetzminator (1. Apr 2010)

ernst hat gesagt.:


> Eine gutes Beispiel. Leider ist es nicht einfach, da man ArrayList und LinkedList kennen  muss.



Soll denn jemand am Anfang des Werdegangs nur Arrays kennen? Nach String sollte ~List etwa die erste Klasse sein, welche man kennenlernt...


----------



## André Uhres (1. Apr 2010)

ernst hat gesagt.:


> Ich will aber unbedingt, dass man um ein Interface _nicht_ herumkommt
> kommt


Stell dir einfach eine Klasse XYZ vor mit einer Methode setProduct(Product p) und einer Methode setItem(Item p). XYZ ist jetzt unabhängig von unserer speziellen Umsetzung und könnte genauso gut ein Product entgegennehmen, welches z.B. von einer Klasse DefaultProduct abgeleitet ist, statt von AbstractProduct.


ernst hat gesagt.:


> in der Klasse AbstractProduct keine einzige abstract Methode vor.
> Warum soll man dann die Klasse abstract machen?


Das ist ja nur eine Demo, notgedrungen unvollständig.


----------



## ernst (2. Apr 2010)

André Uhres hat gesagt.:


> Stell dir einfach eine Klasse XYZ vor mit einer Methode setProduct(Product p) und einer Methode setItem(Item p). XYZ ist jetzt unabhängig von unserer speziellen Umsetzung und könnte genauso gut ein Product entgegennehmen, welches z.B. von einer Klasse DefaultProduct abgeleitet ist, statt von AbstractProduct.
> 
> Das ist ja nur eine Demo, notgedrungen unvollständig.



1)
Noch mal zur Bezeichnung eines Interfaces:
Gibt es dazu Regeln (siehe auch Posting von mir in diesem Thread)?

2)
Was hältst du von dem folgenden Vorschlag, oder gäbe er da auch eine Möglichkeit, das Interface zu umgehen?

[Java]
package sinninterface30;

public interface IWartung {
    void wartungsbericht();
    int wartungsbedarf();
}
[/Java]

[Java]
package sinninterface30;
public class MainSinnInterface30 {
	public static void main(String[] args) {
		int i;
        Produkt produkte[];
        IWartung wartungen[];

		produkte = new Produkt[3];
		wartungen = new IWartung[2];

        produkte[0] = new Auto("Renault-1", 12000, 10000);
		produkte[1] = new Kopierer("Kopix", 30000, 20000);
        produkte[2] = new Ballerspiel("BallerinaI", 30);

        wartungen[0] = new Auto("VW-Käfer-1", 13000, 9000);
        wartungen[1] = new Kopierer("MultiStar1", 40000, 10000);

        System.out.println("Beschreibung der Produkte:");
		for(i=0;i<3;i++){
			System.out.println(produkte_.getBeschreibung());
		}

        System.out.println("\nWartungsberichte:");
		for(i=0;i<2;i++){
			wartungen.wartungsbericht();
		}

        System.out.println("\nKomplett-Beschreibung der Produkte:");
		for(i=0;i<3;i++){
			System.out.println(produkte.getBeschreibung());
            try{
                ((IWartung) produkte).wartungsbericht();
            }
            catch(ClassCastException e){
            }
		}
	}

}

abstract class Produkt{
    protected String name;

	public Produkt(String pName){
		name = pName;
    }

	public String getName(){
		return(name);
	}

    abstract public String getBeschreibung();
}

class Auto extends Produkt implements IWartung{
    private int sollKmStand;
    private int kmStand;

    public Auto(String pName, int pKmStand, int pSollKmStand){
        super(pName);
        kmStand = pKmStand;
        sollKmStand = pSollKmStand;
    }

    public String getBeschreibung(){
        String s;
        s="Name="+name+" kmStand="+kmStand+ " sollKmStand="+sollKmStand;
        return s;
    }

    public void setKmStand(int pKmStand){
        kmStand = pKmStand;
    }

    public int getKmStand(){
        return kmStand;
    }

    public void setSoll(int pSollKmStand){
        sollKmStand = pSollKmStand;
    }

    public int getSollKmStand(){
        return sollKmStand;
    }

    public int wartungsbedarf(){
        return (kmStand - sollKmStand);
    }

    public void wartungsbericht(){
        int wert = kmStand - sollKmStand;
        if(wert>0){
            System.out.println("Schnell zur Wartung! "+name+ " hat"+wert+" Km überzogen");
        }
        else{
            System.out.println("Auto" + name + " muß noch nicht zur Wartung");
        }
    }
}

class Kopierer extends Produkt implements IWartung{
    private int sollSeitenAnzahl;
    private int seitenAnzahl;

    public Kopierer (String pName, int pSeitenAnzahl, int pSollSeitenAnzahl){
        super(pName);
        seitenAnzahl = pSeitenAnzahl;
        sollSeitenAnzahl = pSollSeitenAnzahl;
    }

    public String getBeschreibung(){
        String s;
        s="Name="+name+" seitenAnzahl="+seitenAnzahl+ " SollSeitenAnzahl="+sollSeitenAnzahl;
        return s;
    }

    public void setSeitenAnzahl(int pSeitenAnzahl){
        seitenAnzahl = pSeitenAnzahl;
    }

    public int getSeitenAnzahl(){
        return seitenAnzahl;
    }

    public void setSollSeitenAnzahl(int pSollSeitenAnzahl){
        sollSeitenAnzahl = pSollSeitenAnzahl;
    }

    public int getSollSeitenAnzahl(){
        return sollSeitenAnzahl;
    }

    public int wartungsbedarf(){
        return (seitenAnzahl - sollSeitenAnzahl);
    }

    public void wartungsbericht(){
        int wert = seitenAnzahl - sollSeitenAnzahl;
        if(wert>0){
            System.out.println("Schnell zur Wartung! "+ name + " hat "+wert+ " Seiten überzogen");
        }
        else{
            System.out.println("Kopierer"+ name + " muß noch nicht zur Wartung");
        }
    }
}

class Ballerspiel extends Produkt{
	private int dateigroesse;

    Ballerspiel(String pName, int pDateigroesse){
        super(pName);
        dateigroesse = pDateigroesse;
    }

    public String getBeschreibung(){
        String s;
        s="Name="+name+" Dateigroesse="+dateigroesse;
        return s;
    }

    public double getDateigroesse(){
        return dateigroesse;
    }
}




[/Java]_


----------



## ernst (2. Apr 2010)

André Uhres hat gesagt.:


> Stell dir einfach eine Klasse XYZ vor mit einer Methode setProduct(Product p) und einer Methode setItem(Item p). XYZ ist jetzt unabhängig von unserer speziellen Umsetzung


von welcher speziellen Umsetzung?


> und könnte genauso gut ein Product entgegennehmen, welches z.B. von einer Klasse DefaultProduct abgeleitet ist, statt von AbstractProduct.


Welche KLasse DefaultProduct ?

Ich verstehe nicht, was du meinst.

mfg
Ernst


----------



## André Uhres (2. Apr 2010)

ernst hat gesagt.:


> von welcher speziellen Umsetzung?
> Welche KLasse DefaultProduct ?


Mit Umsetzung meine ich die Klassen, die die Schnittstellen umsetzen (implementieren).
Wenn AbstractProduct abstrakte Methoden enthält, dann wäre DefaultProduct z.B. eine Ableitung davon mit konkreten Umsetzungen (Implementationen) der abstrakten Methoden. Desweiteren kann man sich ein Klasse MyProduct vorstellen, die einfach die Schnittstelle Product implementiert (umsetzt), ohne von einer anderen besonderen Klasse abgeleitet zu sein. Objekte von irgendeiner dieser Umsetzungen (Implementationen) können an die Methode setProduct(Product p) übergeben werden.


----------



## ernst (3. Apr 2010)

faetzminator hat gesagt.:


> Ganz unabhängig von deiner Fragestellung solltest du folgende Punkte beachten:
> - Interfaces sieht man oft mit "I<Name>" oder "<Beschreibung>", "<Name>IF" finde ich eine schlechte Wahl. "Farbig" währ da die bessere Wahl, siehe aber nächsten Punkt.



Wie soll ich Interfaces bezeichnen?
Mit I sollen sie auch nicht beginnen:
--------------------------------
http://openbook.galileocomputing.de/javainsel8/javainsel_06_013.htm:
Hinweis Der Name einer Schnittstelle endet oft auf -ble (Accessible, Adjustable, Runnable). Er beginnt üblicherweise nicht mit einem Präfix wie »I«, obwohl die Eclipse-Entwickler diese Namenskonvention nutzen.
--------------------------------

mfg
Ernst


----------



## Wildcard (3. Apr 2010)

Das I ist Geschmacksache, ich verwende es üblicherweise (na gut, ich bin auch Eclipse Entwickler... ).
...able ist üblich, passt aber auch nicht in jedem Fall. Es gibt keine harten Konventionen, allerdings sollte man mit dem Strom schwimmen (also kein ...IF) damit man andere Entwickler nicht verwirrt.


----------



## daWonderer (3. Apr 2010)

ernst hat gesagt.:


> [Java]
> System.out.println("\nKomplett-Beschreibung der Produkte:");
> for(i=0;i<3;i++){
> System.out.println(produkte_.getBeschreibung());
> ...


_

Du könntest statt dem Abfangen der Exception vorher abfragen, ob eine bestimmte Instanz vorliegt mit *instanceof*
Wenn es ein Auto oder ein Kopierer ist, dann Casten..._


----------



## André Uhres (3. Apr 2010)

Ich würde den Schnittstellen reine Namen geben. Zusätze auf dieser Ebene verschleiern imho nur den Begriff. Bei den Umsetzungen dagegen könnten Zusätze schon eher Sinn machen.


----------

