types classes java
Acest tutorial va discuta diferite tipuri de clase în Java, cum ar fi Abstract, Concrete, Final, Inner, POJO, Static și alte clase speciale, cu exemple:
În tutorialul nostru anterior, am discutat despre cursuri și obiecte în Java. O clasă în Java este un șablon sau plan. Poate fi definit și ca o colecție de obiecte similare. Definim obiecte din clasa de tip și apoi comunicăm prin intermediul acestor obiecte.
Fiecare obiect este o instanță a unei clase care are o stare și un comportament.
=> Vizitați aici pentru seria exclusivă de instruiri Java.
Ce veți învăța:
Tipuri de clase în Java - Introducere
Știm cu toții că clasa are următoarele componente:
- Modificatori: Specificați accesul pentru clasă.
- Numele clasei: Numele clasei.
- Cuvinte cheie: Cuvinte cheie care sugerează dacă o clasă extinde sau implementează clasa sau interfața.
- Clasa Corp cuprinsă între paranteze cretate {}
În funcție de diferiții modificatori utilizați, corpul clasei specificat și cuvintele cheie utilizate, avem diferite tipuri de clase în Java.
Implementarea funcției hash c ++
- Clasa de beton: O clasă normală care are implementarea concretă a metodelor.
- Clasa POJO: Acesta este „Plain Old Java Object” care conține numai variabile private și metode getter setter pentru a accesa aceste variabile.
- Clasa abstractă: Această clasă are una sau mai multe metode abstracte.
- Clasa finală: O clasă finală nu poate fi moștenită.
- Clasa statică: O clasă care conține doar membri statici.
- Clasa interioară: O clasă interioară este o clasă care face parte dintr-o altă clasă.
În acest tutorial, vom discuta fiecare dintre aceste tipuri de clase cu exemple.
De asemenea, vom discuta despre alte tipuri de clase care sunt considerate clase speciale în Java.
- Clasa anonimă: O clasă fără nici un nume.
- Clasa imuabilă: O clasă al cărei obiect nu poate fi schimbat.
- Clasa Singleton: O clasă a cărei instanță unică poate fi creată.
- Clasa obiectului: Clasa de bază a tuturor caracteristicilor Java.
- Clasa de împachetare: Fiecare tip de date primitive din Java are o clasă de împachetare.
Dar, mai întâi, să discutăm pe scurt cum să importăm o clasă în Java împreună cu clasa Main din Java care conține metoda principală sau punctul de plecare în Java.
Importați în Java
În Java, dacă dorim să includem orice funcție sau funcționalitate în programul nostru, atunci putem folosi declarația „import”. Folosind declarația de import, putem importa un pachet întreg și putem utiliza funcționalitatea acestuia în programul nostru sau putem include, de asemenea, o singură clasă.
Mai jos este sintaxa declarației de import.
import packageName/classname; Dacă dorim să importăm pachetul java.lang și toate clasele sale, atunci putem scrie următoarea declarație:
import java.lang.*; Să presupunem că dorim să includem funcționalitatea clasei Arrays în programul nostru, atunci putem scrie următoarea afirmație:
import java.util.Arrays; Declarația de import este echivalentă cu declarația C / C ++ include. Declarația de import este plasată la începutul programului Java ca prima declarație. Putem avea mai multe declarații în programul Java.
Clasa principală în Java
Suntem deja conștienți de faptul că în Java, metoda main () este punctul de plecare al oricărei execuții a programului și poate fi plasată în orice clasă a acelei aplicații. Cu toate acestea, dacă avem o aplicație complexă cu prea multe fișiere și clase, atunci este recomandabil să aveți o clasă Main și să plasați metoda main () în această clasă Main.
class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } } Rețineți că JVM nu creează un obiect din clasa Main. Logica din spatele acestui lucru este că, deoarece main () este o metodă statică, poate fi apelată fără niciun obiect de clasă.
Tipuri de clase în Java
Acum să trecem la tipurile de clase din Java. Vom explica fiecare dintre aceste clase pe rând urmate de exemplele de programare.
# 1) Clasa de beton
O clasă concretă este orice clasă normală dintr-un program Java. Această clasă nu va avea metode abstracte. Toate metodele din clasa concretă sunt complet implementate.
O clasă concretă poate moșteni de la o altă clasă, chiar o clasă abstractă sau poate implementa o interfață. Putem instanția clasa concretă și crearea obiectelor sale.
Un exemplu simplu de clasă concretă este prezentat mai jos.
public class Main { // Concrete Class example static int total(int val1, int val2) { return val1 + val2; } public static void main(String args()) { int sum = total(100, 108); System.out.println('Total of two integers: ' + sum); } } Ieșire
Programul de mai sus prezintă o clasă concretă. Vedem că această clasă are o implementare completă. Nu rămâne nimic incomplet sau neimplementat.
# 2) Clasa POJO
Un POJO (Plain Old Java Object) este o clasă care conține doar variabile private. În afară de variabilele de membru privat, acesta conține doar metode getter și setter utilizate de aceste variabile de membru.
O clasă POJO nu are comportamentul său. Cu toate acestea, poate suprascrie unele metode, cum ar fi egale sau interfețe.
Proprietățile clasei POJO:
- Clasa POJO trebuie să aibă o metodă publică getter și setter.
- Toți membrii sau variabilele de instanță ar trebui să fie private.
- Clasa POJO nu extinde sau implementează clase sau interfețe care sunt pre-specificate.
- Nu conțin adnotări care sunt pre-specificate.
- Nu are un constructor fără argumente (constructor fără argumente).
Mai jos este prezentat un program Java care demonstrează clasa POJO.
//declare a POJO class class POJO_Class { private int daysOfWeek=7; //private variable public int getdaysOfWeek() { //getter return daysOfWeek; } public void setdaysOfWeek(int dow) { //setter this.daysOfWeek = dow; } } public class Main { public static void main(String args()){ POJO_Class pojoDemo = new POJO_Class(); //instance of POJO class System.out.println('Days of the week:' + pojoDemo.getdaysOfWeek()); } } Ieșire
Demonstrația de mai sus a clasei POJO arată că are o variabilă privată și metodele getter setter pentru această variabilă. Pentru a accesa această variabilă de membru, folosim metoda getter. Metoda setter este utilizată pentru a actualiza valoarea.
# 3) Clasa abstractă
O clasă abstractă este o clasă care este incompletă sau a cărei implementare nu este finalizată. O clasă abstractă nu poate fi instanțiată. Trebuie extins de celelalte clase și să-și implementeze metodele pentru a forma o clasă concretă.
O clasă abstractă este declarată utilizând cuvântul cheie „abstract”. O clasă abstractă poate avea metode statice și finale, precum și constructori.
Să demonstrăm o clasă abstractă în Java.
interface multiply //interface multiply { int product(int num1, int num2); } // abstract class abstract class Product implements multiply { // this is an abstract method to calculate product of two numbers public abstract int product(int num1, int num2); } // Concrete class :this will implement the abstract method above class Main extends Product { public int product(int num1, int num2) { return num1*num2; } // main method public static void main(String args()) { Main obj = new Main(); int prod = obj.product(100, 20); // print product System.out.println('Product of two numbers: ' + prod); } }Ieșire
În programul de mai sus, avem o interfață multiplică. Creăm o clasă abstractă Produs care implementează o interfață multiplică. În interiorul produsului, avem o metodă de produs care nu este implementată. Apoi avem o clasă principală care moștenește clasa de produs și implementează metoda produsului. Mai târziu, numim această metodă pe obiectul clasei Main.
# 4) Clasa statică
O statică în Java înseamnă, în general, obiectul care aparține unei clase și nu instanțelor individuale. Deci, un membru static sau o metodă în Java nu trebuie accesată cu un obiect, ci direct folosind un nume de clasă.
O clasă statică în Java poate conține numai membri statici. De asemenea, nu putem instanția o clasă statică.
Următorul program Java demonstrează o clasă statică.
class Static_Class { static int total; // static variable static void sum(int val1, int val2) { // static method System.out.print('Static method to calculate sum:' + ' '); total = val1 + val2; System.out.println(val1 + '+' + val2); // print the numbers } static class Nested_Class { // static class static { // static block System.out.println('static block inside a static nested class'); } public void displaySum() { sum(25, 75); // call static method // print the value in static variable total, it holds the sum of two numbers System.out.println('Sum of two numbers:' + total); } } } public class Main { public static void main(String args()) { // declare static class object Static_Class.Nested_Class object = new Static_Class.Nested_Class(); object.displaySum(); // call displaySum method inside a static class } } Ieșire
Clasa de mai sus demonstrează clasa statică. Aici avem o clasă statică care face parte dintr-o altă clasă concretă. În interiorul clasei statice, calculăm suma a două numere și stocăm rezultatul într-o variabilă statică care este un membru al clasei exterioare.
# 5) Clasa finală
O clasă finală este o clasă care nu poate fi moștenită sau subclasată. Odată ce o clasă este declarată finală în Java, aceasta este un fel de constantă și devine imuabilă.
Prin urmare, pentru a face o clasă imuabilă, trebuie să o declarăm definitivă.
//final class final class Base_Class { void Display() { System.out.println('Base_Class::Display()'); } } //class Derived_Class extends Base_Class { //Compile-time error - can't inherit final class class Derived_Class{ void Display() { System.out.println('Derived_Class::Display()'); } } public class Main { public static void main(String() arg) { Base_Class base_obj = new Base_Class(); //create a final class object base_obj.Display(); Derived_Class deri_obj = new Derived_Class(); deri_obj.Display(); } } Ieșire
Programul de mai sus declară mai întâi un Base_Class care este marcat ca „final”. Prin urmare, atunci când încercăm să-l extindem în Derived_Class, vom primi o eroare de compilator. (Linia comentată). Dar îi putem crea obiectul și putem apela metoda Afișare.
# 6) Clasa imbricată / Clasa interioară
Clasa imbricată, cunoscută și sub numele de clasă interioară în Java, este utilizată pentru a îmbunătăți încapsularea. O clasă imbricată / clasa interioară este o clasă închisă într-o altă clasă.
La fel cum o clasă are variabile și metode ca membri, poate avea și o clasă interioară ca membru.
O clasă imbricată are următoarea structură:
class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… } Clasele interioare au următoarele subtipuri:
- Clasa interioară cuibărită
- Metoda Clasa interioară locală
- Clasa interioară anonimă
- Clasa imbricată static
# 1) Clasa interioară imbricată
O clasă interioară imbricată are acces la variabilele membre private ale unei clase exterioare. De asemenea, putem aplica modificatori de acces clasei interioare imbricate.
# 2) Metoda Clasa interioară locală
Aceasta este clasa interioară declarată în interiorul unei metode de clasă exterioară.
# 3) Clasa interioară anonimă
Clasa interioară anonimă este o clasă interioară declarată în interiorul unei clase exterioare și nu are nici un nume.
# 4) Clasa imbricată static
Modul în care o clasă are o variabilă de membru static, poate avea și o clasă statică ca membru.
Un exemplu de clasă imbricată / interioară este dat mai jos:
public class Main { //nested/inner class enclosed inside Main class. class InnerClass { public void inner_print() { System.out.println('Inner class'); } } public static void main(String() args) { System.out.println('Main in Outer class'); } } Ieșire
Alte clase speciale în Java
Clasa imuabilă în Java
O clasă imuabilă generează obiecte imuabile. Un obiect imuabil este un obiect al cărui conținut nu poate fi schimbat odată ce obiectul este creat. Deci, o clasă imuabilă este cea al cărei obiect nu poate fi schimbat odată creat.
Toate clasele de împachetare în Java pentru tipurile primitive (Integer, Boolean, Byte etc.) sunt imuabile. Clasa String este, de asemenea, imuabilă.
De asemenea, putem avea clase Java imuabile definite de utilizator.
Pentru ca o clasă să fie imuabilă, trebuie declarată definitivă împreună cu toți membrii săi de date. De asemenea, clasa ar trebui să aibă un constructor parametrizat. Toate variabilele membre ar trebui să aibă o metodă getter, dar nu o metodă setter.
Toate cerințele de mai sus trebuie îndeplinite pentru ca o clasă să fie imuabilă.
Să implementăm un program Java pentru a demonstra clasa imuabilă.
final class City { final String city_name; final int cityId; //parameterised constructor public City(String name, int id) { this.city_name = name; this.cityId = id; } //getters for member variables public String getcityName() { return city_name; } public int getcityId() { return cityId; } } // Driver class class Main { public static void main(String args()) { City city = new City('New York', 1001); System.out.print('City Id:' + city.getcityId() + ' '); System.out.println('City Name:' + city.getcityName()); //city.cityId = 1002; //cannot assign a value to final variable regNo } } Ieșire
În programul de mai sus, am declarat clasa Oraș. Aceasta este o clasă finală și în această clasă, am declarat două variabile membre și un constructor parametrizat. De asemenea, am declarat metode getter pentru aceste două variabile membre. Deci, clasa City îndeplinește toate cerințele unei clase imuabile.
Rețineți linia de cod comentată în metoda principală. Dacă decomentăm această linie, atunci vom primi o eroare de compilator (furnizată în comentariul de aici) deoarece încercăm să setăm valoarea pentru o variabilă membru.
Singleton Class În Java
O clasă singleton permite o singură instanță la un moment dat. În Java, un singleton este un model de proiectare. Acest model de proiectare asigură existența unei singure instanțe a unei clase în orice moment al timpului. Deci, orice clasă definită ca singleton are un singur punct de acces și este globală.
Rețineți că încheierea ciclului de viață al aplicației nu distruge o clasă singleton ca clasele normale. Când o clasă este declarată singleton, atunci nu creăm o instanță nouă de fiecare dată când se face o nouă cerere pentru obiect.
Aceeași instanță este utilizată din nou și din nou. În acest fel putem economisi spațiul de memorie mai ales în cazul aplicațiilor cu mai multe fire și baze de date.
Putem folosi o clasă single pentru activități precum stocarea în cache, înregistrarea în jurnal etc.
Următorul program demonstrează o clasă Singleton.
class Singleton { // static variable of type Singleton private static Singleton single_instance = null; // String variable public String str; // private constructor : restricted to this class private Singleton() { str = 'Singleton class::private constructor'; } // create instance of Singleton class using getInstance static method public static Singleton getInstance() { if (single_instance == null) single_instance = new Singleton(); return single_instance; } } class Main { public static void main(String args()) { // instantiate Singleton class with obj1 Singleton obj1 = Singleton.getInstance(); // instantiate Singleton class with obj2 Singleton obj2 = Singleton.getInstance(); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); // change variable of instance obj1 obj1.str = (obj1.str).toUpperCase(); System.out.println('
After changing obj1(str):'); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); } } Ieșire
cum se utilizează selectorul CSS în seleniu
În programul de mai sus, am definit o clasă singleton cu un constructor privat. Am definit o variabilă membru de tip String. În metoda principală, declarăm două instanțe ale clasei singleton. Apoi schimbăm variabila String folosind una dintre instanțe.
Când tipărim valoarea String pentru ambele instanțe, observăm că valoarea variabilei String s-a modificat pentru ambele instanțe. Prin urmare, chiar dacă am schimbat valoarea doar pentru o singură instanță, datorită clasei singleton, modificările se reflectă în toate instanțele.
Întoarcem întotdeauna aceeași instanță, chiar dacă parem să creăm instanțe diferite.
Clasa obiectului în Java
Clasa Object este clasa părinte sau prima clasă din Java. Este la cel mai înalt nivel al ierarhiei Java.
Deoarece toate clasele au clasa Object ca superclasă, toate obiectele Java inclusiv Arrays implementează metodele clasei Object. Clasa obiect este prezentă în pachetul „java.lang”.
Declarația pentru java.lang.Object este:
public class Obiect
Tabelul următor descrie constructorii și metodele clasei Object.
| Constructor / Metoda | Descriere |
|---|---|
| Clasa getClass () | Returnează clasa de execuție a obiectului. |
| Constructor de clase de obiecte | |
| Obiect() | Constructor de clase de obiecte |
| Metode de clasă obiect | |
| clona obiect protejat () | Returnează o clonă sau o copie a obiectului. |
| boolean este egal (obiect obiect) | Verifică dacă un obiect dat este egal cu acest obiect. |
| nul protejat finaliza () | Apelat de colectorul de gunoi atunci când toate referințele la obiect sunt distruse. |
| int hashCode () | Returnează codul hash pentru obiect. |
| notificare nulă () | Folosiți pentru a trezi un singur fir de așteptare. |
| notificare nulăToate () | Trezește toate firele de așteptare. |
| String toString () | Returnează echivalentul șirului obiectului. |
| nul aștepta () | Face un fir de așteptare până când este trezit prin metoda de notificare de către un alt fir. |
| așteptare nulă (expirare lungă) | Face ca firul să aștepte până la expirarea timpului dat de „timeout” sau când este trezit prin notificare sau notificare Toate metodele. |
| așteptare nulă (expirare lungă, int nanos) | Face ca firul să aștepte până la expirarea timpului specificat sau până când notification () sau notificationAll () este invocat de un alt thread. |
Să implementăm un exemplu de program Java care să demonstreze unele dintre metodele clasei Object.
public class Main { public static void main(String() args) { Main t = new Main(); System.out.println('Main class Object HashCode:' + t.hashCode()); t = null; // call garbage collector System.gc(); System.out.println('Main class:End'); } @Override protected void finalize() { System.out.println('Main Class::finalize method called.'); } } Ieșire
Aici avem o clasă Main. În metoda principală () creăm un obiect din clasa Main. Acest obiect este un descendent al clasei Object și acceptă toate metodele clasei Object. Astfel, folosim acest obiect și apelăm câteva metode de clasă Object, cum ar fi hashCode (), System.GC (), finalize () etc.
Clasa Wrapper În Java
Java oferă o caracteristică numită clasă wrapper care are un mecanism care convertește tipul de date primitiv în obiect și invers. Clasele Wrapper sunt clasele care reprezintă tipuri primitive precum int, char etc. ca obiecte.
Astfel, fiecare tip de date primitive din Java are clasa sa de împachetare corespunzătoare.
Tabelul următor prezintă tipurile de date primitive și clasa lor de împachetare echivalentă.
| Tipul primitiv | Tipul ambalajului |
|---|---|
| pluti | Pluti |
| boolean | Boolean |
| char | Caracter |
| octet | Octet |
| mic de statura | Mic de statura |
| int | Întreg |
| lung | Lung |
| dubla | Dubla |
Pentru a converti primitivele în obiecte și obiecte în primitive, avem tehnici numite „autoboxing” și respectiv „box”. Ase Java este un limbaj de programare orientat pe obiecte, ne ocupăm întotdeauna de obiecte și avem, de asemenea, o mulțime de caracteristici precum Colecții, Serializare , etc., care au nevoie și de obiecte și tipuri primitive.
Deci, este imperativ să avem întotdeauna nevoie de obiecte și tipuri primitive în Java și, prin urmare, să necesităm aceste tehnici de autoboxing și unboxing.
Autoboxing
Autoboxing-ul este o tehnică de conversie automată a unui tip de date primitiv într-un obiect din clasa sa de împachetare corespunzătoare. De exemplu , conversia int în clasa Integer, char în clasa Character etc. sunt cazuri de autoboxing.
Notă: Clasele Wrapper folosesc metoda valueOf () pentru a converti primitivul în obiecte depreciate de la Java 5.
Deconectare
Conversia inversă a obiectelor din clasa wrapper în tipurile lor de date primitive corespunzătoare se numește „unboxing”.
Notă: De la Java 5, metoda intValue () care convertește obiectul wrapper într-un tip primitiv este depreciată.
Dat mai jos este un exemplu de box / unboxing.
public class Main { public static void main(String args()){ //Convert int to Integer : boxing int num=20; Integer int_class= Integer.valueOf(num);//explicit conversion from int to Integer Integer inum=num;//autoboxing System.out.println('int => Integer: ' + num+' => '+inum); //Convert Integer to int: unboxing Integer val=new Integer (3); int ival=val.intValue();//explicit conversion from Integer to int int jval=val;//unboxing System.out.println('Integer => int:' + val+' => '+jval); } } Ieșire
Programul de mai sus prezintă autoboxing și unboxing pe valoarea int. Mai întâi, convertim int în obiect întreg și apoi un obiect întreg este convertit în tipul de date int.
Să implementăm un program care să demonstreze clasele de împachetare prezente în Java.
public class Main { public static void main(String args()) { byte bbyte=10; short sshort=20; int iint=300; long llong=400; float ffloat=3.14F; double ddouble=77.2D; char cchar='A'; boolean bboolean=true; //Convert primitives into objects => Autoboxing Byte byteobj=bbyte; Short shortobj=sshort; Integer intobj=iint; Long longobj=llong; Float floatobj=ffloat; Double doubleobj=ddouble; Character charobj=cchar; Boolean boolobj=bboolean; //Print converted objects System.out.println('Primitives converted to Objects:'); System.out.println('Byte object: '+byteobj); System.out.println('Short object: '+shortobj); System.out.println('Integer object: '+intobj); System.out.println('Long object: '+longobj); System.out.println('Float object: '+floatobj); System.out.println('Double object: '+doubleobj); System.out.println('Character object: '+charobj); System.out.println('Boolean object: '+boolobj); //Convert Objects to Primitives => Unboxing byte bytevalue=byteobj; short shortvalue=shortobj; int intvalue=intobj; long longvalue=longobj; float floatvalue=floatobj; double doublevalue=doubleobj; char charvalue=charobj; boolean boolvalue=boolobj; //Print primitives System.out.println('Converting Objects to Primitives'); System.out.println('byte value: '+bytevalue); System.out.println('short value: '+shortvalue); System.out.println('int value: '+intvalue); System.out.println('long value: '+longvalue); System.out.println('float value: '+floatvalue); System.out.println('double value: '+doublevalue); System.out.println('char value: '+charvalue); System.out.println('boolean value: '+boolvalue); } } Ieșire
Ieșirea programului de mai sus arată conversia de la tipuri primitive la obiecte wrapper (Autoboxing) și inversează conversia de la obiecte wrapper la tipuri primitive (unboxing).
întrebări frecvente
Q # 1) Care este tipul de date de clasă în Java?
Răspuns: Java oferă o clasă numită „Clasă” care conține informații despre toate clasele, obiectele și interfețele aplicației care rulează. Clasa Class reprezintă, de asemenea, tipuri de date primitive și tipul de gol.
Clasa Class face parte din pachetul java.lang.
Q # 2) Care este clasa normală în Java?
Răspuns: O clasă normală în Java este o clasă nestatică. Putem crea obiecte dintr-o clasă normală folosind noul cuvânt cheie. De asemenea, orice clasă normală poate avea ca membru o altă clasă. În acest caz, clasa membru se numește clasă imbricată sau clasă interioară, iar clasa de închidere se numește clasă exterioară.
Q # 3) Șirul este o clasă Wrapper în Java?
Răspuns: Nu, String nu este o clasă de împachetare în Java. Pentru ca o clasă să fie o clasă de împachetare, avem nevoie de tipul primitiv corespunzător. De exemplu, pentru clasa Wrapper Integer avem tip primitiv int. Pentru clasa String, nu avem un tip de date primitiv corespunzător.
Q # 4) Care este beneficiul clasei Wrapper?
Răspuns: Clasele Wrapper sunt utilizate pentru conversia tipurilor de date primitive în obiecte. Cu alte cuvinte, clasele de împachetare împachetează tipurile primitive în obiecte. Clasele Wrapper sunt folosite atunci când anumite caracteristici Java, cum ar fi Colecțiile, așteaptă doar obiecte și nu tipuri de date primitive.
Q # 5) De ce se folosește Singleton Class în Java?
Răspuns: Ori de câte ori dorim un punct de acces global pentru un anumit obiect, mergem pentru un model de singleton care ne permite să proiectăm o clasă de singleton în care va exista o singură instanță. Clasele Singleton sunt utilizate în cache-uri, pool-uri de fire, aplicații de baze de date, logare etc.
Concluzie
În acest tutorial, am acoperit diferitele tipuri de clase utilizate în Java. Am văzut tipurile de clase concrete, abstracte, finale, statice, cuibărite, POJO etc. În afară de aceasta, am discutat și clasele Singleton, clasele Immutable și am discutat și exemplele lor de implementare.
De asemenea, am acoperit clasele de împachetări și clasele de obiecte în Java. Clasele Wrapper sunt clasele care împachetează tipurile de date primitive ale Java în obiecte. Clasa obiect în Java este superclasa tuturor celorlalte clase. Este cea mai înaltă clasă din ierarhia Java.
Întrebări și răspunsuri pentru interviuri cu serverul ms sql
Acum că am discutat despre clasele și obiectele din Java și despre tipurile de clase, în următorul tutorial vom continua cu o discuție detaliată despre constructorii din Java.
=> Consultați aici Ghidul perfect de instruire Java.
Lectură recomandată
- Interfață Java și tutorial de clasă abstractă cu exemple
- Noțiuni de bază Java: Sintaxă Java, Java Class și concepte de bază Java
- Ce este cuvântul cheie static în Java?
- Java Integer și Java BigInteger Class cu exemple
- Tutorial de clasă Java Scanner cu exemple
- Obiect Java Class Vs - Cum se utilizează clasa și obiectul în Java
- Tutorial Java Array Class - java.util.Arrays Class cu exemple
- Ce este Java Vector | Tutorial Java Vector Class cu exemple