nh kombi, ganz ehrlich. videos zur schnelligkeit bücher und online seiten zur vertiefung oder um etwas schnell nachzuschlagen

praxiserfahrung ist natürlich denke ich selbstverständlich

ich erkläre es dir leicht aber oberflächlich.
wenn dus wirklich verstehen sollst guck unter der antwort nach:

sollte man eigentlich nicht.
es geht darum, dass die eigenschaften eines objekts normalerweise auf private gestellt werden um datenkapselung zu gewährleisten.
mit getter/setter kannst du dann trotzdem falls du musst auf die eigenschaften eines objekts zugreifen.
der vorteil ist auch, dass du zusätzliche logik über die getter/setter einbauen kannst bevor du auf das objekt zugreifst.

wenn jemand dir sagt du sollst für jede eigenschaft einer klasse ein getter/setter hinzufügen hat der keine ahnung von java und oop nicht verstanden

---------------------------------------------------------------------------------------------

ich versuchs dir leicht aber tiefgründig zu erklären:

ein prinzip bei oop ist datenkapselung.
es geht darum dass teile eines programms möglichst alleinstehend entwickelt werden, also modular. diese programmteile sollten nichts von einander wissen. deshalb setzt man im regelfall die eigenschaften eines objekts auf private.
das signalisiert dem programmierer, die daten/logik sind intern. diese können dadurch auch nicht von anderen programmteilen manipuliert werden können.

auf der anderen seite müssen programmteile jedoch mit anderen programmteile interagieren um ein brauchbares programm hinzukriegen. deshalb gehts jetzt rüber in das thema API Design

kurze analogie:
wenn du eine webseite benutzt dann benutzt du ja nicht direkt den server im hintergrund. der server bietet dir eine (hoffentlich) schöne seite mit der du bestimmte funktionen des servers nutzen kannst. direkten zugriff auf den server hast du aber nicht. das heißt du kannst jetzt nicht die webseite nach deinem belieben ändern oder so, sondern der server schränkt dich in deiner funktion ein.

in dieser analogie ist der server ein programmteil mit internen logik/daten und die webseite ist die API/schnittstelle die dir bereitgestellt wird um mit dem server zu arbeiten.

api design bedeutet, du schreibst dein programmteil so gezielt, dass du die nötige logik/ressourcen für andere programmteile über sogenannte öffentliche schnittstellen bietest.
mit der öffentlichen schnittstelle kannst du einen programmierer anleiten wie er dein programmteil richtig nutzt.

in java übersetzt sind:

• interne logik -> private methoden -> verhalten
• interne daten -> private felder -> attribute
• programmteil -> klasse

getter und setter sind öffentliche schnittstellen um auf interne daten innerhalb einer klasse zuzugreifen

der große vorteil durch modularisierung: weniger spaghetticode. heißt also wenn du ein programmteil veränderst, heißt das nicht unbedingt du musst den rest des programms verändern

minecraft ist bisschen komplizierter/unkomplizierter

tatsächlich ist minecraft wie die meisten bereits erwähnt haben proprietäre software, allerdings hat das spiel eine riesige community von denen teile minecraft dekompiliert haben um das spiel modden zu können

ms hat zum modden tatsächlich sogar offizielle decompiler angeboten aber kein schwein nutzt das weil die lizenzbedingungen zu streng sind

kurzgesagt: minecraft ist quelloffen aber keine quelloffene software

aufaddieren

 IntStream.of(numbers).sum(); // alle zahlen aufaddiert
 IntStream.of(numbers)
    .filter(num -> num >= 0)// keine negativen zahlen
    .sum();// alle zahlen aufaddiert

ersten index finden

int findFirstIndex(int x) {
  var nums = IntStream.of(numbers).boxed().toList();
  return nums.indexOf(x);
}

letzten index finden

int findLastIndex(int x) {
  var nums = IntStream.of(numbers).boxed().toList();
  return nums.lastIndexOf(x);
}

alle indexe

List<Integer> findAll(int x) {
  ObjIntConsumer<List<Integer>> addOccurence = (indices, i) -> {
    if (numbers[i] == x) indices.add(i);
  };
  return IntStream.range(0, numbers.length).collect(ArrayList::new, addOccurence, ArrayList::addAll);
}

literals sind in deinem kontext einfach code der direkt zu einem bestimmten wert evaluiert bzw. quellcode-repräsentationen eines bestimmten wertes.

wenn du im code 1 schreibst, kriegt das programm den wert 1

wenn du im code "bob" schreibst, kriegt dein programm den wert bob

wenn du true schreibst, kriegt dein programm (in tieferen schichten) den wert 1/true

folglich sind im code nicht-literals, code der nicht im programm direkt zu einem wert evaluiert.

@ code vs "@" literal

var a = true; literal wird genutzt um variable zu initialisieren

der bezeichner a repräsentiert keinen bestimmten wert sondern er referenziert irgendwas im quellcode

"a" hingegen repräsentiert auf code-ebene den buchstaben a