extends macht aber was ganz anderes als define.
Wenn wir das mal am Beispiel Student und Person machen, d.h. jeder Student ist auch eine Person, dann wäre Student extends Person in C++ Student : Person, also eben genau das was Stiller Leser beschreibt, die Klasse Student erbt alle Eigenschaften der Klasse Person.
Wenn jede Person einen Namen hat und jeder Student einen Namen und einen Studiengang, dann sieht das z.B. so aus:
C++
Code:
#include <string>
using namespace std;
class Person {
private:
string name;
public:
Person(string n) {
name = n;
}
string getName(){
return name;
}
};
class Student : Person {
private:
string studiengang;
public:
Student(string n, string s):Person(n) {
studiengang = s;
}
string getStudiengang(){
return studiengang;
}
};
Java
Code:
class Person {
private String name;
public Person(String n) {
name = n;
}
public String getName() {
return name;
}
}
class Student extends Person {
private String studiengang;
public Student(String n, String s) {
super(n);
studiengang = s;
}
public String getStudiengang() {
return studiengang;
}
}
Was Feuerstern im EP beschreibt ist aber keine Subklasse im Sinne von Kindklasse, sondern eine Klasse als Eigenschaft einer anderen Klasse. Das kann man nicht durch Vererbung ersetzen. Ein Beispiel zur Veranschaulichung mit Person und Auto:
Code:
public class Main{
public static void main(String []args){
Auto A3 = new Auto("Audi A3");
Person Peter = new Person("Peter",A3);
System.out.println(Peter.getAuto().getMarke());
}
}
class Person {
private String name;
private Auto car;
Person(String n, Auto c) {
name = n;
car = c;
}
public String getName() {
return name;
}
public Auto getAuto() {
return car;
}
}
class Auto {
private String marke;
Auto(String m) {
marke = m;
}
public String getMarke() {
return marke;
}
}
Um hier die Automarke zu erhalten kann ich nur über Peter.getAuto().getMarke() gehen, da das Objekt Peter keine Funktion hat, um direkt auf die Marke seines Autos zugreifen zu können. Die Klasse Auto extended die Klasse Person nicht, das sind zwei völlig verschiedene Klassen.
Ich kann aber tricksen und die Funktion Person.getMarke() definieren, dann kann ich auch direkt mit Peter.getMarke() auf die Automarke zugreifen:
Code:
public class Main{
public static void main(String []args){
Auto A3 = new Auto("Audi A3");
Person Peter = new Person("Peter",A3);
System.out.println(Peter.getMarke());
}
}
class Person {
private String name;
private Auto car;
Person(String n, Auto c) {
name = n;
car = c;
}
public String getName() {
return name;
}
public Auto getAuto() {
return car;
}
public String getMarke() {
return car.getMarke();
}
}
class Auto {
private String marke;
Auto(String m) {
marke = m;
}
public String getMarke() {
return marke;
}
}
Also sowas kannst du schon machen, ist aber halt auch nicht ungefährlich wenn du beispielsweise die Variable marke umbenennen möchtest und infolgedessen auch die Getter-Funktion umbenennst, dann musst du das nicht nur in der Auto-Klasse und der Main-Funktion korrigieren, sondern auch in der Person-Klasse. Klar kann ein Programm wie Eclipse das automatisch machen, aber das führt die Klassentrennung irgendwie ad absurdum, dann kann ich ja auch gleich String automarke in die Person-Klasse reinschreiben und brauche keine Auto-Klasse mehr. Und später wenn man dann im Team an größeren Programmen arbeitet oder andere Leute das Programm weiterentwickeln müssen nachdem du gar nicht mehr an diesem Projekt arbeitest, da ist das auch nicht unbedingt optimal zum nachhalten. Wobei ich mit sowas auch kaum Erfahrung habe und ich auch kein Experte in sauberem Programmierstil bin.
So, das ist aber auch nicht deine Frage.
Du scheinst ja mit nested classes zu arbeiten, davon hab ich keinen Plan, hab ich noch nie benutzt. Wenn du nested classes wirklich brauchst, bleibt dir nicht viel anderes übrig, denn sowas wie #define gibt es in Java nicht, hat keinen Precompiler wo quasi Stringvariablen erstmal in Javacode umgesetzt werden.
Du kannst halt die Konstruktoren verpacken, also sowas machen wie
Code:
public class Main{
public static void main(String []args){
ParentAdapterItem parent = new ParentAdapterItem();
ParentAdapterItem.InnerAdapterItem item = parent.newInner();
}
}
class ParentAdapterItem {
class InnerAdapterItem {
public static final int TYPE_IMAGE = 0;
}
ParentAdapterItem.InnerAdapterItem newInner() {
ParentAdapterItem.InnerAdapterItem item = new ParentAdapterItem.InnerAdapterItem();
return item;
}
}
...dann sparst du dir zumindest die rechte Seite 
Oder nochmal verpacken à la
Code:
public class Main{
public static void main(String []args){
ParentAdapterItem parent = new ParentAdapterItem();
InnerAdapter x = new InnerAdapter(parent.newInner());
}
}
class ParentAdapterItem {
class InnerAdapterItem {
public static final int TYPE_IMAGE = 0;
}
ParentAdapterItem.InnerAdapterItem newInner() {
ParentAdapterItem.InnerAdapterItem item = new ParentAdapterItem.InnerAdapterItem();
return item;
}
}
class InnerAdapter {
private ParentAdapterItem.InnerAdapterItem inner;
ParentAdapterItem.InnerAdapterItem getInner() {
return inner;
}
void setInner(ParentAdapterItem.InnerAdapterItem i) {
inner = i;
}
InnerAdapter(ParentAdapterItem.InnerAdapterItem i) {
inner = i;
}
}
und dann mit x.getInner() drauf zugreifen 
Ah nee, das ist unschön.
Kannst auch einen Preprocessor als Plugin vorschalten: https://github.com/manifold-systems/...d-preprocessor
Aber dann kann das keiner außer dir mehr bearbeiten ohne dass die dasselbe Plugin auch haben.
Stackoverflow erwähnt Dependency Injections, allerdings hab ich davon absolut keinen Plan, also ka ob du damit was anstellen kannst.
World of Players
Java Unterklassen Aufrufe abkürzen
Zitat von Multithread
![[Bild: sigpic16020_3.gif]](https://forum.worldofplayers.de/forum/signaturepics/sigpic16020_3.gif){kind=link}
![[Bild: AMD_Threadripper.png]](https://upload.worldofplayers.de/files10/AMD_Threadripper.png){kind=link}
![[Bild: i6tfHoa3ooSEraFH63.png]](https://upload.worldofplayers.de/files10/i6tfHoa3ooSEraFH63.png){kind=link}