Java objektumok

1. Tárgyak

A Java-ban minden objektum.

Pontosabban, nagyon kevés olyan dolog van a Java-ban, ami nem objektum. Például primitív típusok. De ez egy meglehetősen ritka kivétel a szabály alól.

Tehát mi az objektum?

Az objektum olyan entitás, amely az adatokat az adatokat feldolgozó metódusokkal csoportosítja . Amikor azt mondjuk, hogy "adatok", akkor természetesen változókra gondolunk.

Az objektum változóit "adatainak" vagy "állapotának" nevezik.

Egy objektum metódusai a „viselkedése”. Egy objektum állapotát (változóit) csak az adott objektum metódusaival szokás megváltoztatni. Az objektum változóinak közvetlen megváltoztatása (a metódusok használata nélkül) rossz formának minősül.

Minden objektumnak és minden változónak van típusa . Ez a típus az objektum létrehozásakor egyszer kerül meghatározásra, és a jövőben nem módosítható. Az objektum típusa az osztálya.

Minden objektumnak megvan a saját példányváltozója (mezője). Ha egy nem statikus int változót deklarálunk egy osztályban, és a programunk 10 objektumot hoz létre ebből az osztályból, akkor minden objektumnak saját int változója lesz.

Interakció egy tárggyal

Az objektumokkal való munkavégzés legkényelmesebb módja, ha egy változóban tárolunk egy hivatkozást, majd metódusokat hívunk meg ezen a változón. Ez ismerősnek tűnik számodra:

variable.method()

Hol variablevan egy változó, amely egy objektumra való hivatkozást tárol, és methodaz adott osztály metódusa.

Ha egy objektum mezőjére (változójára) szeretne hivatkozni, akkor a pont operátort is kell használnia :

variable.field

Ahol variableegy változó, amely egy objektumra való hivatkozást tárol, és fieldegy példányváltozó (mező).

2. newoperátor

Egy adott osztály objektumának létrehozásához az operátort kell használni new. Általában a következőképpen néz ki egy objektum létrehozása:

Class variable = new Class(arguments);

Hol Classvan a változó osztályának neve variable, valamint a létrehozandó objektum osztályának neve. És variable egy olyan változó, amely hivatkozást tárol a létrehozott objektumra. És argumentsegy helyőrző a konstruktornak átadott argumentumok vesszővel tagolt listájához.

Az átadható argumentumok konkrét listáját az osztályt író programozók döntik el.

Már korábban is hozott létre objektumokat, és még ezt a konstrukciót is használta. Nem felejtetted el, remélem?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— ez létrehoz egy consoleváltozót, amelynek típusa Scanner. — ez új objektumot hoz létre. A hozzárendelési operátor pedig az újonnan létrehozott objektumra való hivatkozással egyenlővé állítja a változót.new Scanner(System.in)Scannerconsole

nextInt()A második sorban az objektum metódusát hívjuk meg Scannera változó segítségével console, amely az objektumra való hivatkozást tárolja Scanner.

Példák objektum létrehozására:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

A létrehozott objektumokat az osztály osztályának vagy példányainak , míg az osztályt az objektum osztályának nevezzük . Például a sváltozó egy hivatkozást tárol az osztály egy példányára String.

3. Tanórák bemutatása

Azt hiszem, már láthattad, milyen kényelmes a más programozók által írt osztályok használata. De mi a helyzet a saját órák megírásával?

Honnan tudod, hogy mikor és hol van szükséged saját osztályodra, és hogyan készíts egyet?

A programozók általában saját osztályokat hoznak létre, amikor új entitást akarnak bevinni a programba. Ez zavaróan hangzik? Aztán megpróbálom elmagyarázni, de messziről kezdem.

Adatok csoportja

Kicsit leegyszerűsítve azt mondhatjuk, hogy a Java objektum egy memóriablokk, amely az osztályban deklarált változókat (példánymezőket) tartalmazza. Vagy más szóval változók egy csoportba kombinálva.

Tegyük fel, hogy a programnak el kell tárolnia a 100pontok koordinátáit, és szüksége van egy módszerre, hogy megjelenítse azokat a képernyőn. Ezt tömbök segítségével lehet megtenni. Például így:

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

Sokkal kényelmesebb lenne, ha egyetlen típusunk lenne egy pontra vonatkozó összes információ tárolására: x, y, color. Ha ilyen típus nem létezik a Java-ban, saját maga is létrehozhatja.

Ehhez kódot írunk egy osztályhoz Point:

public class Point
{
   public int x;
   public int y;
   public int color;
}

Most a fenti kód átírható a következőre:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Most adjunk hozzá egy metódust az osztályhoz, Pointamely információkat jelenít meg az objektumról:

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

Az osztály most Solutionígy néz ki:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Ügyesen elrejtettük a pont koordinátáit és színinformációit az Pointosztályon belül a pont állapotát megjelenítő metódussal együtt.

Az osztályok a program összetettségének kezelésének egyik módja. Egy nagy program kevésbé lesz bonyolult, ha sok kis osztályra bontják.

4. Változatlan vs megváltoztathatatlan objektumok

Egyszer régen tanulmányoztuk a Java konstansait, és olyan következtetésre jutottunk, amely nem túl megnyugtató. A konstansok segítségével megvédheti a változókat a módosítástól, de nem akadályozhatják meg az objektumok megváltoztatását, amelyekre hivatkoznak.

A probléma megoldására a Java konstans objektumokkal állt elő. Vagy ahogy gyakrabban nevezik, megváltoztathatatlan objektumok.

Egyébként már ismersz olyan osztályt, aminek az objektumait nem lehet megváltoztatni: String. Az Stringobjektum létrehozása után örökre változatlan marad. És hogyan érték el ezt a Java alkotói?

Először is, az Stringosztály összes változója rejtett, azaz deklarált private.

Másodszor, nem örökölheti az Stringosztályt: az osztálydeklarációja tartalmazza a finalmódosítót.

Harmadszor, és ami a legérdekesebb, az osztály összes metódusa String, amelytől elméletileg a meglévő objektum megváltoztatását várná, valójában nem változtatja meg, hanem egy újat ad vissza.

Például a toUpperCase()metódus a karakterlánc összes betűjét nagybetűvé teszi. De ahelyett, hogy megváltoztatná az objektumot, amelyen a metódus meghívásra kerül, egy új objektumot ad vissza, amely Stringnagybetűkből áll:

String text = "This is a very important message";
String message = text.toUpperCase();

Ez lesz a memóriában a kód végrehajtása után:

Tehát nyugodtan adja át a húrjait bármilyen módszernek: senki nem fogja megváltoztatni őket.