Unterschied zwischen new und import

[efaq]

Hi Leute, ich hab eine Frage: Wo genau liegt der Unterschied zwischen dem Erzeugen einer neuen Instanz (new..) und dem Import von einer Klasse, um davon dann ein Objekt in einer anderen Klasse erzeugen zu können?

Folgendes: Ich habe ein Java-Projekt, dass mehrere Packages hat. In einem Package namens "utils" liegt eine Klasse namens "GenerList". In einem anderen Package liegen 2 "Dinge": Einmal eine Klasse namens "StockManger" und einmal ein Interface namens "StockItem".

Hier mal der Code aus der Klasse StockManager:

package bookstore.stock;

import bookstore.utils.GenericList;

/*
* Diese Klasse ist (beispielhaft) für die Überwachung
* der Lagerbestände und deren Gesamtgewicht zuständig.
* (damit das Regalbrett nicht bricht o.ä.)
*/
public class StockManager {

/*
* Damit eine Datenstruktur benutzt werden kann, die unsere
* Objekte verwaltet, wurde die StringList aus einer vergangenen
* Sitzung zu umprogrammiert, dass jetzt beliebige Datentypen
* damit verwendet werden können. Das geschieht mit Generics
* (die Typ-Angaben in den spitzen Klammern). Wir sehen uns
* Generics später noch genauer an, deshalb können sie hier
* vorerst ignoriert werden.
*/
private GenericList<StockItem> stock;

public StockManager() {
//neue Instanz der Liste erzeugen
this.stock = new GenericList<StockItem>();
}

/*
* Fügt der Liste ein StockItem hinzu
*/
public void addStockItem(StockItem item){
stock.add(item);
}

/*
* Gibt das Gesamtgewicht aller StockItems im Lager zurück
*/
public double getTotalItemWeight() {
double weight = 0;
for (int i = 0; i < stock.size(); i++) {
weight += stock.get(i).getWeight();// Woher kommt das "i"?
}
return weight;
}

}




Frage: Wieso kann hier die GenericList via import erzeugt werden? Ich dachte man müsste immer eine "Sache" via new Operator instanziieren. Zudem kann ich auf StockItem zugreifen. Warum? Es liegt zwar im selben Package aber müsste ein Objekt hierfür nicht auch erst via new erzeugt werden?

Stattdessen steht da "private GenericList<StockItem> stock; " und es scheint zu klappen. Wo genau liegt hier der Unterschied? Wann muss man also new verwenden und wann geht so was wie da oben? Hat es was mit Generics im Allgemeinen zu tun?

Ich danke euch schon mal im Voraus für eure Antwort!

 

[httpdigest]

Wo genau liegt der Unterschied zwischen dem Erzeugen einer neuen Instanz (new..) und dem Import von einer Klasse, um davon dann ein Objekt in einer anderen Klasse erzeugen zu können?

Irgendwie steckt die Antwort doch schon in deiner Frage: Mit `new` erzeugst du eine neue Instanz einer Klasse. Und das `import` Schlüsselwort dient nur für das Auflösen von Typen bei Verwendung von nicht vollqualifizierten Namen, wenn die Typen nicht imselben Package sind. Zum Beispiel kannst du komplett auf `import` Statements verzichten, wenn du immer vollqualifizierte Namen ausschreibst, wie z.B. `bookstore.utils.GenericList` statt `import bookstore.utils.GenericList` und `GenericList`.
Die Liste der `import`-Statements am Anfang der Compilation Unit sagt dem Java Compiler nur, wo er mal versuchen soll zu gucken, wenn er auf einen nicht vollqualifizierten Namen eines Typs trifft, den er nicht auflösen kann.

 

[efaq]

Irgendwie steckt die Antwort doch schon in deiner Frage: Mit `new` erzeugst du eine neue Instanz einer Klasse. Und das `import` Schlüsselwort dient nur für das Auflösen von Typen bei Verwendung von nicht vollqualifizierten Namen, wenn die Typen nicht imselben Package sind. Zum Beispiel kannst du komplett auf `import` Statements verzichten, wenn du immer vollqualifizierte Namen ausschreibst, wie z.B. `bookstore.utils.GenericList` statt `import bookstore.utils.GenericList` und `GenericList`.
Die Liste der `import`-Statements am Anfang der Compilation Unit sagt dem Java Compiler nur, wo er mal versuchen soll zu gucken, wenn er auf einen nicht vollqualifizierten Namen eines Typs trifft, den er nicht auflösen kann.

Danke erstmal für deine Antwort, aber leider verstehe ich das nicht so ganz..

1) was genau ist gemeint mit "Verwendung von nicht vollqualifizierten Namen "?
2) Und du meinst es reicht aus, wenn man nur `bookstore.utils.GenericList` statt `import bookstore.utils.GenericList` schreibt? Also quasi das "import" einfach weglassen oder wie?

 

[httpdigest]

Beispiel deiner Klasse ohne import:

package bookstore.stock;
public class StockManager {
  private bookstore.utils.GenericList<StockItem> stock; // <- bookstore.utils.GenericList ist ein vollqualifizierter Name
  public StockManager() {
    this.stock = new bookstore.utils.GenericList<StockItem>();
  }
  public void addStockItem(StockItem item){
    stock.add(item);
  }
  public double getTotalItemWeight() {
    double weight = 0;
    for (int i = 0; i < stock.size(); i++) {
      weight += stock.get(i).getWeight();
    }
    return weight;
  }
}

 

[temi]

Wieso kann hier die GenericList via import erzeugt werden?

Mit "import" erzeugt man gar nichts.

In deinem Beispiel wird eine private Variable vom Typ "GenericList" deklariert.

Im Konstruktor wird dann eine Instanz erzeugt und zugewiesen:

public StockManager() {
//neue Instanz der Liste erzeugen
this.stock = new GenericList<StockItem>();
}

 

[mihe7]

Danke erstmal für deine Antwort, aber leider verstehe ich das nicht so ganz..

Ich versuche es mal mit einer Analogie. Wieso hast Du im Dateisystem Ordner? Klar, um Ordnung zu halten. Aber Ordner sind vor allem Namensräume. D. h. durch den Ornder ist es möglich, im Dateisystem zig mal den gleichen Dateinamen zu verwenden. Ich habe z. B. bestimmt 100 Dateien, die alle Test.java heißen. Das funktioniert, weil sie sich in unterschiedlichen Ordnern befinden.

Der Dateiname alleine reicht also nicht, um eine dieser 100 Dateien zu identifizieren. Vielmehr brauche ich einen vollqualifizierten Dateinamen. Das wäre auf meinem System der Pfad zur Datei. Zum Beispiel /home/mihe7/java/junk/area/Test.java

Wenn ich in dieses Verzeichnis wechsle, dann muss ich aber nicht den kompletten Pfad angeben, sondern es reicht Test.java anzugeben.

Genauso funktioniert das mit Java und seinen Klassen. Klassen befinden sich in Paketen. Der vollqualifizierte Name besteht also aus dem Pfad zur Klasse, z. B. java.lang.String ist eine Klasse, die sich im Paket (= Verzeichnis der Analogie) java.lang befindet.

Da der Entwickler seine Klassen in seinen Paketen erstellt, müsste er nun bei jeder Gelegenheit die vollqualifizierten Klassennamen angeben, z. B. java.util.List list = new java.util.ArrayList<>(); Das ist notwendig, damit der Compiler weiß, welche List und welche ArrayList verwendet werden soll (es kann ja mehrere geben)

Das wäre auf Dauer ziemlich nervig. Daher hat man die Möglichkeit mit einem import-Statement zu sagen, welche Klasse man meint, wenn im Code selbst das Paket weggelassen wird nicht angegeben wird.

import java.util.List; // verwende diese Klasse, wenn ich im Code nur von List spreche
...
private List list; // wegen des import-Statements kann der Compiler dies zu java.util.List auflösen.