Mga bagay sa Java

1. Mga bagay

Ang lahat sa Java ay isang bagay.

Mas tumpak, napakakaunting mga bagay sa Java na hindi mga bagay. Halimbawa, ang mga primitive na uri. Ngunit ito ay isang medyo bihirang pagbubukod sa panuntunan.

Kaya ano ang isang bagay?

Ang object ay isang entity na nagpapangkat ng data kasama ng mga pamamaraan na nagpoproseso ng data . Kapag sinabi naming "data", ibig sabihin namin ay variable, siyempre.

Ang mga variable ng isang bagay ay tinatawag na "data" o "estado".

Ang mga pamamaraan ng isang bagay ay sinasabing ang "pag-uugali" nito. Nakaugalian na baguhin ang estado ng isang bagay (mga variable) gamit lamang ang mga pamamaraan ng bagay na iyon. Ang direktang pagbabago ng mga variable ng isang bagay (hindi ginagamit ang mga pamamaraan nito) ay itinuturing na masamang anyo.

Ang bawat bagay , pati na rin ang bawat variable, ay may uri . Ang uri na ito ay tinutukoy nang isang beses kapag ang bagay ay nilikha at hindi na mababago sa hinaharap. Ang uri ng isang bagay ay ang klase nito.

Ang bawat bagay ay may sariling kopya ng mga variable ng halimbawa (mga patlang). Kung ang isang di-static na int isang variable ay idineklara sa isang klase, at ang iyong programa ay lumilikha ng 10 mga bagay ng klase na iyon, ang bawat bagay ay magkakaroon ng sarili nitong int isang variable.

Pakikipag-ugnayan sa isang bagay

Ang pinaka-maginhawang paraan upang gumana sa isang bagay ay ang pag-imbak ng isang reference dito sa isang variable, at pagkatapos ay tumawag ng mga pamamaraan sa variable na iyon. Ito ay mukhang pamilyar sa iyo:

variable.method()

Nasaan variableang isang variable na nag-iimbak ng isang sanggunian sa isang bagay, at methodisang paraan ng klase na iyon.

Kung gusto mong sumangguni sa isang field (variable) ng isang bagay, kailangan mo ring gamitin ang dot operator :

variable.field

Nasaan variableang variable na nag-iimbak ng reference sa isang object, at fieldisang instance variable (field).

2. newoperator

Upang lumikha ng isang bagay ng isang tiyak na klase, kailangan mong gamitin ang newoperator. Sa pangkalahatan, narito ang hitsura ng paglikha ng isang bagay:

Class variable = new Class(arguments);

Nasaan Classang pangalan ng klase ng variablevariable pati na rin ang pangalan ng klase ng bagay na gagawin. At variable ito ay isang variable na nag-iimbak ng isang sanggunian sa nilikha na bagay. At argumentsito ay isang placeholder para sa isang comma-delimited na listahan ng mga argumento na ipinasa sa constructor.

Ang tiyak na listahan ng mga argumento na maaaring ipasa ay napagpasyahan ng mga programmer na sumulat sa klase.

Nakagawa ka na ng mga bagay dati at ginamit mo pa ang partikular na construct na ito. Hindi mo nakalimutan, sana?

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

Scanner console— lumilikha ito ng consolevariable na ang uri ay Scanner. — lumilikha ito ng bagong bagay. At itinatakda ng operator ng pagtatalaga ang variable na katumbas ng isang sanggunian sa bagong likhang bagay.new Scanner(System.in)Scannerconsole

Sa pangalawang linya, tinatawag namin ang nextInt()pamamaraan sa Scannerbagay, gamit ang consolevariable, na nag-iimbak ng isang sanggunian sa Scannerbagay.

Mga halimbawa ng paglikha ng bagay:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

Ang mga nilikhang bagay ay tinatawag na mga bagay ng klase o mga pagkakataon ng klase , habang ang klase ay tinatawag na klase ng bagay . Halimbawa, ang svariable ay nag-iimbak ng reference sa isang instance ng Stringklase.

3. Pagpapakilala sa mga klase

Sa palagay ko nakita mo na kung gaano kaginhawa ang paggamit ng mga klase na isinulat ng ibang mga programmer. Ngunit ano ang tungkol sa pagsulat ng iyong sariling mga klase?

Paano mo malalaman kung kailan at saan mo kailangan ang iyong sariling klase at kung paano gumawa nito?

Karaniwang gumagawa ang mga programmer ng sarili nilang mga klase kapag gusto nilang magdala ng bagong entity sa programa. Nakakalito ba yan? Pagkatapos ay susubukan kong ipaliwanag, ngunit magsisimula ako sa malayo.

Grupo ng data

Ang pagpapasimple ng kaunti, maaari nating sabihin na ang isang bagay sa Java ay isang bloke ng memorya na naglalaman ng mga variable na ipinahayag sa isang klase (mga patlang ng halimbawa). O, sa madaling salita, ang mga variable ay pinagsama sa isang grupo.

Sabihin nating ang iyong programa ay kailangang mag-imbak ng mga coordinate ng 100mga puntos at nangangailangan ng isang paraan upang ipakita ang mga ito sa screen. Magagawa ito gamit ang mga arrays. Halimbawa, tulad nito:

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);
   }
}

Magiging mas maginhawa kung mayroon kaming isang uri para sa pag-iimbak ng lahat ng impormasyon tungkol sa isang punto: x, y, color. Kung walang ganoong uri sa Java, maaari mo itong gawin mismo.

Upang gawin ito, magsusulat kami ng code para sa isang Pointklase:

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

Ngayon ang code sa itaas ay maaaring muling isulat bilang:

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);
   }
}

Ngayon magdagdag tayo ng isang paraan sa Pointklase na magpapakita ng impormasyon tungkol sa bagay:

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

Ngayon ang Solutionklase ay ganito ang hitsura:

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);
   }
}

Mahusay naming itinago ang mga coordinate ng punto at impormasyon ng kulay sa loob ng Pointklase kasama ang pamamaraang nagpapakita ng estado ng punto.

Ang mga klase ay isang paraan upang pamahalaan ang pagiging kumplikado ng programa. Ang isang malaking programa ay nagiging hindi gaanong kumplikado kapag ito ay nahahati sa maraming maliliit na klase.

4. Nababago kumpara sa mga bagay na nababago

Noong unang panahon, pinag-aralan namin ang mga constant sa Java at nakarating sa isang konklusyon na hindi masyadong nakaaaliw. Hinahayaan ka ng mga Constant na protektahan ang mga variable mula sa pagbabago, ngunit hindi nila mapipigilan ang mga pagbabago sa mga bagay na kanilang tinutukoy.

Upang malutas ang problemang ito, nakabuo ang Java ng mga pare-parehong bagay. O, gaya ng mas madalas na tawag sa kanila, mga hindi nababagong bagay.

Sa pamamagitan ng paraan, alam mo na ang gayong klase, na ang mga bagay ay hindi mababago: String. Ang isang Stringbagay ay nananatiling walang pagbabago pagkatapos na ito ay nilikha. At paano ito nakamit ng mga tagalikha ng Java?

Una, ang lahat ng mga variable ng Stringklase ay nakatago, ibig sabihin, ipinahayag private.

Pangalawa, hindi mo mamanahin ang Stringklase: kasama sa deklarasyon ng klase nito ang finalmodifier.

Ikatlo, at pinaka-kawili-wili, ang lahat ng mga pamamaraan ng Stringklase, na, sa teorya, inaasahan mong baguhin ang umiiral na bagay, hindi talaga ito babaguhin, ngunit sa halip ay magbabalik ng bago.

Halimbawa, toUpperCase()ginagawa ng pamamaraan ang lahat ng mga titik sa string na uppercase. Ngunit sa halip na baguhin ang bagay kung saan tinawag ang pamamaraan, nagbabalik ito ng bagong Stringbagay na binubuo ng malalaking titik:

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

Ito ang magiging memorya pagkatapos isagawa ang code na ito:

Kaya huwag mag-atubiling ipasa ang iyong mga string sa anumang paraan: walang magbabago sa kanila.