În Java, clasele și obiectele sunt concepte de bază ale programării orientate pe obiecte (OOP) care sunt folosite pentru a reprezenta concepte și entități din lumea reală. Clasa reprezintă un grup de obiecte cu proprietăți și comportament similare. De exemplu, tipul animalului Câine este o clasă în timp ce un anumit câine numit Tommy este un obiect al Câine clasă.

În acest articol, vom discuta despre obiectele și clasele Java și despre cum să le implementăm în programul nostru.

Clasele Java

O clasă în Java este un set de obiecte care au în comun caracteristici/comportament și proprietăți/atribute comune. Este un model sau un prototip definit de utilizator din care sunt create obiectele. De exemplu, Student este o clasă, în timp ce un anumit elev numit Ravi este un obiect.

Proprietățile claselor Java

1. Clasa nu este o entitate din lumea reală. Este doar un șablon sau un model sau un prototip din care sunt create obiectele.
2. Clasa nu ocupă memorie.
3. Clasa este un grup de variabile de diferite tipuri de date și un grup de metode.
4. O clasă în Java poate conține:
   • Membru de date
   • Metodă
   • Constructor
   • Clasa imbricata
   • Interfață

Declarație de clasă în Java

  access_modifier     class   <  class_name>{ membru de date; metodă; constructor; clasă imbricată; interfata; }>>> 
    Exemplu de clasă Java    
 
Java
    
 
     
  
 
 

 
    
 
     
     
    
 
 
 

 
 
 
 
 // Java Program for class example> class> Student {> >// data member (also instance variable)> >int> id;> >// data member (also instance variable)> >String name;> >public> static> void> main(String args[])> >{> >// creating an object of> >// Student> >Student s1 =>new> Student();> >System.out.println(s1.id);> >System.out.println(s1.name);> >}> }> 
 
 
 
 
    
   
 
>
 
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // Java program to Illustrate Creation of Object> // Using new Instance> // Main class> class> GFG {> >// Declaring and initializing string> >String name =>'GeeksForGeeks'>;> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Try block to check for exceptions> >try> {> >Class cls = Class.forName(>'GFG'>);> >// Creating object of main class> >// using instance method> >GFG obj = (GFG)cls.newInstance();> >// Print and display> >System.out.println(obj.name);> >}> >catch> (ClassNotFoundException e) {> >e.printStackTrace();> >}> >catch> (InstantiationException e) {> >e.printStackTrace();> >}> >catch> (IllegalAccessException e) {> >e.printStackTrace();> >}> >}> }> 
 
 
 
 
    
 
>
 
    
 
>
 
stlc
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // Java program to Illustrate Creation of Object> // Using clone() method> // Main class> // Implementing Cloneable interface> class> GFG>implements> Cloneable {> >// Method 1> >@Override> >protected> Object clone()> >throws> CloneNotSupportedException> >{> >// Super() keyword refers to parent class> >return> super>.clone();> >}> >String name =>'GeeksForGeeks'>;> >// Method 2> >// main driver method> >public> static> void> main(String[] args)> >{> >GFG obj1 =>new> GFG();> >// Try block to check for exceptions> >try> {> >GFG obj2 = (GFG)obj1.clone();> >System.out.println(obj2.name);> >}> >catch> (CloneNotSupportedException e) {> >e.printStackTrace();> >}> >}> }> 
 
 
 
 
    
 
>
 
    
 
>
 
 
    Ieșire 1    
suită de instrumente de primăvară
 
0 null>
 
    Ieșirea 2    
 
GeeksForGeeks>
 
    Ieșirea 3    
 
GeeksForGeeks>
 
Componentele claselor Java
 
În general, declarațiile de clasă pot include aceste componente, în ordine:
  
 
 
    Modificatori    : O clasă poate fi publică sau are acces implicit (Consultați acest pentru detalii).
 
    Cuvânt cheie de clasă:    cuvântul cheie class este folosit pentru a crea o clasă.
 
    Numele clasei:    Numele trebuie să înceapă cu o literă inițială (cu majusculă prin convenție).
 
    Superclasă (dacă există):    Numele părintelui clasei (superclasa), dacă există, precedat de cuvântul cheie extinde. O clasă poate extinde (subclasă) doar un părinte.
 
    Interfețe (dacă există):    O listă separată prin virgulă de interfețe implementate de clasă, dacă există, precedată de cuvântul cheie implements. O clasă poate implementa mai mult de o interfață.
 
    Corp:    Corpul clasei este înconjurat de acolade, { }.
 
 
 
Constructorii sunt utilizați pentru inițializarea obiectelor noi. Câmpurile sunt variabile care furnizează starea clasei și a obiectelor sale, iar metodele sunt folosite pentru a implementa comportamentul clasei și al obiectelor acesteia.  
Există diferite tipuri de clase care sunt utilizate în aplicații în timp real, cum ar fi clase imbricate , cursuri anonime , și  expresii lambda  .
 
Obiecte Java
 
Un obiect în Java este o unitate de bază a programării orientate pe obiecte și reprezintă entități din viața reală. Obiectele sunt instanțele unei clase care sunt create pentru a utiliza atributele și metodele unei clase. Un program tipic Java creează multe obiecte, care, după cum știți, interacționează prin invocarea unor metode. Un obiect este format din:
 
 
    Stat    : este reprezentat de atributele unui obiect. De asemenea, reflectă proprietățile unui obiect.
 
    Comportament    : Este reprezentat prin metodele unui obiect. De asemenea, reflectă răspunsul unui obiect cu alte obiecte.
 
    Identitate    : dă un nume unic unui obiect și permite unui obiect să interacționeze cu alte obiecte.
 
 
Exemplu de obiect: câine
 
Obiecte Java
 
Obiectele corespund lucrurilor găsite în lumea reală. De exemplu, un program de grafică poate avea obiecte precum cerc, pătrat și meniu. Un sistem de cumpărături online poate avea obiecte precum coșul de cumpărături, clientul și produsul.
  
 
    Notă:    Când creăm un obiect care nu este un tip de date primitiv, acesta este întotdeauna alocat în memoria heap.
 
 
Declararea obiectelor (numită și instanțierea unei clase)
 
Când un obiect al unei clase este creat, se spune că clasa este    instanţiat    . Toate instanțele împărtășesc atributele și comportamentul clasei. Dar valorile acelor atribute, adică starea, sunt unice pentru fiecare obiect. O singură clasă poate avea orice număr de instanțe.
 
    Exemplu:    
 
Declarație de obiect Java
 
Pe măsură ce declarăm variabile precum (nume tip;). Acest lucru anunță compilatorul că vom folosi numele pentru a face referire la date al căror tip este tip. Cu o variabilă primitivă, această declarație rezervă și cantitatea adecvată de memorie pentru variabilă. Deci, pentru variabilele de referință, tipul trebuie să fie strict un nume de clasă concret. În general, noi    nu pot    creați obiecte dintr-o clasă abstractă sau o interfață.
 
Dog tuffy;>
 
Dacă declarăm o variabilă de referință (Tuffy) ca aceasta, valoarea acesteia va fi nedeterminată (nulă) până când un obiect este de fapt creat și atribuit acestuia. Pur și simplu declararea unei variabile de referință nu creează un obiect.
 
Inițializarea unui obiect Java
 
Noul operator instanțiază o clasă prin alocarea de memorie pentru un nou obiect și returnarea unei referințe la acea memorie. Noul operator invocă și constructorul clasei.
 
    Exemplu:    
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // Class Declaration> public> class> Dog {> >// Instance Variables> >String name;> >String breed;> >int> age;> >String color;> >// Constructor Declaration of Class> >public> Dog(String name, String breed,>int> age,> >String color)> >{> >this>.name = name;> >this>.breed = breed;> >this>.age = age;> >this>.color = color;> >}> >// method 1> >public> String getName() {>return> name; }> >// method 2> >public> String getBreed() {>return> breed; }> >// method 3> >public> int> getAge() {>return> age; }> >// method 4> >public> String getColor() {>return> color; }> >@Override> public> String toString()> >{> >return> (>'Hi my name is '> +>this>.getName()> >+>'.
My breed,age and color are '> >+>this>.getBreed() +>','> +>this>.getAge()> >+>','> +>this>.getColor());> >}> >public> static> void> main(String[] args)> >{> >Dog tuffy> >=>new> Dog(>'tuffy'>,>'papillon'>,>5>,>'white'>);> >System.out.println(tuffy.toString());> >}> }> 
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
 
Hi my name is tuffy. My breed,age and color are papillon,5,white>
 
    Inițializați folosind metoda/funcția:    
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 public> class> GFG {> >// sw=software> >static> String sw_name;> >static> float> sw_price;> >static> void> set(String n,>float> p)> >{> >sw_name = n;> >sw_price = p;> >}> >static> void> get()> >{> >System.out.println(>'Software name is: '> + sw_name);> >System.out.println(>'Software price is: '> >+ sw_price);> >}> >public> static> void> main(String args[])> >{> >GFG.set(>'Visual studio'>,>0>.0f);> >GFG.get();> >}> }> 
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
deschide meniul de setări
 
Software name is: Visual studio Software price is: 0.0>
 
Această clasă conține un singur constructor. Putem recunoaște un constructor deoarece declarația sa folosește același nume ca și clasa și nu are niciun tip de returnare. Compilatorul Java diferențiază constructorii în funcție de numărul și tipul argumentelor. Constructorul din    Câine    clasa ia patru argumente. Următoarea declarație oferă tuf, papillon, 5 și white drept valori pentru acele argumente:
 
Dog tuffy = new Dog('tuffy','papillon',5, 'white');>
 
Rezultatul executării acestei instrucțiuni poate fi ilustrat astfel:
 
Alocarea memoriei obiectelor Java
  
 
    Notă:    Toate clasele au cel puțin    unu    constructor. Dacă o clasă nu declară în mod explicit niciuna, compilatorul Java oferă automat un constructor fără argument, numit și constructor implicit. Acest constructor implicit apelează constructorul fără argument al părintelui clasei (deoarece conține o singură instrucțiune, adică super();) sau    Obiect    constructor de clasă dacă clasa nu are alt părinte (deoarece clasa Object este părintele tuturor claselor fie direct, fie indirect).
 
 
Modalități de a crea un obiect al unei clase
 
Există patru moduri de a crea obiecte în Java. Strict vorbind, există o singură cale (prin folosirea unui    nou    cuvânt cheie), iar restul utilizează intern a    nou    cuvânt cheie.
 
    1. Folosind un cuvânt cheie nou    
 
Este cea mai comună și generală modalitate de a crea un obiect în Java.
 
    Exemplu:    
 
// creating object of class Test Test t = new Test();>
 
    2. Folosind metoda Class.forName(String className).    
 
Există o clasă predefinită în pachetul java.lang cu numele Class. Metoda forName(String className) returnează obiectul Class asociat clasei cu numele șirului dat. Trebuie să dăm un nume complet calificat pentru o clasă. La apelarea noii metode Instance() pe acest obiect Class returnează o nouă instanță a clasei cu numele șirului dat.
 
// creating object of public class Test // consider class Test present in   com.p1   package Test obj = (Test)Class.forName('com.p1.Test').newInstance();>
 
    3. Folosind metoda clone().    
 
Metoda clone() este prezentă în clasa Object. Acesta creează și returnează o copie a obiectului.
 
// creating object of class Test Test t1 = new Test(); // creating clone of above object Test t2 = (Test)t1.clone();>
 
    4. Deserializarea    
 
Deserializarea este o tehnică de citire a unui obiect din starea salvată într-un fișier. A se referi la  Serializare/De-serializare în Java  
 
FileInputStream file = new FileInputStream(filename); ObjectInputStream in = new ObjectInputStream(file); Object obj = in.readObject();>
 
Crearea mai multor obiecte după un singur tip (o practică bună)
 
În timp real, avem nevoie de diferite obiecte ale unei clase în diferite metode. Crearea unui număr de referințe pentru stocarea acestora nu este o practică bună și, prin urmare, declarăm o variabilă de referință statică și o folosim ori de câte ori este necesar. În acest caz, pierderea memoriei este mai mică. Obiectele care nu mai sunt referite vor fi distruse de către Colector de gunoi din Java.
 
Exemplu:
 
Test test = new Test(); test = new Test();>
 
În sistemul de moștenire, folosim o variabilă de referință a clasei părinte pentru a stoca un obiect sub-clasă. În acest caz, putem comuta în diferite obiecte de subclasă folosind aceeași variabilă referită.
 
    Exemplu:    
 
class Animal {} class Dog extends Animal {} class Cat extends Animal {} public class Test { // using Dog object Animal obj = new Dog(); // using Cat object obj = new Cat(); }>
 
Obiecte anonime în Java
 
Obiectele anonime sunt obiecte care sunt instanțiate, dar nu sunt stocate într-o variabilă de referință.
 
 
Sunt folosite pentru apeluri imediate de metodă.
 
Acestea vor fi distruse după apelarea metodei.
 
Sunt utilizate pe scară largă în diferite biblioteci. De exemplu, în bibliotecile AWT, acestea sunt folosite pentru a efectua anumite acțiuni la capturarea unui eveniment (de exemplu, o apăsare de tastă).
 
În exemplul de mai jos, atunci când un buton de tastă (la care se face referire prin btn) este apăsat, pur și simplu creăm un obiect anonim al clasei EventHandler doar pentru a apela metoda handle.
 
 
btn.setOnAction(new EventHandler() { public void handle(ActionEvent event) { System.out.println('Hello World!'); } });>
 
Diferența dintre clasa Java și obiecte
 
Diferențele dintre clasă și obiect în Java sunt următoarele:
 
 
 
 
Clasă
 
 
 
Obiect
 
 
 
 
 
Clasa este schița unui obiect. Este folosit pentru a crea obiecte.
 
Un obiect este o instanță a clasei.
 
 
 
Nu este alocată nicio memorie atunci când o clasă este declarată.
 
Memoria este alocată de îndată ce un obiect este creat.
 
 
 
O clasă este un grup de obiecte similare.
 
Un obiect este o entitate din lumea reală, cum ar fi o carte, o mașină etc.
 
 
 
Clasa este o entitate logică.
 
Un obiect este o entitate fizică.
 
 
 
O clasă poate fi declarată o singură dată.
 
Obiectele pot fi create de mai multe ori conform cerințelor.
 
 
 
Un exemplu de clasă poate fi o mașină.
 
Obiectele mașinii de clasă pot fi BMW, Mercedes, Ferrari etc.