A Java csomagok olyan mechanizmusok, amelyek osztályok alcsomagjai és interfészek csoportját foglalják magukba. A csomagokat a következőkre használják:

• Akadályozza meg az elnevezési ütközéseket azáltal, hogy engedélyezi az azonos nevű osztályok létezését különböző csomagokban, például college.staff.cse.Employee és college.staff.ee.Employee.
• Könnyebbé teheti az osztályfelületek és egyéb összetevők megkeresését és használatát.
• Ellenőrzött hozzáférést biztosít a védett tagok számára, amelyek ugyanazon a csomagon belül és alosztályok szerint érhetők el. Az alapértelmezett tagok (nincs hozzáférés-meghatározó) csak ugyanazon a csomagon belül érhetők el.

A kapcsolódó osztályok csomagokba csoportosításával a Java elősegíti az adatok tokozását, így a kód újrafelhasználható és könnyebben kezelhető. Egyszerűen importálja a kívánt osztályt egy csomagból, hogy használni tudja a programjában.

Egyedi csomagok készítése

1. lépés: Hozzon létre egy könyvtárat, amelyben létrehozzuk a csomagjainkat és a Java fájljainkat.

mkdir PROGRAMOZÁS

hány millió van egy milliárdban

2. lépés: Most módosítsa a könyvtárat, és hozzon létre egy másik mappát a fő mappán belül

cd PROGRAMOZÁS
mkdir JavaProgramming
cd Javaprogramozás
mkdir tömbök

3. lépés: Most hozzon létre egy üres szöveges fájlt, és írja be az alábbi Java kódot, és ne felejtse el menteni ugyanazon a néven, mint a .java kiterjesztésű osztály (TwoPointers.java)

TwoPointers osztály.

package JavaProgramming.arrays; // Main class present inside the package  public class TwoPointers {  public static void main(String[] args) {  System.out.println('Inside the package');  } } 

Jegyzet: Ne felejtse el hozzáadni a csomag nevét a programfájlhoz.

4. lépés: Most futtassa a programot a mappa elérési útjának megadásával

javac srcJavaProgrammingarraysTwoPointers.java

java srcJavaProgrammingarraysTwoPointers.java

Kimenet:

Mappa szerkezete:

Ez egy egyéni Java-csomag vizuális megjelenítése az alábbi képen. Először hozunk létre egy Progamming nevű mappát, és azon belül létrehozunk egy Javaprogramming csomagot, majd létrehozunk egy másik alcsomagot, amely az ún. tömbök . Ezután létrehozunk benne egy Java osztályfájlt, amely az alábbi képen látható:

Java csomagok kezelése

Címtár szerkezete: A csomagnevek és a könyvtárszerkezetek szorosan összefüggenek. Például, ha egy csomag neve college.staff.cse, akkor három könyvtár a főiskolai személyzet és a cse, ahol a cse a személyzeten belül, a személyzet pedig a főiskolán belül található.

Elnevezési konvenciók : A csomagneveket a domain nevek fordított sorrendjében írjuk, pl. org.geeksforgeeks.practice. Egy főiskolán a konvenció a következő lehet:

• főiskola.tech.cse
• college.tech.ee
• főiskola.művészettörténet

Példa:

import java.util.*;

Itt az util egy a java csomagon belül létrehozott alcsomag.  

Hozzáférés az osztályokhoz a csomagon belül

Java-ban a következő módszerek valamelyikével importálhatunk osztályokat egy csomagból:

1. Importáljon egy adott osztályt :

import java.util.Vector;

Ez csak a Vector osztályt importálja a java.util csomagból.

2. Importálja az összes osztályt egy csomagból :

import java.util.*;

Ez importálja az összes osztályt és interfészt a java.util csomagból, de nem tartalmazza az alcsomagokat.

iterál a java térképen

Példa: Importálja a Vector osztályt

import java.util.Vector; public class Geeks {    public Geeks() {    // java.util.Vector is imported We are able to access it directly in our code.  Vector v = new Vector();    java.util.ArrayList l = new java.util.ArrayList();  l.add(3);  l.add(5);  l.add(7);    System.out.println(l);  }  public static void main(String[] args) {      new Geeks();  } } 

[3 5 7] 

Jegyzet:

• Import csomag használata.*; importálja az összes osztályt egy csomagban, de nem az osztályokat az alcsomagjaiból.
• Ha két csomagnak azonos nevű osztályai vannak (pl. java.util.Date és my.package.Date), használja a teljesen minősített nevet az ütközések elkerülése érdekében:

import java.util.Date;

import my.package.Date;

Java-csomagok típusai

• Beépített csomagok
• Felhasználó által definiált csomagok

1. Beépített csomagok

Ezek a csomagok nagyszámú osztályból állnak, amelyek a Java részét képezik API .A leggyakrabban használt beépített csomagok közül néhány:

• java.lang : Nyelvi támogatási osztályokat tartalmaz (például olyan osztályokat, amelyek primitív adattípusú matematikai műveleteket határoznak meg). Ez a csomag automatikusan importálódik.
• java.io: Osztályokat tartalmaz a bemeneti / kimeneti műveletek támogatására.
• java.util : Olyan segédprogramosztályokat tartalmaz, amelyek olyan adatstruktúrákat valósítanak meg, mint a Linked List Dictionary és támogatás; a dátum/idő műveletekhez.
• java.applet: Osztályokat tartalmaz kisalkalmazások létrehozásához.
• java.aut: Osztályokat tartalmaznak a grafikus felhasználói felületek összetevőinek megvalósításához (például gomb ;menük stb.). 6)
• java.net: Osztályokat tartalmaznak a hálózati műveletek támogatására.

2. Felhasználó által definiált csomagok

Ezeket a csomagokat a felhasználó határozza meg.

1. Hozza létre a csomagot:

int karakterlánchoz c++

Először létrehozunk egy myPackage könyvtárat (a névnek meg kell egyeznie a csomag nevével). Ezután hozza létre a MyClass-t a könyvtárban úgy, hogy az első utasítás a csomagnevek legyenek.

Példa:

package myPackage; public class MyClass {  public void getNames(String s)  {   System.out.println(s);   } } 

2. Használja az Osztályt a programban:

Most a MyClass osztály programunkban.

 import myPackage.MyClass; public class Geeks {  public static void main(String args[]) {     // Initializing the String variable with a value   String s = 'GeeksforGeeks';    // Creating an instance of class MyClass in the package.  MyClass o = new MyClass();    o.getNames(s);  } } 

Jegyzet: A MyClass.java fájlt a myPackage könyvtárba kell menteni, mivel a csomag része.  

Statikus import Java-ban

A Java statikus importálása a statikus tagokhoz való hozzáférés egyszerűsítéséről szól, és elválasztja a felhasználó által definiált csomagok szélesebb körű megvitatásától.

Statikus import a Java programozási nyelvben (5-ös és újabb verziók) bevezetett szolgáltatás, amely lehetővé teszi az osztályban nyilvánosként definiált tagokat (mezőket és metódusokat) statikus Java kódban kell használni anélkül, hogy megadná az osztályt, amelyben a mező definiálva van.

Példa:

import static java.lang.System.*; class Geeks {  public static void main(String args[]) {    // We don't need to use 'System.out' as imported using static.  out.println('GeeksforGeeks');  } } 

GeeksforGeeks 

Névütközések kezelése

Ha két csomag azonos nevű osztályt tartalmaz (pl. java.util.Date és java.sql.Date), adja meg a teljes csomagnevet az ütközések elkerülése érdekében.

import java.util.*;
import java.sql.*;
//És akkor használja a Date osztályt, akkor fordítási idő hibát kapunk:
Ma dátum ; //HIBA-- java.util.Date vagy java.sql.Date?

A fordító nem fogja tudni kitalálni, hogy melyik Date osztályt akarjuk. Ezt a problémát egy speciális importálási utasítás használatával lehet megoldani:

import java.util.Date;
import java.sql.*;

Ha mindkét Date osztályra szükségünk van, akkor a teljes csomagnevet kell használnunk minden alkalommal, amikor az adott osztály új objektumát deklaráljuk. Például:

java.util.Date deadLine = new java.util.Date();
java.sql.Date today = new java.sql.Date();

xvideoservicethief ubuntu 14.04 letöltés

Címtárszerkezet és CLASSPATH

A csomagnevek egy könyvtárszerkezetnek felelnek meg. Például egy Circle osztály a com.zzz.project1.subproject2 csomagban a következőképpen van tárolva:

$BASE_DIR/com/zzz/project1/subproject2/Circle.class

• Itt $BASE_DIR a csomag alapkönyvtárát jelenti.
• A csomag nevében szereplő „pont” a fájlrendszer egy alkönyvtárának felel meg.
• Az alapkönyvtár ( $BASE_DIR ) bárhol elhelyezkedhet a fájlrendszerben.
• Ezért a Java fordítót és a futtatókörnyezetet tájékoztatni kell a $BASE_DIR helyéről, hogy megtalálják az osztályokat.
• Ezt az úgynevezett környezeti változó hajtja végre CLASSPATH .
• A CLASSPATH hasonló egy másik PATH környezeti változóhoz, amelyet a parancshéj a végrehajtható programok keresésére használ.

CLASSPATH beállítása

A CLASSPATH a következő módok bármelyikével állítható be:

• A CLASSPATH a környezetben állandóan beállítható a Windows lépései szerint

Lépjen a Vezérlőpult -> Rendszer -> Speciális -> Környezeti változók menüpontra.

• Válassza a „Rendszerváltozók” lehetőséget, hogy a CLASSPATH-t a rendszer összes felhasználójára alkalmazza.
• Válassza a „Felhasználói változók” lehetőséget, ha csak az éppen bejelentkezett felhasználóra szeretné alkalmazni.
• CLASSPATH szerkesztése vagy létrehozása: Ha a CLASSPATH már létezik, jelölje ki, és kattintson a "Szerkesztés" gombra, vagy ha nem létezik, kattintson az "Új" gombra.
• Írja be a CLASSPATH részleteit: A „Változó neve” mezőbe írja be: „CLASSPATH” A „Változó értéke” mezőbe írja be a könyvtárakat és a JAR fájlokat pontosvesszővel elválasztva.
• A „Változó érték” mezőbe írja be a könyvtárakat és a JAR fájlokat pontosvesszővel elválasztva. Példa:

.c:javaprojectclasses;d:tomcatlibservlet-api.jar

• A pont (.) az aktuális munkakönyvtárat jelöli.
• A CLASSPATH aktuális beállításának ellenőrzéséhez adja ki a következő parancsot:

> CLASSPATH BEÁLLÍTÁSA

A CLASSPATH ideiglenesen beállítható az adott CMD shell munkamenethez a következő parancs kiadásával:

> SET CLASSPATH=.;c:javaprojectclasses;d:tomcatlibservlet-api.jar

A CLASSPATH környezeti változó használata helyett használhatja például a javac és a java parancsok -classpath vagy -cp parancssori kapcsolóját is.

> java –classpath c:javaprojectclasses com.abc.project1.subproject2.MyClass3

A felhasználó által definiált csomagok illusztrációja:  Első csomagunk elkészítése: Fájlnév – ClassOne.java

package package_name; public class ClassOne {  public void methodClassOne()  {  System.out.println('Hello there its ClassOne');  } } 

Második csomagunk elkészítése: Fájlnév – ClassTwo.java

package package_one; public class ClassTwo {  public void methodClassTwo()  {  System.out.println('Hello there i am ClassTwo');  } } 

Mindkét létrehozott csomagot felhasználva: Fájlnév – Testing.java

import package_name.ClassOne; import package_one.ClassTwo; public class Testing {  public static void main(String[] args)  {  ClassTwo a = new ClassTwo();  ClassOne b = new ClassOne();  a.methodClassTwo();  b.methodClassOne();  } } 

Most nézzük meg a csomagok és a tesztelési osztályfájl könyvtárszerkezetét:

Hozzáférés-módosítók a csomagok kontextusában

• Nyilvános: Tagok apublicmódosító bárhonnan elérhető, függetlenül attól, hogy a hozzáférési osztály ugyanabban a csomagban van-e vagy sem .
• Védett: A védett módosítóval rendelkező tagok ugyanazon a csomagon belül érhetők el Az alosztályokban
• Alapértelmezett: A módosító nélküli tagok csak ugyanazon a csomagon belül érhetők el
• Magán: Tagok aprivatemódosítók csak ugyanazon az osztályon belül érhetők el. Ezeket nem érhetik el az azonos csomag alosztályaiban vagy különböző csomagokban lévő osztályok.