Probleme mit Vererbung

Hallo ich habe folgendes Problem das ich eine TennisSocke habe die in eine Waschmaschine kommt diese erbt von Socke
aber die TennisSocke soll beim 2 Wasch Durchgang kaputt gehen und das soll überprüft werden mit der Methode beladen()
und dann die Socke nicht mehr Einlanden. Ich weiß einfach nicht wie ich anfangen soll bitte um Hilfe

Code:
package com.company;

public class Main {

    public static void main(String[] args) {
        Waschmaschine w = new Waschmaschine(); Socke[] socken = new Socke[3];
        socken[0] = new Socke();
        socken[1] = new Socke("blau");
        socken[2] = new Socke("gestreift");
        System.out.println(w);
        w.belade(socken);
        System.out.println(w); System.out.println("-------------------------");
        w.wasche(); System.out.println("-------------------------");
        socken[0] = new Socke("schwarz"); w.belade(socken); w.wasche(true);
    }
}


package com.company;

public class Socke {
    Boolean trocken;
    String farbe;

    public Socke(){
        this.farbe="Weiß";
    }
    public Socke(String farbe){
        this.farbe=farbe;
    }
    public void waschen(){
        this.trocken=false;
    }
    public void trockne(){
        this.trocken=true;
    }
    public Boolean istTrocken(){
        return this.trocken;
    }
    public String getFarbe() {
        return farbe;
    }
    @Override
    public String toString(){
        return String.format("Socke, Farbe %s, trocken %s", this.farbe, this.trocken);
    }
    public static void  main(String[] args){
        Socke s=new Socke();
        s.waschen();
        s.trockne();
        s.waschen();
        s.trockne();
    }
}
package com.company;

public class Waschmaschine {
    Socke[] socken = new Socke[0];

    public void belade(Socke[] s) {
        this.socken = s;
    }

    private boolean beladungKorrekt() {
        int dunkel = 0, hell = 0, weiss = 0;

        for (Socke s : this.socken) {
            switch (s.getFarbe()) {
                case "gelb":
                case "grau":
                case "" +
                        "rosa":
                    hell++;
                    break;
                case "blau":
                case "grün":
                case "gestreift":
                case "schwarz":
                    dunkel++;
                    break;
                case "weiss":
                    weiss++;
                default:
                    dunkel++;
            }
        }
        if (hell > 0) {
            return (dunkel + weiss) == 0 ? true : false;
        }
        if (dunkel > 0) {
            return (hell + weiss) == 0 ? true : false;
        }
        if (weiss > 0) {
            return (hell + weiss) == 0 ? true : false;
        }
        return false;
    }
    public void wasche(boolean sound){

        this.wasche();
        this.wasche(); }
    public void wasche() {
        if (!beladungKorrekt()) {
            System.out.println("Gemischte Farben, ALARM");
            return; }
        for (Socke s: this.socken) { System.out.println(s.toString()); s.waschen(); System.out.println(s.toString()); s.trockne(); System.out.println(s.toString());
        } }
    @Override
    public String toString() {
        return String.format("Waschmaschine belanden mit %d Socken", this.socken.length);
    }
}
 
Also als erstes verstehe ich deine Aussage nicht. Was meinst Du mit "und dann die Socke nicht mehr Einlanden. "?

Wenn Du bei Socken generell unterscheiden können willst, ob diese heile sind, dann musst Du das in den Socken implementieren.
Dann kann ein Tennissocken einen Waschzähler haben diesen neuen Status verändern nach dem xten Waschen.

Die Waschmaschine kann dann nach dem Waschen die Socken prüfen und mit defekten Socken irgendwas machen.

So in der Art oder was genau meinst du?
 
TennisSocke ist noch nicht implementiert weil ich einfach keinen Ansatz finde beziehungsweise es so gemacht hätte aber hier fehlt die Abfrage wann die TennisSocke kaputt ist

Code:
package com.company;

public class TennisSocke extends Socke {
    Boolean broken;

    public TennisSocke(){
        this.farbe="Weiß";
    }
    public TennisSocke(String farbe){
        this.farbe=farbe;
    }
    public void waschen(){
        this.trocken=false;
    }
    public void trockne(){
        this.trocken=true;
    }
    public Boolean istTrocken(){
        return this.trocken;
    }
    public String getFarbe() {
        return farbe;
    }
    @Override
    public String toString(){
        return String.format("TennisSocke, Farbe %s, trocken %s", this.farbe, this.trocken);
    }
    public static void  main(String[] args){
        TennisSocke ts=new TennisSocke();
        ts.waschen();
        ts.trockne();
        ts.waschen();
       ts.trockne();
    }
}
 
Das Problem bei dem Ansatz ist, dass nur TennisSocken nun kaputt sein können. Damit müsste die Waschmaschine aber auch TennisSocken als solche kennen.... Aber wir wollen ja eine universelle Lösung haben mit so wenig Abhängigkeiten wie möglich.

Daher war eine erste Idee, dass man Socke so erweitert, dass diese defekt sein können.
==> Das wäre ein ganz trivialer Aufbau, bei dem man einfach das, was man benötigt, an diversen Klassen einfügt.

Aber man kann das auch alles als Interfaces behandeln. Dann kann man z.B. mehrere Interfaces definieren:
a) waschbar -> waschen() Methode, ggf. auch noch getFarbe().
b) zerstörbar -> istKaputt() Methode.

Dann ist nicht klar, ob die Wäsche, die man wäscht, zerstörbar ist oder nicht. Aber Waschmaschine (oder wer auch immer) kann dann prüfen, ob eine vorhandene Socke eben zerstörbar implementiert um dann ggf. istKaputt aufzurufen um das zu prüfen.
==> Das ist dann etwas flexibler. Denn eine Waschmaschine kann ja deutlich mehr Waschen. Die alten IBM Tastaturen hatten auf den eigentlichen Tasten Kappen mit Beschriftung. Die konnte man abziehen und die konnte man dann in einem Wäschebeutel in der Waschmaschine waschen .... aber es waren natürlich keine Socken. Die Waschmaschine kann ja prinzipiell alles waschen, was waschbar ist .... (So man dies so sehen will)

Dann kann man dies noch komplexer gestalten. Es kann ja mehrere Wäschestücke geben mit unterschiedlichem Waschverhalten. Daher könnte es Sinn machen, dass man das Verhalten ausgliedert in ein Interface Waschverhalten mit Methode waschen. Dann können unterschiedliche Wäschestücke gleiches Waschverhalten haben ohne dass man Code doppelt hat. Sprich: Socke hat ein Waschverhalten und waschen ruft einfach waschverhalten.waschen auf. (=> Strategy Pattern)

Aber ich fürchte, dass wir damit dann jetzt komplett über das Ziel heraus geschossen sind. So die Aufgabe nicht noch komplexer wird, reicht aus meiner Sicht eine Erweiterung von Socke + Implementation von TennisSocke.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben