Nutzen von Importmethoden bei Klasseninstanzen

[xYurisha]

Hallo zusammen,
Ich hätte eine Frage bezüglich Klasseninstanzen in Verbindung mit Importmethoden.
In meinem aktuellen Programm habe ich in meiner Main-Klasse eine Klasseninstanz von einer Klasse Names "Inventar" angelegt.
Diese Klasse arbeitet wiederum mit einer HashMap, die Ich ja erstmal importieren musste. Das Problem das ich habe und nicht verstehe ist, dass ich trotz instanziieren der Klasse Inventar nicht den HashMap-Befehl .isEmpty(); in der Main-Klasse aufrufen kann, sondern erst in der Inventarklasse nochmals in eine Methode schreiben muss in der, der Befehl steht. Kann mir jemand erklären wieso oder was ich falsch mache ?

Meine Idee war das beim ansprechen von der Klasseninstanz er die Methode isEmpty() kennt da ich sie ja importiert habe, anscheint ist dies aber nicht so.

Danke schon mal für eure Hilfe!

//MAIN Klasse
package game;

public class Spiel {

    public static void main(String[] args) {
        Item sword = new Item(1,"Schwert");
        Inventar inventar = new Inventar();
        System.out.prinln(inventar.isEmpty()); //Den Abschnitt will er nicht machen da er die Methode anscheinend nicht kennt
        System.out.println(inventar.emptyInv());//Das macht er aber
    }

}

//Klasse Inventar

package game;
import java.util.HashMap;
public class Inventar {
    
private HashMap<Integer, Integer> inv = new HashMap<Integer, Integer>();

    public void addItem(Item item, int amount) {
        if(amount > 0) {
            inv.put(item.get_ID(), amount);   
        }
    }
    
    public boolean emptyInv() {
        return inv.isEmpty();
    }
}

 

[LimDul]

Woher soll java wissen, was passieren soll, wenn du inventar.isEmpty() aufrufst? Was ist, wenn du z.B. zwei HashMaps in der Inventar Klasse hast. Oder andere Objekte die eine isEmpty Methode anbieten?

Der Import sorgt nur für eins - dass Java weiß, wenn du HashMap schreibst dass du die Klasse java.util.HashMap meinst.

Hintergrund ist: Java-Klassen haben (analog wie z.B. domains) einen vollqualifizierten Namen. Das ermöglicht es z.B. das du eine eigene Klasse schreibst und sie HashMap nennst. Deine Klasse, die du da geschrieben hast, hat den vollqualifizierten Namen game.Inventar. Man könnte komplett auf Imports verzichten und immer den vollqualifizierten Namen schreiben. Dann sähe dein Code wie folgt aus:

package game;

public class Spiel {

    public static void main(String[] args) {
        game.Item sword = new game.Item(1,"Schwert");
        game.Inventar inventar = new game.Inventar();
        java.lang.System.out.prinln(inventar.isEmpty()); //Den Abschnitt will er nicht machen da er die Methode anscheinend nicht kennt
        java.lang.System.out.println(inventar.emptyInv());//Das macht er aber
    }

}

//Klasse Inventar

package game;

public class Inventar {
   
private java.util.HashMap<Integer, Integer> inv = new java.util.HashMap<Integer, Integer>();

    public void addItem(game.Item item, int amount) {
        if(amount > 0) {
            inv.put(item.get_ID(), amount);  
        }
    }
   
    public boolean emptyInv() {
        return inv.isEmpty();
    }
}

Das ist offensichtlich schnell nicht mehr lesbar, vor allem wenn die Package-Namen tief verschachtelt werden. Und genau dafür sind Imports da.

 

[Kirby.exe]

Das liegt daran, dass deine Hash Map private ist

Edit: habe die getter übersehen

 

[LimDul]

Das liegt daran, dass deine Hash Map private ist

Nein. Auch dann würde obiger Code nicht gehen.

Dann würde

inventar.inv.isEmpty();

gehen - aber das wäre schlechter Stil.

 

[Gelöschtes Mitglied 62473]

System.out.prinln(inventar.isEmpty()); //Den Abschnitt will er nicht machen da er die Methode anscheinend nicht kennt

Wie sollte er auch? inventar ist keine HashMap jedoch beinhaltet sie eine.

 

[Kirby.exe]

@LimDul aus reinem Interesse: Was ist der Unterschieden zwischen

private HashMap<Integer, Integer> inv = new HashMap<Integer, Integer>();

und dem

private java.util.HashMap<Integer, Integer> inv = new java.util.HashMap<Integer, Integer>();

 

[xYurisha]

Wie sollte er auch? inventar ist keine HashMap jedoch beinhaltet sie eine.

Ich dachte dadurch das Inventar eine HashMap beinhaltet kann ich auch ihre Methoden benutzen, wie es in der Klasse selbst ja auch geht.

 

[Gelöschtes Mitglied 62473]

Ich dachte dadurch das Inventar eine HashMap beinhaltet kann ich auch ihre Methoden benutzen

Nein.

 

[Kirby.exe]

Ich dachte dadurch das Inventar eine HashMap beinhaltet kann ich auch ihre Methoden benutzen, wie es in der Klasse selbst ja auch geht.

Du kannst alle Methoden in Inventar aufrufen, jedoch hast du versucht die Methode isEmpty() in Inventar aufzurufen Diese existiert dort jedoch nicht

 

[xYurisha]

Woher soll java wissen, was passieren soll, wenn du inventar.isEmpty() aufrufst? Was ist, wenn du z.B. zwei HashMaps in der Inventar Klasse hast. Oder andere Objekte die eine isEmpty Methode anbieten?

Der Import sorgt nur für eins - dass Java weiß, wenn du HashMap schreibst dass du die Klasse java.util.HashMap meinst.

Hintergrund ist: Java-Klassen haben (analog wie z.B. domains) einen vollqualifizierten Namen. Das ermöglicht es z.B. das du eine eigene Klasse schreibst und sie HashMap nennst. Deine Klasse, die du da geschrieben hast, hat den vollqualifizierten Namen game.Inventar. Man könnte komplett auf Imports verzichten und immer den vollqualifizierten Namen schreiben. Dann sähe dein Code wie folgt aus:

package game;

public class Spiel {

    public static void main(String[] args) {
        game.Item sword = new game.Item(1,"Schwert");
        game.Inventar inventar = new game.Inventar();
        java.lang.System.out.prinln(inventar.isEmpty()); //Den Abschnitt will er nicht machen da er die Methode anscheinend nicht kennt
        java.lang.System.out.println(inventar.emptyInv());//Das macht er aber
    }

}

//Klasse Inventar

package game;

public class Inventar {
  
private java.util.HashMap<Integer, Integer> inv = new java.util.HashMap<Integer, Integer>();

    public void addItem(game.Item item, int amount) {
        if(amount > 0) {
            inv.put(item.get_ID(), amount); 
        }
    }
  
    public boolean emptyInv() {
        return inv.isEmpty();
    }
}

Das ist offensichtlich schnell nicht mehr lesbar, vor allem wenn die Package-Namen tief verschachtelt werden. Und genau dafür sind Imports da.

Stimmt du hast recht, danke! Ich habe das komplett übersehen.

 

[Kirby.exe]

Man könnte komplett auf Imports verzichten und immer den vollqualifizierten Namen schreiben. Dann sähe dein Code wie folgt aus:

Hatte das überlesen Jetzt habe ich verstanden wo der Unterschied liegt

 

[Gelöschtes Mitglied 62473]

Du vergleichst Birnen mit Äpfeln. Drei workarounds:
1. wrapper Methoden schreiben (am saubersten),
2. Modifier ändern und auf Variable mit. zugreifen (am unsaubersten),
3. HashMap implementieren, also das Interface implementieren oder von ihr erben.

 

[xYurisha]

@All Danke für eure schnellen und guten Antworten, ihr habt mir sehr weitergeholfen!