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 variable
van egy változó, amely egy objektumra való hivatkozást tárol, és method
az 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 variable
egy változó, amely egy objektumra való hivatkozást tárol, és field
egy példányváltozó (mező).
2. new
operá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 Class
van 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 arguments
egy 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 console
vá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)
Scanner
console
nextInt()
A második sorban az objektum metódusát hívjuk meg Scanner
a változó segítségével console
, amely az objektumra való hivatkozást tárolja Scanner
.
Példák objektum létrehozására:
Kód | Leírás |
---|---|
|
Hozzon létre egy String objektumot |
|
Hozzon létre egy Scanner objektumot |
|
Hozzon létre egy int[] : elemtárolót10 int |
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 s
vá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 100
pontok 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, Point
amely 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 Point
osztá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 String
objektum 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 String
osztály összes változója rejtett, azaz deklarált private
.
Másodszor, nem örökölheti az String
osztályt: az osztálydeklarációja tartalmazza a final
mó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 String
nagybetű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.