Matroids Matheplanet Forum Index
Moderiert von matph
Informatik » Programmieren » Java: Morsealphabet und Zugriff auf Klassen
Druckversion
Druckversion
Autor
Universität/Hochschule J Java: Morsealphabet und Zugriff auf Klassen
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2021-05-02


Hallo,

ich checke es einfach nicht. Schon beim Lesen der Theorie habe ich das mit dem private/public/static/non-static nicht wirklich kapiert. Ich verstehe zwar die Sätze, die ich lese, aber nicht die Zusammenhänge und Unterschiede.

Und bei der folgenden Aufgabe scheitert es daran.

Ich habe sicher noch weitere Fehler drin, aber das Zugriff / Klassenproblem ist erst mal das Hauptproblem, weil so auch nichts kompiliert.

Die Aufgabenstellung:




Ich habe versucht alle Vorgaben (insb. welche Modifikatoren erlaubt sind) umzusetzen, aber checke einfach nicht, wo das Problem / die Probleme sind.
Java
  1. package KE2.EA2;
  2. import java.util.NoSuchElementException;
  3. import java.util.Scanner;
  4.  
  5. class Morse {
  6. private LinkedList<String> morsealphabet = new LinkedList<String>();
  7.  
  8. public static void main(String argv[]) {
  9. morsealphabet.addLast(".-");
  10. morsealphabet.addLast("-...");
  11. morsealphabet.addLast("-.-.");
  12. morsealphabet.addLast("-..");
  13. morsealphabet.addLast(".");
  14. morsealphabet.addLast("..-.");
  15. morsealphabet.addLast("--.");
  16. morsealphabet.addLast("....");
  17. morsealphabet.addLast("..");
  18. morsealphabet.addLast(".---");
  19. morsealphabet.addLast("-.-");
  20. morsealphabet.addLast(".-..");
  21. morsealphabet.addLast("--");
  22. morsealphabet.addLast("-.");
  23. morsealphabet.addLast("---");
  24. morsealphabet.addLast(".--.");
  25. morsealphabet.addLast("--.-");
  26. morsealphabet.addLast(".-.");
  27. morsealphabet.addLast("...");
  28. morsealphabet.addLast("-");
  29. morsealphabet.addLast("..-");
  30. morsealphabet.addLast("...-");
  31. morsealphabet.addLast(".--");
  32. morsealphabet.addLast("-..-");
  33. morsealphabet.addLast("-.--");
  34. morsealphabet.addLast("--..");
  35.  
  36. System.out.println("Geben Sie ein Wort ein: ");
  37. Scanner scanner = new Scanner(System.in);
  38. String input = scanner.nextLine();
  39. System.out.println("Gelesenes Wort lautet : \n" + input);
  40. char[] buchstaben = input.toCharArray();
  41. System.out.println(buchstaben);
  42. for (char b : buchstaben) {
  43. String ergebnis = code(b);
  44. System.out.println(ergebnis);
  45. }
  46. }
  47.  
  48. public String code(char b) {
  49. int number = Character.getNumericValue(b);
  50. System.out.println("number of " + b + " is " + number);
  51.  
  52. int laufzahl = number - 65;
  53. String str = "";
  54. LinkedList<String>.ListIterator it = morsealphabet.listIterator();
  55. try {
  56. for (int i = 1; i == laufzahl; i++) {
  57. str = it.next();
  58. }
  59. return str;
  60. } catch (NoSuchElementException e) {
  61. return "Fehler!";
  62. }
  63. }
  64. }
  65. // ------------------------------------------------------------------
  66. // GEGEBEN im Skript
  67. class LinkedList<ET> {
  68. static class Entry<T> {
  69. T element;
  70. Entry<T> next;
  71. Entry<T> previous;
  72.  
  73. Entry(T element, Entry<T> next, Entry<T> previous) {
  74. this.element = element;
  75. this.next = next;
  76. this.previous = previous;
  77. }
  78. }
  79.  
  80. Entry<ET> header = new Entry<ET>(null, null, null);
  81. int size = 0;
  82.  
  83. // Constructs an empty Linked List.
  84. header.next = header;
  85. header.previous = header;
  86. }
  87.  
  88. // Returns the last Element in this List.
  89. ET getLast() {
  90. if (size == 0) throw new NoSuchElementException();
  91. return header.previous.element;
  92. }
  93.  
  94. // Removes and returns the last Element from this List.
  95. ET removeLast() {
  96. Entry<ET> lastentry = header.previous;
  97. if (lastentry == header) throw new NoSuchElementException();
  98. lastentry.previous.next = lastentry.next;
  99. lastentry.next.previous = lastentry.previous;
  100. size--;
  101. return lastentry.element;
  102. }
  103.  
  104. // Appends the given element to the end of this List.
  105. void addLast(ET e) {
  106. Entry<ET> newEntry = new Entry<ET>(e, header, header.previous);
  107. header.previous.next = newEntry;
  108. header.previous = newEntry;
  109. size++;
  110.  
  111. }// Returns the number of elements in this List.
  112.  
  113. int size() {
  114. return size;
  115. }
  116.  
  117. class ListIterator {
  118. private int nextIndex = 0;
  119. private Entry<ET> next = header.next;
  120.  
  121. boolean hasNext() {
  122. return nextIndex != size;
  123. }
  124.  
  125. ET next() {
  126. if (nextIndex == size)
  127. throw new NoSuchElementException();
  128. ET elem = next.element;
  129. next = next.next;
  130. nextIndex++;
  131. return elem;
  132. }
  133. }
  134.  
  135. ListIterator listIterator() {
  136. return new ListIterator();
  137. }
  138. }
  139. //-----------------------------------------------------------------------

Das Hauptproblem, wo ich Hilfe brauche, betrifft die in meinem Editor rot markierten Stellen:
 
   morsealphabet.addLast(".-");
   morsealphabet.addLast("-...");
   morsealphabet.addLast("-.-.");
   (...)

Hier habe ich auch zig andere Sachen ausprobiert, z.B.
morsealphabet.LinkedList<String>.addLast(".-");
morsealphabet.LinkedList<ET>.addLast(".-");
morsealphabet.LinkedList.addLast(".-");
Morse.morsealphabet.LinkedList<String>.addLast(".-");

Außerdem habe ich auch die LinkedList Klasse mal in die Morse reingezogen, war aber auch falsch. Oder die private morsealphabet Deklaration in die main Methode, das wollte er auch nicht (privat darf nicht in static stehen oder so...)
Ebenfalls nicht funkioniert hat es, die addLast Aufrufe in der Morse Klasse selbst zu machen.

Kann mir bitte jemand erklären, wo in meinem Code das Problem ist? Ich sehe nicht, wie ich bei den Vorgaben, die die Aufgabe macht, das hätte machen müssen und weigere mich in die Musterlösung zu sehen, ehe ich es nicht selbst hinbekomme.









Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
zippy
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 24.10.2018
Mitteilungen: 2276
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, eingetragen 2021-05-02


Du kannst in einer statischen Methode keine nicht-statischen Member der Klasse verwenden.

--zippy



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.2, vom Themenstarter, eingetragen 2021-05-02


Ja,
java: non-static variable morsealphabet cannot be referenced from a static context

das sagt mir der Compiler auch. Aber das hilft mir leider nicht weiter.

Ich hatte schon versucht, z.B. morsealphabet.addLast(".-"); aus der main rauszuziehen und nur in die Morse-Klasse zu legen, das geht auch nicht. Dann sagt er, "cannot resolve Symbol 'addLast'"





Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
zippy
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 24.10.2018
Mitteilungen: 2276
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.3, eingetragen 2021-05-02


2021-05-02 20:11 - curious_mind in Beitrag No. 2 schreibt:
das sagt mir der Compiler auch. Aber das hilft mir leider nicht weiter.

Warum hilft dir das nicht weiter? Verstehst du, was der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen ist?

Du hast hier zwei Möglichkeiten:

1. Du machst alles in der Klasse Morse statisch, weil diese Klasse ohnehin nur eine Sammlung von Methoden ist und keinen Zustand hat. So etwas versucht man aber im Regelfall zu vermeiden und außerdem widerspricht es dem ersten Hinweis der Aufgabenstellung.

2. Du initialisierst morsealphabet in einem nicht-statischen Kontext wie etwa in einem Konstruktur oder einem Initializer und erzeugst dir in deiner main-Methode eine Instanz von Morse, mit der du dann arbeitest.

Das könnte dann so aussehen:
java
  private Morse() {
      morsealphabet.addLast(".-");   
      morsealphabet.addLast("-..."); 
      //...
      morsealphabet.addLast("-.--");
      morsealphabet.addLast("--..");
  }
 
  public static void main(String argv[]) {
      Morse morse = new Morse();
      System.out.println("Geben Sie ein Wort ein: ");
      Scanner scanner = new Scanner(System.in);
      String input = scanner.nextLine();
      System.out.println("Gelesenes Wort lautet : \n" + input);
      char[] buchstaben = input.toCharArray();
      System.out.println(buchstaben);
      for (char b : buchstaben) {
          String ergebnis = morse.code(b);
          System.out.println(ergebnis);
      }
  }

Übrigens ist es – um es vorsichtig auszudrücken – unüblich, zwei Klassen wie Morse und LinkedList in eine gemeinsame Datei zu packen.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 2867
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.4, eingetragen 2021-05-03


Salopp:

Normale (non-static) Klassenmethoden gehören einer Instanz dieser Klasse, also einem bestimmten Objekt.

Das verwendet man immer dann, wenn der konkrete Zustand einer Instanz eine Rolle spielt.

Beispiel:
Java
class Dog {
 
    private final String name;
 
    public Dog(String name) {
        this.name = name;
    }
 
    public void barks() {
        System.out.println(String.format("Wooff! I'm %s!", this.name));
    }
 
    public static void main(String[] args) {
        var myDog = new Dog("Lumpy");
        myDog.barks();
        var neighborsDog = new Dog("Scruffles");
        neighborsDog.barks();
    }
 
}

Die Methode barks() hängt vom konkreten Zustand des Objektes ab.



Statische Methoden gehören zu keiner bestimmten Instanz.
Sie sind (wie der Name besagen soll) eben statisch und vom aktuellen Zustand des Objektes unabhängig.
Der Klassiker ist die Methode "main", die als Einstiegspunkt des Programmes keine Objektinstanz benötigen darf (Zum Zeitpunkt ihres Aufrufs existiert ja noch gar kein Objekt, dessen aktuellen Zustand sie nutzen könnte).



Die Attribute "private", "" (ohne explizite Modifizierung), "protected" und "public" geben die Sichtbarkeit von Methoden und Variablen an.


ModifierClassPackageSubclassWorld
publicYYYY
protectedYYYN
no modifierYYNN
privateYNNN



-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.5, vom Themenstarter, eingetragen 2021-05-03

Java
  private Morse() {
      morsealphabet.addLast(".-");   
      morsealphabet.addLast("-..."); 
      //...
      morsealphabet.addLast("-.--");
      morsealphabet.addLast("--..");
  }
 
  public static void main(String argv[]) {
      Morse morse = new Morse();
      System.out.println("Geben Sie ein Wort ein: ");
      Scanner scanner = new Scanner(System.in);
      String input = scanner.nextLine();
      System.out.println("Gelesenes Wort lautet : \n" + input);
      char[] buchstaben = input.toCharArray();
      System.out.println(buchstaben);
      for (char b : buchstaben) {
          String ergebnis = morse.code(b);
          System.out.println(ergebnis);
      }
  }
 
Auch das geht nicht... Dann findet er morsealphabet nicht.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.6, vom Themenstarter, eingetragen 2021-05-03


Hab's jetzt so gemacht:
Java
class Morse {
        private LinkedList<String> morsealphabet = new LinkedList<String>();
        Morse(){
            morsealphabet.addLast(".-");
            morsealphabet.addLast("-...");
            morsealphabet.addLast("-.-.");
            morsealphabet.addLast("-..");
 

Aber wieso ich das so machen muss, leuchtet mir nicht wirklich ein. Ein Morsealphabet ändert sich ja nicht, das macht aus meiner Sicht null Sinn, es als Objekt zu bauen. Und ich kapiere auch nicht, wieso es privat sein muss.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.7, vom Themenstarter, eingetragen 2021-05-03


Jetzt habe ich hier wieder so ein Problem bei dem Aufruf der code-Methode:
Java
public static void main(String argv[]) {
            Morse alphabet = new Morse();
            System.out.println("Geben Sie ein Wort ein: ");
            Scanner scanner = new Scanner(System.in);
            String input = scanner.nextLine();
            System.out.println("Gelesenes Wort lautet : \n" + input);
            char[] buchstaben = input.toCharArray();
            System.out.println(buchstaben);
            String ergebnis = "";
            for (char b : buchstaben) {
                ergebnis = code(b);
                System.out.println(ergebnis);
            }
        }

"java: non-static method code(char) cannot be referenced from a static context"

Muss ich jetzt noch ein neues Objekt erfinden, um darauf code anwenden zu können!?



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2076
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.8, eingetragen 2021-05-03


Du hast doch ein Objekt. Verwende alphabet.code(b) statt code(b).



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.9, vom Themenstarter, eingetragen 2021-05-03


Ich soll aber das eingelesene Wort übersetzen in Morsecode und nicht das Morsealphabet übersetzen.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 2867
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.10, eingetragen 2021-05-03


Hier mal in ganz kurz:
Java
import java.util.Arrays;
import java.util.LinkedList;
 
public class Morse {
 
    private LinkedList<String> morsealphabet;
 
    public Morse() {
        morsealphabet = new LinkedList<>();
        String[] abc = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
                "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.." };
        morsealphabet.addAll(Arrays.asList(abc));
    }
 
    public String code(char c) {
        int nv = c - 65;
        return (nv < 0 || nv >= morsealphabet.size()) ? "Fehler!" : morsealphabet.get(nv);
    }
 
    public static void main(String[] args) {
        var abc = "zABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        var morse = new Morse(); // Erzeuge Instanz eines Morsecodes
        for (int i = 0; i < abc.length(); ++i) {
            // Codiere die Zeichen (sofern möglich) mit dem Morsecode namens "morse"
            System.out.println(abc.charAt(i) + " -> " + morse.code(abc.charAt(i)));
        }
    }
 
}


PS.: Frag doch bitte mal beim Betreuer nach, was die LinkedList hier bezwecken soll. Für Random Access ohne regelmäßiges Insert/Delete verwendet man ArrayList oder einfache Arrays. Selbst eine HashMap wäre hier besser geeignet!


-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.11, vom Themenstarter, eingetragen 2021-05-03


Hallo Der Einfältige,
danke für deine Lösung, aber sie enthält zu vieles, was wir noch nicht hatten. Ich möchte nur mit den gegebenen Mitteln arbeiten, und da hatten wir eben nur (unsere eigene) LinkedList und Konstruktoren und Klassen.

Sag mir bitte, wie ich meinen Code noch hinbiegen kann. Also insb. die code-Methode, die nicht statisch sein darf (laut Hinweise), aber die auch nicht aufgerufen werden kann in der Main-Methode, wenn sie nicht statisch ist.

Für mich ist das ein Widerspruch, den ich nicht auflösen kann.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
zippy
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 24.10.2018
Mitteilungen: 2276
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.12, eingetragen 2021-05-03


2021-05-03 11:48 - curious_mind in Beitrag No. 11 schreibt:
Für mich ist das ein Widerspruch, den ich nicht auflösen kann.

Du musst code auf einer Instanz von Morse aufrufen. Das hatte dir tactac in Beitrag Nr. 8 und ich in Beitrag Nr. 3 bereits geschrieben.

Deine Antwort hier...

2021-05-03 11:29 - curious_mind in Beitrag No. 9 schreibt:
Ich soll aber das eingelesene Wort übersetzen in Morsecode und nicht das Morsealphabet übersetzen.

... ergibt keinen Sinn. Wenn die code-Methode nicht das macht, was sie soll, musst du sie ändern. Das hat aber nichts damit zu tun, wie du sie aufrufen musst.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 2867
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.13, eingetragen 2021-05-03


Das hat tactac dir bereits beantwortet und mein Code dir eigentlich gezeigt.

Du erstellst eine Instanz der Klasse Morse und rufst deren Methode code auf.
Java
/* Relevant Code gone missing ... */
 
    public static void main(String[] args){
        var myMorse = new Morse(); // Create instance of morse encoder
        var myEncodedString = myMorse.code('F'); // Encode a char
        System.out.println(myEncodedString);
        myEncodedString = myMorse.code('Z'); // Encode another char
        System.out.println(myEncodedString);
        myEncodedString = myMorse.code('a'); // Encode yet another char
        System.out.println(myEncodedString);
     }
 

Ausgabe:
..-.
--..
Fehler!



PS.: Mein Code verwendet weder ListIteratoren (zumindest nicht explizit), noch explizite Fehlerbehandlung (da hier komplett unsinnig).
Ich habe einzig das repetetive addLast abgekürzt, da man so etwas einfach nicht macht (DoNotRepeatYourself!) und zudem das sinnlose try/catch durch einen einfachen ternären Ausdruck ersetzt.

[Die Antwort wurde nach Beitrag No.11 begonnen.]


-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.14, vom Themenstarter, eingetragen 2021-05-03


Gut, mag sein, dass man das alles auch viel effizienter und cooler und mit weniger Überflüssigem und Sinnlosem programmieren kann.

Das hilft aber jemandem, der eine explizite Aufgabe mit expliziten Vorgaben dazu hat, was benutzt werden soll (eigene Linkedlist-Klasse von S. 121 inkl. List-Iterator, sowie vorgegebener NoSuchElementException) nicht, weil ich das inhaltlich dann weder verstehe, was du codest (weil wir das noch gar nicht kennen) noch das so einreichen / nutzen dürfte!

Wie du sicher weißt, gibt es im Internet zu Hauf Beispiele für Java-Code, der komplett uneffizient und sinnfrei ist, weil man die gleiche Aufgabe auch viel einfacher lösen kann, der aber aus didaktischen Gründen genau so verwendet oder präsentiert wird.

Danke für Eure Versuche, mir hier zu helfen, hat aber leider diesmal nicht geklappt. No hard feelings.

Die Aufgabe setzt anscheinend mehr Verständnis von Objekten und Instanzen, sowie Aufrufe von Methoden in verschiedenen statischen oder nicht-statischen Klassen voraus, als ich durch das Lesen meines Skripts erwerben konnte. Wahrscheinlich wäre es einfacher, wenn man gerade mit anderen Mitstudenten mehr im Kontakt sein könnte, um den Stoff zu diskutieren.

Danke trotzdem - ernst gemeint! Ich gucke in ein paar Wochen noch mal zurück, vielleicht macht das dann alles mehr Sinn :)



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
zippy
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 24.10.2018
Mitteilungen: 2276
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.15, eingetragen 2021-05-03


2021-05-03 14:39 - curious_mind in Beitrag No. 14 schreibt:
Ich gucke in ein paar Wochen noch mal zurück, vielleicht macht das dann alles mehr Sinn :)

Was du bis dahin auch lernen solltest, ist, in den Antworten auf deine Fragen die Übersicht nicht zu verlieren und, wenn dir mehrere Personen antworten, nicht alle Antworten in einen Topf zu werfen.

Mit dem Beitrag Nr. 8 von tactac waren alle Probleme ausgeräumt, die mit dem Thema statisch/nicht-statisch zusammenhängen. Hättest du seinen Vorschlag umgesetzt und das komplette Makeover von DerEinfaeltige ignoriert, wärst bis zu einem Programm gekommen, das sich compilieren lässt und läuft.

Dass dieses Programm trotzdem nur Blödsinn ausgegeben hätte, hat dann viel banalere Gründe: Du verwendest Character.getNumericValue in dem falschen Glauben, dass diese Methode den ASCII-Code liefert. Du schreibst i == laufzahl in einer for-Schleife, wo eigentlich ein <= hingehört. Du machst einen Off-by-one-Error beim Durchsuchen der Liste.

Diese Fehler hätten sich aber leicht durch Debuggen finden und korrigieren lassen.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.16, vom Themenstarter, eingetragen 2021-05-03


2021-05-03 15:33 - zippy in Beitrag No. 15 schreibt:
Diese Fehler hätten sich aber leicht durch Debuggen finden und korrigieren lassen.

Dafür muss das Ding aber kompilieren :)

Mit alphabet.code(b) hat es das getan, sodass ich die code-Methode jetzt auch debuggen konnte.
Java
package KE2.EA2;
import java.util.NoSuchElementException;
import java.util.Scanner;
 
    class Morse {
        // Konstruktor für Morsealphabet-Objekt
        private LinkedList<String> morsealphabet = new LinkedList<String>();
        Morse(){
            morsealphabet.addLast(".-");
            morsealphabet.addLast("-...");
            morsealphabet.addLast("-.-.");
            morsealphabet.addLast("-..");
            morsealphabet.addLast(".");
            morsealphabet.addLast("..-.");
            morsealphabet.addLast("--.");
            morsealphabet.addLast("....");
            morsealphabet.addLast("..");
            morsealphabet.addLast(".---");
            morsealphabet.addLast("-.-");
            morsealphabet.addLast(".-..");
            morsealphabet.addLast("--");
            morsealphabet.addLast("-.");
            morsealphabet.addLast("---");
            morsealphabet.addLast(".--.");
            morsealphabet.addLast("--.-");
            morsealphabet.addLast(".-.");
            morsealphabet.addLast("...");
            morsealphabet.addLast("-");
            morsealphabet.addLast("..-");
            morsealphabet.addLast("...-");
            morsealphabet.addLast(".--");
            morsealphabet.addLast("-..-");
            morsealphabet.addLast("-.--");
            morsealphabet.addLast("--..");
        }
 
        public static void main(String argv[]) {
            Morse alphabet = new Morse();
 
            System.out.print("Geben Sie ein Wort ein: ");
            Scanner scanner = new Scanner(System.in);
            String input = scanner.nextLine();
            char[] buchstaben = input.toCharArray();
            System.out.println("Ergebnis:");
            for (char b : buchstaben) {
                System.out.println(alphabet.code(b));
            }
        }
        // code-Methode ist nicht statisch, also ist sie nur auf Objekte anwendbar.
        public String code(char b) {
            //System.out.print("Ascii of " + b + " is " + (int)b+".");
            int laufzahl = (int)b - 64;
            //System.out.println("Korrigierte Nummer ist:"+laufzahl);
            String str = "";
            LinkedList<String>.ListIterator it = morsealphabet.listIterator();
            try {
                for (int i = 1; i <= laufzahl; i++) {
                    str = it.next();
                }
                return str;
            } catch (NoSuchElementException e) {
                return "Fehler!";
            }
        }
    }
 
    class LinkedList<ET> {
        (...)
 

Trotzdem ist das nicht zufriedenstellend für mich.

Es reicht ja nicht, dass es jetzt ausgibt, was es soll. Das tut es nur, weil ich ewig rumprobiert, geraten und Code-Schnipsel von hier benutzt habe.

Für mich ist immer noch unklar:

- Was dieses [Objekt].[Methode] genau aussagt. Also, wieso ich alphabet.code(b) schreiben musste, denn diese Syntax verstehe ich auf Deutsch als:
"Wende Methode 'code' auf 'alphabet' an", was bedeuten würde, dass er das Morsealphabet übersetzen soll. Offenbar tut er das nicht bzw. interpretiert diese Syntax anders (richtig), aber dennoch interpretiere ich diese Syntax offenbar falsch, deshalb wäre ich auch nie auf die Idee gekommen, alphabet.code zu schreiben. Wenn dann eher buchstaben.code (weil die Methode soll schließlich die das char-array buchstaben umwandeln).

- Wieso
Java
private LinkedList<String> morsealphabet = new LinkedList<String>();
        Morse(){
            (...)
        }
jetzt funktioniert. Mir leuchtet weder ein, wieso man hier eine private LinkedList erstellen sollte, wieso der Konstruktor nicht private sein soll (oder ob er das vielleicht besser auch sein sollte), und wieso ich überhaupt diesen Konstruktor jetzt brauchte.

- Auch weiß ich nicht, wieso ich ein Morse-Objekt und ein LinkedList-Objekt brauche.

- Auch weiß ich nicht, wo der Aufgabensteller gern die Exception bzw. das try/catch gesehen hätte. Ich meinte, die wäre da richtg lokalisiert. Der Einfältige meint, die wäre sinnlos. Ich weiß jetzt nicht, ob die dort "logisch sinnlos" (weil anders besser zu programmieren, was dann egal wäre, weil ich ja nur die Aufgabenstellung befolge) oder ob sie auch "syntaktisch sinnlos" ist.

Das ist etwas frustrierend für mich, hat aber nichts mit Euch zu tun, ich bin dankbar für Eure Hilfe.



















Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Bilbo
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 03.01.2005
Mitteilungen: 2008
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.17, eingetragen 2021-05-03


Hallo curious_mind,

2021-05-03 16:25 - curious_mind in Beitrag No. 16 schreibt:
- Was dieses [Objekt].[Methode] genau aussagt. Also, wieso ich alphabet.code(b) schreiben musste, denn diese Syntax verstehe ich auf Deutsch als:
"Wende Methode 'code' auf 'alphabet' an", was bedeuten würde, dass er das Morsealphabet übersetzen soll. Offenbar tut er das nicht bzw. interpretiert diese Syntax anders (richtig), aber dennoch interpretiere ich diese Syntax offenbar falsch, deshalb wäre ich auch nie auf die Idee gekommen, alphabet.code zu schreiben.

Stell Dir eine Klasse als einen Bausatz für ein Ikea-Möbelstück vor, in dem allerhand Einzelteile liegen. Diese Einzelteile, die Du verwenden kannst, sind hier die Variablen und Funktionen. Nun kann es in zwei verschiedenen Bausätzen (z.B. einem für ein Regal und einem für ein Bett) jeweils ein Teil geben, das in der jeweiligen Bauanleitung als "Schraube" bezeichnet wird. Das heißt aber nicht, dass die Schrauben die gleiche Größe haben. Wenn Du nun beide Möbelstücke aufbauen sollst und Dir jemand die Anweisungen dazu gibt, muss er also sagen:
"Nimm die Schraube aus dem Bausatz 'Regal' und schraube sie fest."

Genauso ist es hier: "alphabet" ist eine Instanz (=ein Möbelstück) der Klasse "Morse" (=des Typs 'Regal'). Wenn Du "alphabet.code(...)" schreibst, gibt das also zunächst einfach nur an, dass Du die Methode in der Klasse "Morse" verwenden sollst; denn es kann ja auch z.B. eine andere Klasse "Braille" geben, die für Blindenschrift-Kodierung verwendet wird und ebenfalls eine Methode "code(...)" besitzt.  
 
Wenn die Methode "code(...)" statisch wäre, wäre das auch schon der ganze Zauber. Da sie nicht statisch ist, ist die Wahrheit noch etwas komplizierter: Denn es geht nicht nur darum, die Methode auf der richtigen Klasse, sondern auch auf der richtigen Instanz der Klasse anzuwenden. Also wenn Du zwei Regale der gleichen Sorte aufbaust, die Teile nicht durcheinanderzubringen. Das wäre hier zum Beispiel wichtig, wenn Du gleichzeitig mit verschiedene Morse-Instanzen mit unterschiedlichen Morse-Alphabeten arbeiten würdest (was in dem Beispiel natürlich nicht der Fall ist).

Das erklärt auch, warum Du so ein "Morse"-Objekt benötigst. Ohne eine Instanz kommst Du an die nicht-statischen Methoden und Variablen gar nicht dran.


Mir leuchtet weder ein, wieso man hier eine private LinkedList erstellen sollte, wieso der Konstruktor nicht private sein soll (oder ob er das vielleicht besser auch sein sollte), und wieso ich überhaupt diesen Konstruktor jetzt brauchte.

Du bräuchtest diesen Konstruktor nicht zwingend. Stattdessen könntest Du auch eine Methode "buildMorseAlphabet()" schreiben, die den Code enthält, der jetzt in Deinem Konstruktor ist. Dann müsstest Du in Deinem Code
Java
Morse alphabet = new Morse();
alphabet.buildMorseAlphabet();
 
...

schreiben. Übrigens ist der Name "alphabet" für Deine Variable nicht gut gewählt. Es handelt sich hier nicht um eine Instanz für das Alphabet, sondern für den Übersetzer!

Ob die Methode nun "private" oder "public" ist (oder package-private wie in Deinem Fall, da Du weder "private" noch "public" angegeben) hast, ist syntaktisch egal, solange Du nur mit einer Klasse arbeitest. Wichtig wird es, wenn Du mehrere Klassen hast, die untereinander agieren sollen. In der Regel sind Konstruktoren aber "public", damit eine Klasseninstanz auch von einer anderen erzeugt werden kann.

Auch weiß ich nicht, wo der Aufgabensteller gern die Exception bzw. das try/catch gesehen hätte. Ich meinte, die wäre da richtg lokalisiert. Der Einfältige meint, die wäre sinnlos. Ich weiß jetzt nicht, ob die dort "logisch sinnlos" (weil anders besser zu programmieren, was dann egal wäre, weil ich ja nur die Aufgabenstellung befolge) oder ob sie auch "syntaktisch sinnlos" ist.

Syntaktisch ist die Exception schon an der richtigen Stelle, soweit ich sehe. Über die Exception würde ich mir jetzt keine zu großen Gedanken machen, versuch erst mal, den Rest richtig zu verstehen.

Viele Grüße
Thorsten


-----------------
Heilmagier der Drachengilde
Wohlordner des Universums
Rechner des Unberechenbaren
Navigator Irrlichts im Ozean der Rätsel



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 2867
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.18, eingetragen 2021-05-03


[Objekt].[Methode] ruft die Methode einer bestimmten Instanz eines Typs auf.
alphabet.code(c) heißt also:
Hey Kodierer namens "alphabet", du hast doch diese tolle code-Methode.
Wende die doch bitte mal auf den Charakter c an gib mir das Ergebnis zurück.
Besonders interessant wird das natürlich erst, wenn man tatsächlich verschiedene Kodierer mit verschiedenen Morsealphabeten besitzt, die man bspw. über den Konstruktor übergibt.
Dann kann man für jedes Alphabet eine passende Kodierinstanz erstellen.



Zum Konstruktor:
Einen privaten Konstruktor kann man nur von der Klasse selbst aus aufrufen.
Der Konstruktor könnte hier private sein, da die aufrufende main-Methode in derselben Klasse liegt.
Von außerhalb wäre er sonst nicht aufrufbar und man bräuchte eine öffentliche statische Methode zum Erzeugen einer Instanz.
(Stichworte: Singleton-Pattern, Factory-Pattern etc.)


Zum Arbeiten mit LinkedList:
1. Die Exception ist logisch sinnlos.
Du kannst ja direkt berechnen, ob der Charakter im zulässigen Bereich liegt oder nicht. Es gibt also keinen Grund hier hochgradig kompliziert mit try/catch zu agieren.
2. Mir ist nach wie vor nicht klar, ob ihr LinkedList oder irgendeinen selbstdefinierten Container verwendet, den irgendein Witzbold im Sinne allgemeiner Verwirrung ebenfalls "LinkedList" getauft hat.
Im letzteren Fall gibt es eventuell keine get(index)-Methode und auch kein addAll(Container). Trotzdem gilt es, 26 Zeilen mit der gleichen Anweisung zu vermeiden.

[Die Antwort wurde nach Beitrag No.16 begonnen.]


-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.19, vom Themenstarter, eingetragen 2021-05-03


Danke für Eure Geduld.

@Thorsten:
Die Beispiele mit den Möbeln und der Braille sind aufschlussreich. Zumindest kann ich mir nun vorstellen, wieso er das Morsealphabet (den Übersetzer) gern nicht-statisch haben wollte.

Also verstehe ich richtig - korrigier mich bitte:

Ich habe die parametrische Klasse LinkedList aus dem Skript gegeben. Um eine Liste mit String-Elementen zu erstellen (wo ich die Morse-Zeichen einspeichern kann), muss ich ein Listen-Objekt bzw. eine Instanz dieser LinkedList-Klasse erstellen, geschehen durch "private LinkedList<String> morsealphabet = new LinkedList<String>();"

Die Aufgabenstellung verlangt zudem - durch die Vorgabe des Methodenkopfes "public String code(...)", dass die code-Methode nicht statisch ist, sodass ich gezwungen bin ein Kodierer-Objekt bzw. eine Instanz der Morse-Klasse zu erstellen, um für dieses Objekt bzw. mithilfe dieses Objekts (Übersetzer) ein eingelesenes Wort zu übersetzen - "alphabet.code(b)"

Ist das soweit richtig?


Frage 1: Ich habe ja schon ein Objekt (diese LinkedListe). Wieso kann man diese Liste nicht einfach mit den Morse-Zeichen füllen und dann LinkedListGefüllt.code(b) machen? Also, wieso brauchte man auch noch ein Morse-Objekt?

Frage 2: Die Instanz LinkedList wird (bei mir jetzt) direkt am Anfang der Klasse Morse erstellt. Hätte ich die besser direkt in die Main Methode geschrieben, also bevor ich in der Main den Morse-Konstruktor aufrufe?

Frage 3: WANN genau wird (bei mir) die LinkedList-Instanz erstellt? Beim Aufruf des Morse-Konstruktors?

@Der Einfältige
Frage 4: Wo hättest du denn try/catch hingemacht? Irgendwo muss die Exception ja abgefangen werden, das sagte mir jedenfalls der Compiler. Und irgendwo muss ich auch diese NoSuchElementException throw'n, das suggiert die Aufgabenstellung jedenfalls. Andersgesagt: Vorausgesetzt ich WOLLTE eine NoSuchElementException werfen, wo hättest du das try/catch dann gemacht?

P.S. Die LinkedList-Klasse habe ich zu Thread-Beginn vollständig angegeben. Ich weiß nicht, ob die mit der offiziellen Klasse so übereinstimmt (bzw. ein Ausschnitt von der offiziellen darstellt) oder anders ist, aber jedenfalls sollen wir genau diese Klasse für die Aufgabe nutzen und nur die Methoden die da stehen (Im Skript wurde anhand dieser Klasse das Thema Parametrische Klassen erläutert).]

 



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Bilbo
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 03.01.2005
Mitteilungen: 2008
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.20, eingetragen 2021-05-03


2021-05-03 22:38 - curious_mind in Beitrag No. 19 schreibt:
Ist das soweit richtig?

Ja, das stimmt soweit.

Frage 1: Ich habe ja schon ein Objekt (diese LinkedListe). Wieso kann man diese Liste nicht einfach mit den Morse-Zeichen füllen und dann LinkedListGefüllt.code(b) machen? Also, wieso brauchte man auch noch ein Morse-Objekt?

Du meinst, warum man die Methode "code(...)" nicht in der Klasse "LinkedList" definiert? - Das macht natürlich im Sinne von Code-Wiederverwendbarkeit wenig Sinn, da Typ der verketteten Liste ja ein ganz allgemeines Konzept ist, das man in allerlei Anwendungen gebrauchen kann, die überhaupt nichts mit Morse-Übersetzung zu tun haben. Da möchte man nicht überall so eine Methode "code(...)" mit rumschleppen ... Ein allgemeines Paradigma "guter" Programmierung besagt, dass eine Klasse immer nur möglichst eine Sache tun soll.

Oder soll "LinkedListGefüllt" eine eigene Klasse sein? Dann wäre die Frage, was für eine?

Frage 2: Die Instanz LinkedList wird (bei mir jetzt) direkt am Anfang der Klasse Morse erstellt. Hätte ich die besser direkt in die Main Methode geschrieben, also bevor ich in der Main den Morse-Konstruktor aufrufe?

Frage 3: WANN genau wird (bei mir) die LinkedList-Instanz erstellt? Beim Aufruf des Morse-Konstruktors?

Da Du die LinkedList direkt im Konstruktor benötigst, kannst Du sie entweder dort erstellen oder so wie Du es gemacht hast, direkt bei der Deklaration initialisieren. Das läuft auf das gleiche hinaus - sie wird beim Aufruf des Morse-Konstruktors aufgebaut.

Du könntest sie auch von "außen" als zusätzliches Argument übergeben (in deinem Fall also in der main-Methode aufbauen). Der Konstruktor hätte dann das Aussehen
Java
Morse(LinkedList alphabet)
{
   this.morsealphabet = alphabet
}

Damit wäre deine Klasse selbst flexibler und Du könntest auch ein Braille-Alphabet übergeben.

Für die Zwecke der Aufgabenstellung genügt es aber so, wie es ist.

Viele Grüße
Thorsten



@Der Einfältige
Frage 4: Wo hättest du denn try/catch hingemacht? Irgendwo muss die Exception ja abgefangen werden, das sagte mir jedenfalls der Compiler. Und irgendwo muss ich auch diese NoSuchElementException throw'n, das suggiert die Aufgabenstellung jedenfalls. Andersgesagt: Vorausgesetzt ich WOLLTE eine NoSuchElementException werfen, wo hättest du das try/catch dann gemacht?

P.S. Die LinkedList-Klasse habe ich zu Thread-Beginn vollständig angegeben. Ich weiß nicht, ob die mit der offiziellen Klasse so übereinstimmt (bzw. ein Ausschnitt von der offiziellen darstellt) oder anders ist, aber jedenfalls sollen wir genau diese Klasse für die Aufgabe nutzen und nur die Methoden die da stehen (Im Skript wurde anhand dieser Klasse das Thema Parametrische Klassen erläutert).]

 



-----------------
Heilmagier der Drachengilde
Wohlordner des Universums
Rechner des Unberechenbaren
Navigator Irrlichts im Ozean der Rätsel



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.21, vom Themenstarter, eingetragen 2021-05-04


2021-05-03 23:29 - Bilbo in Beitrag No. 20 schreibt:
Frage 1: Ich habe ja schon ein Objekt (diese LinkedListe). Wieso kann man diese Liste nicht einfach mit den Morse-Zeichen füllen und dann LinkedListGefüllt.code(b) machen? Also, wieso brauchte man auch noch ein Morse-Objekt?

Du meinst, warum man die Methode "code(...)" nicht in der Klasse "LinkedList" definiert?

Nein, ich meinte eher, die code-Methode in der Morse-Klasse zu lassen sowas zu machen wie (von der Idee her):

LinkedList<String> neueListe = new LinkedList<String>();
neueListe.add([Morsezeichen]); (x 26)
...
[Buchstaben einlesen]

for (b in Buchstaben) {
neueListe.Morse.code(b)
}

Also die code-Methode auf das (individuelle Listen-)Objekt neueListe anzuwenden.

Aber das geht wahrscheinlich nicht -> genau an den Stellen, wo ich  ".add" und ".code" verwenden wollte, hatte ich ja immer die Kompilierweigerung.

Kannst du mir (nochmal) sagen warum? Kann man Methoden in einer Klasse immer nur auf eigene Objekte derselben Klasse anwenden?


2021-05-03 23:29 - Bilbo in Beitrag No. 20 schreibt:
(...)
Da Du die LinkedList direkt im Konstruktor benötigst, kannst Du sie entweder dort erstellen oder so wie Du es gemacht hast, direkt bei der Deklaration initialisieren. Das läuft auf das gleiche hinaus - sie wird beim Aufruf des Morse-Konstruktors aufgebaut.

Du könntest sie auch von "außen" als zusätzliches Argument übergeben (in deinem Fall also in der main-Methode aufbauen). Der Konstruktor hätte dann das Aussehen
Java
Morse(LinkedList alphabet)
{
   this.morsealphabet = alphabet
}


Nur zur Sicherheit - dann müsste es aber so aussehen
Java
class Morse{
 
LinkedList<String> morsealphabet; 
 
Morse(LinkedList alphabet)
{
   this.morsealphabet = alphabet
}
 
}
oder?

Ja, das wäre natürlich sinnvoller, aber du hast Recht, das übersteigt die Aufgabenstellung.

Danke schon mal.



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 2867
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.22, eingetragen 2021-05-04


Es geht auch bspw. so:
Java
  1. public class Morse {
  2.  
  3. private LinkedList<String> morsealphabet;
  4.  
  5. public Morse(String[] abc) {
  6. morsealphabet = new LinkedList<>();
  7. for (var s : abc)
  8. morsealphabet.addLast(s);
  9. }
  10.  
  11. public String code(char c) {
  12. int nv = c - 65;
  13. if (nv < 0 || nv >= morsealphabet.size())
  14. return "Fehler!";
  15. var it = morsealphabet.listIterator();
  16. for (int i = 0; i < nv; ++i)
  17. it.next();
  18. return it.next();
  19. }
  20.  
  21. public static void main(String[] args){
  22. String[] abc = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
  23. "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.." };
  24. var myMorse = new Morse(abc); // Create instance of morse encoder
  25. var myEncodedString = myMorse.code('L'); // Encode a char
  26. System.out.println(myEncodedString);
  27. myEncodedString = myMorse.code('S'); // Encode another char
  28. System.out.println(myEncodedString);
  29. myEncodedString = myMorse.code('a'); // Encode yet another char
  30. System.out.println(myEncodedString);
  31. }
  32.  
  33. }


Das nutzt jetzt eure LinkedList statt java.util.LinkedList.
Jede Instanz kann so ihr eigenes Alphabet übergeben bekommen.



Den Rest der Frage verstehe ich nicht.
Eine Methode gehört zu einer Klasse und (falls sie nicht statisch ist) zu einem Objekt/einer Instanz derselben.

Du wendest hier keine Methode einer Klasse auf sich selbst an.
Du wendest eine Methode der Klasse Morse auf ein Objekt von Typ char an.


Wenn ich aus Teig einen Kuchen machen will, brauche ich einen Ofen, der backen kann.
Die Backfunktion des Ofens wende ich dann auf den Teig an.
Java
class Kueche{
    static class Teig{
    }
 
    static class Ofen{
       void backe(Teig t){
          System.out.println("Backe, backe, Kuchen ...");
       }
    }
 
    public static void main(String[] args){
       var meinOfen = new Ofen(); // Ich brauche einen Ofen
       var hefeTeig = new Teig(); // Ich brauche einen Teig
       meinOfen.backe(hefeTeig); // Jetzt kann ich Kuchen backen
    }
}



-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.23, vom Themenstarter, eingetragen 2021-05-06


Ok, auch zu deinem Beispiel fallen mir noch Fragen ein, falls du noch magst:
Java
class Kueche{
    static class Teig{
    }
 
    static class Ofen{
       void backe(Teig t){
          System.out.println("Backe, backe, Kuchen ...");
       }
    }
 
    public static void main(String[] args){
       var meinOfen = new Ofen(); // Ich brauche einen Ofen
       var hefeTeig = new Teig(); // Ich brauche einen Teig
       meinOfen.backe(hefeTeig); // Jetzt kann ich Kuchen backen
    }
}

1. Warum müssen Teig und Ofen statisch sein?
2. Ist "backe" statisch, weil es in der statischen Klasse drin steht oder nicht-statisch, weil kein static davor steht?
3. Warum muss man in der Main-Methode keine new Küche Objekt erstellen?



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 2867
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.24, eingetragen 2021-05-06


1. Ein Objekt einer statischen Klasse kann unabhängig existieren.
Genausogut könnte man die Klassen Teig und Ofen in eigenen Dateien definieren.

2. backe ist nicht-statisch. Es gehört zu einem bestimmten Ofenobjekt.

3. Da Teig und Ofen statisch sind, benötigt man kein Objekt einer Küche um diese zu erstellen.


Ohne das static-Keyword sieht es bspw. so aus:
Java
  1. class Kueche{
  2. class Teig{
  3. }
  4.  
  5. class Ofen{
  6. void backe(Teig t){
  7. System.out.println("Backe, backe, Kuchen ...");
  8. }
  9. }
  10.  
  11. public static void main(String[] args){
  12. var meineKueche = new Kueche();
  13. var meinOfen = meineKueche.new Ofen();
  14. var hefeTeig = meineKueche.new Teig();
  15. meinOfen.backe(hefeTeig);
  16. }
  17. }


Lesetipp:
Nested Classes in den Java-Tutorials.



-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 10.11.2012
Mitteilungen: 470
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.25, vom Themenstarter, eingetragen 2021-05-06


Alles klar, ok, langsam macht das Ganze mehr Sinn.

Danke für Deine & Eure Hilfe.

Bis wahrscheinlich bald. :D



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
curious_mind hat die Antworten auf ihre/seine Frage gesehen.
curious_mind hat selbst das Ok-Häkchen gesetzt.
Neues Thema [Neues Thema]  Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2021 by Matroids Matheplanet
This web site was originally made with PHP-Nuke, a former web portal system written in PHP that seems no longer to be maintained nor supported. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]