Package in Java

[sousou]

Hallo zusammen,


Ich b´beschäftige mich grad mit Packages in Java. Wusste dabei bis vor 2 stunden nichts hab mir aber nun so einige Infos angeeignet also z.B das man ein package macht um zugehörigkeiten von Klassen zu haben und dann der volle Name PackageName.Klassenname ist. Nun wollt ich ne Übungsaufgabe mal lösen die lautet:


static Attribute können in den eigenen Namensbereich importiert werden. Bsp:
import static java.lang.Math.PI
...
double radius = 4.2;
double umfang = 2*PI*radius;
Auch die Namen von Aufzählkonstanten können static importiert werden.
Schreiben Sie in einem Package rfh eine Aufzählung Unit mit den L¨angeneinheiten
Millimeter, Zentimeter usw., also mit den Konstanten mm, cm, dm, m. Im Konstruktor
soll jeweils die L¨ange gemessen in Millimeter mitgegeben werden, also 1 bei mm, 10 bei
cm usw.
Schreiben Sie außerhalb des Packages eine Klasse TestUnit
class TestUnit {
Unit x = cm; // diese Zeile nicht ver¨andern!
}
Erg¨anzen Sie die import-Anweisungen, damit TestUnit ohne Fehlermeldung compiliert.




Die Lösung hiervon ist:

   import RFH.Unit;
   import static RFH.Unit.cm ;

    class TestUnit {
      Unit x = cm;
   }   





package RFH;
   
	
    public enum Unit{
      	/* die konstanten sind immer public */
      mm(1),cm(10),dm(100),m(1000);
      
      int millimeter;
  
  
      
       Unit(int millimeter){
         this.millimeter=millimeter;
      }
		
		
      
  }

Meine Frage hierbei ist, außerhalb des Package erfolgen zwei import mit:


import RFH.Unit;
import static RFH.Unit.cm ;


Soganz versteh ich nicht was die Imports bewirken. In der Aufgabenstellung steht auch nur, dass man die einfügen sollte damit keine Fehlermeldungen angezeigt werden sollen.



lg

 

[Landei]

Packages sind ganz einfach zu verstehen, es sind sozusagen die "Verzeichnisse", in denen die Klassen stehen.

Nehmen wir einmal eine ArrayList. Der "volle Name" ist java.util.ArrayList ("die Klasse ArrayList im Unterpackage util vom Package java"), und so könntest du ihn auch in jeder anderen Klasse immer so verwenden. Willst du das java.util. davor nicht jedesmal mitschreiben, schreibst du einmal import java.util.ArrayList, und ab da weiß Java, welche Klasse gemeint ist. Hast du nun eine Menge imports für ein bestimmtes package, kannst du mit Sternchen alle Klassen dort bekannt machen, in unserem Beispiel java.util.*

import static ist etwas anderes, es importiert statische Member aus einer Klasse. Angenommen du willst EMPTY_LIST oder sort() aus java.util.Collections verwenden. Dann hast du mit "normalen" imports (also import java.util.Collections oder java.util.*) die Möglichkeit, Collections.EMPTY_LIST oder Collections.sort(myList) aufzurufen. Alternativ kann man mit einem statischen Import die statischen Member "bekannt machen": Nach import static java.util.Collections.EMPTY_LIST bzw. import static java.utils.Collections.sort() "weiß" deine Klasse, dass mit EMPTY_LIST oder sort(myList) die statischen Member von Collections gemeint sind. Wiederum gibt es die Abkürzung mit dem Sternchen, so dass alle statischen Member bekannt gemacht werden: import static java.util.Collections.*;

imports und statische imports sind also "nur" kleine Helfer, damit man nicht immer die "vollen" Namen schreiben muss, etwa so, wie du in der Konsole statt den vollen Dateinamen anzugeben auch mit cd ins entsprechende Verzeichnis wechseln und dort die Datein ohne Pfadangabe ansprechen kannst.

 

[sousou]

danke erstmal, denke mal das import ohen static verstanden zu haben. Aber das mit static da kenn ich fast keine Klasse von denen du sprichst.

Könntest du es bissien kurz und knapp an meinen angegeben beispiel bitte erklären?



THX!

 

[Landei]

Ich kenne dafür Unit nicht. Aber trotzdem: Mit dem "normalen" import (import RFH.Unit) wäre die Klasse Unit bekannt, und man könnte z.B. überall in deiner Klasse Unit.cm statt dem vollen Namen RFH.Unit.cm schreiben. Aber da das trotzdem immer noch etwas nervig ist, gibt es statische imports. Nach import static RFH.Unit.cm; weiß dein Programm, dass mit "cm" das cm aus RFH.Unit gemeint ist, du kannst es ohne den Zusatz Unit. einfach als cm verwenden.

Eine Klasse, die du bestimmt kennst, ist java.lang.Math, die auch oft statisch importiert wird (import static java.lang.Math.*). Danach kann man all die statischen mathematischen Funktionen ohne den Vorsatz Math. aufrufen, also sqrt(2) statt Math.sqrt(2), sin(PI/6) statt Math.sin(PI/6) usw.

Da ist wirklich nichts weiter dabei, imports sind einfach "Abkürzungen", damit man nicht immer die ganzen Namen schreiben muss, sonst nichts. Woher soll das Programm auch wissen, ob du mit "List" die Klasse java.awt.List oder java.util.List meinst? Oder was dieses "cm" bedeuten soll, was nirgendwo definiert ist. Du sagst: "Das cm, das ich meine, kommt aus RFH.Unit.cm", und gut ist. Wenn du das nicht verstehst, schlage ich die Hände über dem Kopf zusammen, renne schreiend im Kreis und verweise auf Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 3.5 Pakete und import-Deklarationen nutzen

 

[sousou]

achsoo, ja total easy jetzt 😉 danke also

kurz zusammengefasst:

ohne statischen import nur normalen Import also import RFH.Unit:

x = Unit.cm;


bedeutet so gesehen einfach mit staitischen import also import static RFH.Unit.cm:

x = cm;


Dies gibt es dann nicht?...import RFH.Unit.cm

 

[Landei]

Genau. Ein normaler import bezieht sich immer auf eine Klasse oder ein Interface (oder mit Sternchen auf mehrere).
Ein statischer Import bezieht sich immer auf die statischen Member einer Klasse oder eines Interfaces (oder mit Sternchen auf mehrere).