Ja, mein Werklehrer hat sich seinerzeit eines meiner Werkstücke aufgehoben - als abschreckendes Beispiel für die nachfolgenden Generationen. Damit war meine Karriere als Schreiner auch schon beendet.A fool with a tool is still a fool
im game dev hast du meistens die situation dass singleton massenhaft verwendet wird von neuen programmierern
ist doch klar mister "Betriebssystem ist von der shell abhängig"
A fool with a tool is still a fool
Rate mal, wen du gerade ertappt hast
uhhmmm keine ahnung
public class WorkerInformationService {
public static void main(String[] args) {
//--------------------
//this object normally would NOT be in here:
WorkerDataManagement wdm = new WorkerDataManagement();
wdm.setHoursWorked(135.5);
wdm.setLeaveDaysTotal(30.0);
wdm.setLeaveDaysTaken(19.5);
wdm.getAmountHoursWorked(); //testing
wdm.getAmountLeaveDaysLeft(); //testing
//--------------------
WorkerInterface workerProxy = new WorkerDataManagementProxy(wdm);
//information allowed to be accessed:
workerProxy.getAmountHoursWorked();
workerProxy.getAmountLeaveDaysLeft();
}
}
public interface WorkerInterface {
double getAmountLeaveDaysLeft();
double getAmountHoursWorked();
}
public class WorkerDataManagement implements WorkerInterface {
//some "random" instance variables chosen as examples for a class like this:
double leaveDaysTotal;
double leaveDaysTaken;
double leaveDaysLeft;
double hoursWorked;
double sickDays;
double salaryPerHour;
public void setLeaveDaysTotal (double newLeaveDaysTotal) { this.leaveDaysTotal = newLeaveDaysTotal; }
public double getLeaveDaysTotal() { return leaveDaysTotal; }
public void setLeaveDaysTaken (double newLeaveDaysTaken) { this.leaveDaysTaken = newLeaveDaysTaken; }
public double getLeaveDaysTaken() { return leaveDaysTaken; }
public void setHoursWorked (double newHoursWorked) { this.hoursWorked += newHoursWorked; }
@Override
public double getAmountLeaveDaysLeft() {
leaveDaysLeft = leaveDaysTotal - leaveDaysTaken;
System.out.println("From " + leaveDaysTotal + " days off already " + leaveDaysTaken + " days were taken. \n Days off left: " + leaveDaysLeft);
return leaveDaysLeft;
}
@Override
public double getAmountHoursWorked() {
return hoursWorked;
}
}
public class WorkerDataManagementProxy implements WorkerInterface{
public WorkerDataManagementProxy(WorkerDataManagement wdm) {
}
@Override
public double getAmountLeaveDaysLeft() {
WorkerDataManagement wdm = new WorkerDataManagement();
return wdm.getAmountLeaveDaysLeft();
}
@Override
public double getAmountHoursWorked() {
WorkerDataManagement wdm = new WorkerDataManagement();
return wdm.getAmountHoursWorked();
}
}public class WorkerDataManagementProxy implements WorkerInterface {
WorkerDataManagement wdm = new WorkerDataManagement();
public WorkerDataManagementProxy(WorkerDataManagement wdm) {
this.wdm = wdm;
}
@Override
public double getAmountLeaveDaysLeft() {
return wdm.getAmountLeaveDaysLeft();
}
@Override
public double getAmountHoursWorked() {
return wdm.getAmountHoursWorked();
}
}Die Frage ist die, die @thecain schon gestellt hat, nämlich wozu der Proxy dienen soll.
if (mayAccessLeaveDays) {
return wdm.getAmountLeaveDaysLeft();
}
throw new IllegalAccessException("...");Was Du hier beschreibst ist ein ganz bestimmter Typ eines Proxys. Im Allgemeinen ist ein Proxy einfach ein Objekt, das stellvertretend (aus welchem Grund auch immer) für ein anderes Objekt steht.
interface Firma {
Long getId();
void setId(Long id);
String getName();
void setName(String name);
}public class FirmaImpl implements Firma { ... }class FirmaProxy implements Firma {
private Firma firma;
private boolean geladen;
private Long id;
public FirmaProxy(Long id) { this.id = id; }
public Long getId() {
return geladeneFirma().getId();
}
public void setId(Long id) {
geladeneFirma().setId(id);
}
public String getName() {
return geladeneFirma().getName();
}
public void setName(String name) {
geladeneFirma().setName(name);
}
private Firma geladeneFirma() {
if (!geladen) {
// lade Firma aus DB
geladen = true;
}
return firma;
}
}FirmaProxy fp = new FirmaProy();
Firma f = fp.geladeneFirma();
f.getID();Das gefällt mir
Nein, die Nutzer (Clients) wissen gar nicht, dass sie ein Proxy-Objekt erhalten. Dieses implementiert ja die Schnittstelle Firma und kann daher auch in dieser Weise verwendet werden.
private Firma firma;
public void setFirma(Firma firma) { this.firma = firma; }
public Firma getFirma() { return firma; }public Person ladePerson(long id) {
Person person = new Person(id);
person.setName(...); // aus DB
long firmenId = // aus DB
person.setFirma(new FirmaProxy(firmenId));
return person;
}public class WorkerOutfittery {
public static void main(String[] args) {
WorkerOutfit worker_1_outfit = new Clothes();
worker_1_outfit = new Boots(worker_1_outfit); //hier ist es ein "clothes"
worker_1_outfit = new Dungarees(worker_1_outfit); //hier ist es ein "clothes"
worker_1_outfit = new Overall (worker_1_outfit); //hier ist es ein "clothes"
worker_1_outfit = new Driller (worker_1_outfit); //das wäre ein "tools"
System.out.println(worker_1_outfit.getOutfitItem() + "total pledge is about " + worker_1_outfit.getPledge());
//und hier nochmal im Prinzip das gleiche
WorkerOutfit worker_2_outfit = new Hammer (new Driller (new Tools() ) );
System.out.println(worker_2_outfit.getOutfitItem() + "total pledge is about " + worker_2_outfit.getPledge());
worker_2_outfit = new Boots (new Dungarees ( new Overall (new Clothes()) ) );
System.out.println(worker_2_outfit.getOutfitItem() + "total pledge is about " + worker_2_outfit.getPledge());
}
/* Konsolenausgabe:
clothes: security Boots, Dungarees, Overall, Driller, total pledge is about 131.0
tools: Driller, Hammer, total pledge is about 65.0
clothes: Overall, Dungarees, security Boots, total pledge is about 81.0
*/
}Das freut mich zu hören.
Naja, das kommt auf deine Implementierung drauf an. Mehrfachvererbung geht in Java nicht (aus gutem Grund), eine Klasse kann aber viele Interfaces implementieren.
Mal in Bezug auf das Beispiel: Ein Arbeitnehmer wird von seinem Arbeitgeber ausgerüstet - kein Plan, Arbeitnehmerleasing oder was auch immer.
Das Kaffee-Bsp. habe ich auch aus dem Buch Entwurfsmuster 😶 -🦶 Ich denke, ich habe das decorator Pattern verstanden. Mir ging es bei meiner Rückfrage darum, ob ich theoretisch mehr als eine konkrete Komponente mit einem decorator dekorieren kann - Lösung scheint ja das Interface zu sein.das kaffee beispiel in java erklärt es ganz gut was das decorator pattern machtDecorator pattern - Wikipedia
en.wikipedia.org
Ob und wann das sinnvoll ist, steht ja auf einem anderen Blatt. Ich denke mal, ich hätte bei mir die Outfits auch einfach nicht in Tools und Clothes unterscheiden müssen und schon wäre die Frage gar nicht aufgekommen.
Vererbung wird überbewertet
Ja. Interfaces gingen mir etwas auf den Sack, den für sowas muß man jede Menge redudanten Code schreiben. Die Klassen machen ja alle dasselbe.
Es ist tatsächlich so, dass das Erlernen von Design Patterns wie den GoF-Patterns eine Herausforderung sein kann. Es ist wichtig, sich bewusst Zeit zu nehmen, um sie zu verstehen und zu lernen, wie man sie in der Praxis anwendet. Im Berufsalltag werden diese Patterns nicht immer bewusst verwendet. Oft werden sie unbewusst angewendet, ohne dass man sich bewusst darüber Gedanken macht. Es ist jedoch wichtig, sie zu kennen und zu verstehen, da sie bei der Lösung von bestimmten Problemen hilfreich sein können. Es lohnt sich daher, sich die Zeit zu nehmen, um sie zu lernen und in der Praxis anzuwenden.
Dazu siehe https://www.baeldung.com/design-patterns-series -> https://www.baeldung.com/java-strategy-pattern (auch hier gilt es Änderungen oder Erweiterungen aller Art leichter implementieren zu können)
Ich bin mir nicht sicher, ob ich dich richtig verstehe.
Die Andrea stammte auch von der CSU, die bekanntermaßen mit Bavaria One auch ein bayerisches Weltraumprogramm verfolgt. Da wird sich die Welt aber anschauen, wenn die erste Rakete in Weißwurstform den Planeten verlässt. SCNR.
Kommt darauf an, was dein Ziel ist. Wenn deine Klasse sich verhalten können soll wie das Interface es festlegt, dann muss sie es implementieren. Soll die Klasse nur eine Instanz davon speichern können, dann kann sie dieses als Instanzvariable haben und da kann es sinnvoll sein als Typ das Interface anzugeben, um flexibler zu sein.
ich verstehe nicht, wie du das meinst. Die Klasse (interface) habe ich doch ohnehin schon, wenn ich daraus ein Objekt für eine Instanzvariable mache.
Jo danke für den Link. Lambdas waren für mich an der Stelle noch kein Ding. Ich bin ja gerade eher bei den grundsätzlichen Ideen der Patterns.
Ich bin mir nicht sicher, ob ich DICH jetzt richtig verstehe
public class WorkSheet {
public static void main(String[] args) {
Worker programmer = new Programmer();
programmer.setName("The Nerd");
System.out.println("We need someone to write a code!");
System.out.println("");
// ------------------------
System.out.println(programmer.getName() + " answers: " + programmer.getSkilledOrNot());
System.out.println(programmer.getName() + " got struck by lightning and lost his memory.");
programmer.setSkilledOrNot(new NoCodingSkills());
System.out.println(programmer.getName() + " says " + programmer.getSkilledOrNot());public interface SkilledOrNotInterface {
String skillSetup();
}
//hier ist das Interface implementiert
public class CodingSkills implements SkilledOrNotInterface {
@Override
public String skillSetup() {
return "I can code!";
}
}
//hier ist das Interface ebenfalls implementiert
public class NoCodingSkills implements SkilledOrNotInterface {
@Override
public String skillSetup() {
return "I can definitley not code!";
}
}
//hier ist das Interface nicht implementiert, sondern es taucht als Instanzvariable auf
public class Worker {
private String profession;
private String name;
private String tools;
public void setProfession(String prof) { this.profession = prof; }
public String getProfession() { return profession; }
public void setName(String name) { this.name = name; }
public String getName() { return name; }
public void setTools(String tools) { this.tools = tools; }
public String getTools () { return tools; }
//--------------------
//use interface as instance variable
SkilledOrNotInterface skilledOrNot;
public String getSkilledOrNot() {
return skilledOrNot.skillSetup();
}
//let strategy pattern be dynamic:
public void setSkilledOrNot(SkilledOrNotInterface skilledOrNot) {
this.skilledOrNot = skilledOrNot;
}
}
public class Programmer extends Worker {
public Programmer() {
super();
setProfession("Programmer");
setTools("Computer");
skilledOrNot = new CodingSkills();
}
}Ok, damit nähere ich mich glaube ich dem "Problem" in meinem Kopf: Warum oder in welchen Fällen sollte ich nur eine Instanz des Interfaces brauchen anstatt jenes zu implementieren? Ich mein.. ich habe Interfaces doch aus dem Grund, damit ich sie implementieren kann und die Methoden dann in verschiedenen Klassen unterschiedlich überschreiben und nutzbar machen kann. Was bringt es mir, sie wie in meinem obigen Code beschrieben als Instanzvariable zu haben?
Antwort von chatGPT:
Falsch. Man kann trotzdem die Patterns an verschiedenen Stellen selber verwenden.
klar, warum sollte ich sprachen integrierte features hernehmen wenn es auch auf einem längeren weg geht
Ähm, kannst Du das bitte einmal näher erläutern?
(ich denke,hilft MIR das inzwischen nicht mehr groß weiter)
?
"Instanz des Interfaces" war schlecht von mir formuliert, da sich ein Interface nicht instantiieren lässt. Besser ist: "Instanz einer Klasse, die das Interface implementiert". Dies zur Richtigstellung.
public void doSomething(ArrayList<MyType> list) {
}
//vs.
public void doSomething(Collection<MyType> list) {
}Das lässt sich noch "verbessern" mit:
public void doSomething(Iterable<MyType> list) {
}Im letzten Fall kannst du dann natürlich nur noch mit den Methoden von Iterable<> zugreifen.
class Foo {
// die Instanzvariable wird als List<> deklariert (Interface)
// dadurch kann die tatsächliche Implementation später noch leicht
// gewechselt werden, auf jeden Typen der List<> implementiert.
private List<MyType> list = new ArrayList<>();
public void doSomething(Iterable<MyType> list) {
for (var item : list) {
this.list.add(item);
}
}
}direkt dazu: Habe ich das aber nicht getan; eine Instanz des Interfaces erzeugt und jenes somit zur Instanzvariable gemacht?
