În Java, clasă este un plan din care putem crea un obiect individual. Java oferă o cuvânt cheie denumită clasă prin care putem declara o clasă. În interiorul clasei, definim clasă membrii si functiile. Nu se poate crea programe Java fără clasă. De asemenea, putem referi o clasă ca a definit de utilizator Tipuri de clase
Există șapte tipuri de clase în Java:
Clasa statică
Putem face o clasă static dacă și numai dacă este o clasă imbricată. De asemenea, putem spune că clasele statice sunt cunoscute ca clase imbricate. Înseamnă că o clasă care este declarată ca statică în cadrul unei alte clase este cunoscută ca o clasă statică. Clasa statică imbricată nu necesită referire la clasa exterioară. Scopul unei clase statice este de a oferi conturul clasei sale moștenite.
Proprietățile clasei statice sunt:
- Clasa are doar membri statici.
- Nu poate accesa membrul (nestatic) al clasei exterioare.
- Nu putem crea un obiect din clasa statică.
Să înțelegem conceptul de clasă statică printr-un program.
StaticClassExample.java
public class StaticClassExample { private static String str = 'Javatpoint'; //nested class which is a Static class public static class StaticDemo { //non-static method of Static class public void show() { System.out.println(str); } } public static void main(String args[]) { StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo(); obj.show(); } } Ieșire:
s în python
Javatpoint
În clasa exterioară a programului de mai sus, am declarat o variabilă str ca static deoarece accesăm acea variabilă dintr-un context static. Dacă declarăm acea variabilă ca nestatică, compilatorul arată o eroare deoarece o clasă statică imbricată nu poate accesa membrii nestatici ai clasei exterioare.
Al doilea lucru care trebuie observat în programul de mai sus este că pentru a crea obiectul clasei imbricate nu trebuie să creăm o instanță a clasei exterioare. Dacă clasa imbricată nu este o clasă statică, trebuie să creăm o instanță a clasei exterioare.
Clasa finală
Cuvântul final înseamnă că nu poate fi schimbat. The final clasa în Java poate fi declarată utilizând cuvânt cheie final . Odată ce declarăm o clasă ca finală, valorile rămân aceleași pe tot parcursul programului. Scopul orei finale este de a face clasa imuabil precum clasa String. Este doar o modalitate de a face clasa imuabilă. Amintiți-vă că clasa finală nu poate fi prelungită . De asemenea împiedică clasa să fie subclasată .
Să înțelegem conceptul de clasă finală printr-un program.
FinalClassExample.java
//base class declared as final final class A { void printmsg() { System.out.print('Base class method is executed.'); } } //derived class //extending a final class which is not possible //it shows the error cannot inherit final class at compile time class B extends A { void printmsg() { System.out.print('Derived class method is executed.'); } } //main class public class FinalClassExample { public static void main(String[] arg) { B obj = new B(); obj.printmsg(); } } Ieșire:
/FinalClassExample.java:11: error: cannot inherit from final A class B extends A
Clasa abstracte
Un clasa abstractă este un care este declarat cu cuvântul cheie abstract . Clasa poate conține sau nu metode abstracte. Nu putem crea o instanță a unei clase abstracte, dar poate fi o subclasă. Aceste clase sunt incomplete, așa că pentru a completa clasa abstractă ar trebui să extindem clasele abstracte la o clasă concretă. Când declarăm o subclasă ca abstractă, atunci este necesar să oferim implementarea metodelor abstracte. Prin urmare, subclasa trebuie de asemenea să fie declarată abstractă. Putem realiza ascunderea datelor folosind clasa abstractă. Un exemplu de clasă abstractă este AbstarctMap clasă care face parte din cadrul Collections.
Să înțelegem conceptul de clasă abstractă printr-un program.
AbstractClassExample.java
//abstract class abstract class MathematicalOperations { int a=30, b=40; //abstract method public abstract void add(); } public class Operation extends MathematicalOperations { //definition of abstract method public void add() { System.out.println('Sum of a and b is: 'a+b); } public static void main(String args[]) { MathematicalOperations obj = new Operation(); obj.add(); } } Ieșire:
Sum of a and b is: 70
Clasa de beton
Acestea sunt clasele Java obișnuite. O clasă derivată care oferă implementările de bază pentru toate metodele care nu sunt deja implementate în clasa de bază este cunoscută ca beton clasă. Cu alte cuvinte, sunt clase Java obișnuite în care sunt implementate toate metodele unei clase abstracte. Putem crea direct un obiect din clasa concretă. Amintiți-vă că clasa concretă și clasa abstractă nu sunt aceeași. O clasă concretă își poate extinde clasa părinte. Este folosit pentru cerințe specifice.
Să înțelegem conceptul de clasă concretă printr-un program.
ConcreteClassExample.java
//Concrete Class public class ConcreteClassExample { //method of the concreted class static int product(int a, int b) { return a * b; } public static void main(String args[]) { //method calling int p = product(6, 8); System.out.println('Product of a and b is: ' + p); } } Ieșire:
Product of a and b is: 48
Clasa Singleton
O clasă care are doar un obiect la un moment dat este cunoscută ca a clasa singleton . Totuși, dacă încercăm să creăm o instanță a doua oară, acea instanță nou creată indică prima instanță. Dacă am făcut vreo modificare în interiorul clasei prin orice instanță, modificarea afectează și variabila instanței unice. Este de obicei folosit pentru a controla accesul în timp ce se ocupă cu conexiunea la baza de date și cu programarea socket-ului. Dacă vrem să creăm o clasă singleton, faceți următoarele:
- Creați un privat constructor .
- Creați o metodă statică (prin utilizarea inițializării leneșe) care returnează obiectul clasei singleton.
SingletonClassExample.java
public class Singleton { private String objectState; private static Singleton instance = null; private Singleton() throws Exception { this.objectState = 'Javatpoint'; } public static Singleton getInstance() { if(instance==null) { try { instance=new Singleton(); } catch(Exception e) { e.printStackTrace(); } } return instance; } public String getObjectState() { return objectState; } public void setObjectState(String objectState) { this.objectState = objectState; } } Ieșire:
Javatpoint
Clasa POJO
În Java, POJO înseamnă Obiect Java vechi simplu. O clasă Java care conține doar variabile private, setter și getter este cunoscută ca POJO clasă. Este folosit pentru a defini obiecte Java care măresc reutilizarea și lizibilitatea unui program Java. Clasa oferă încapsulare. Este utilizat pe scară largă în Java deoarece este ușor de înțeles aceste clase. Clasa POJO are următoarele proprietăți:
- Nu extinde clasele predefinite, cum ar fi Arrays, HttpServlet etc.
- Nu poate conține adnotări prespecificate.
- Nu poate implementa predefinite interfețe .
- Nu este necesar să adăugați niciun constructor.
- Toate variabilele de instanță trebuie să fie private.
- Getter/setter metode trebuie să fie public.
Să înțelegem conceptul de clasă POJO printr-un program Java.
PojoClassExample.java
class PojoDemo { //private variable private double price=89764.34; //getter method public double getPrice() { return price; } //setter method public void setPrice(int price) { this.price = price; } } //main class public class PojoClassExample { public static void main(String args[]) { PojoDemo obj = new PojoDemo(); System.out.println('The price of an article is '+ obj.getPrice()+' Rs.'); } } Ieșire:
The price of an article is 89764.34 Rs.
Clasa interioara
Java ne permite să definim o clasă în cadrul unei clase și astfel de clase sunt cunoscute ca clase imbricate . Este folosit pentru a grupa clasele logic și pentru a realiza încapsulare . Membrii clasei exterioare (inclusiv private) pot fi accesați de către clasa interioara . Sintaxa generală pentru declararea clasei imbricate este următoarea:
moștenire în java
class OuterClass { //code class NestedClass { //code } } Clasele imbricate sunt de două tipuri:
1. Clasa imbricată statică: O clasă care este static și cuibărit se numește o clasă imbricată statică. Interacționează cu membrul instanței din clasa sa exterioară. Putem crea un obiect din clasa imbricată statică utilizând următoarea sintaxă:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
2. Clasă imbricată nestatică: Sunt apelate clase imbricate non-statice clasele interioare .
Sintaxa generală pentru declararea clasei imbricate statice și a clasei interioare este următoarea:
class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } Să înțelegem conceptul de clasă interioară printr-un program Java.
InnerClassExample.java
java pentru pauză
public class InnerClassExample { public static void main(String[] args) { System.out.println('This is outer class.'); } class InnerClass { public void printinner() { System.out.println('This is inner class.'); } } } Tipuri de clase interioare
Java oferă cele două tipuri de clase interioare, după cum urmează:
- Clasele locale sau Metoda Clasa interioară locală
- Clasele anonime sau Clasa interioară anonimă
Clasa interioară locală
Este un tip de clasă interioară care este definită în interiorul unui bloc. Aici blocul denotă corpul unei metode (un grup de instrucțiuni închise între o pereche de acolade). Datorită definirii în interiorul unui bloc, este cunoscută și ca metodă de clasă interioară locală. Acestea sunt clasele non-statice deoarece pot accesa membrii instanței blocului. Putem defini clasele interne locale în corpul unei metode. Aceste clase trebuie să fie instanțiate în blocul în care sunt definite.
Când compilam un program Java (un program care conține o clasă internă), compilatorul generează cele două fișiere de clasă și anume clasă.exterioară și OuterInner.class. Unul pentru clasa exterioară și celălalt pentru clasa interioară care conține o referință la clasa exterioară.
Să înțelegem conceptul de clasă interioară locală printr-un program Java.
OuterClass.java
public class OuterClass { private void getValue() { //if you are using Java 7 make the variable final //if you are using Java 8 the code runs successfully int sum = 20; //declaring method local inner class class InnerClass { public int divisor; public int remainder; public InnerClass() { divisor = 4; remainder = sum%divisor; } private int getDivisor() { return divisor; } private int getRemainder() { return sum%divisor; } private int getQuotient() { System.out.println('We are inside the inner class'); return sum / divisor; } } //creating an instance of inner class InnerClass ic = new InnerClass(); System.out.println('Divisor = '+ ic.getDivisor()); System.out.println('Remainder = ' + ic.getRemainder()); System.out.println('Quotient = ' + ic.getQuotient()); } public static void main(String[] args) { //creating an instance of outer class OuterClass oc = new OuterClass(); oc.getValue(); } } Ieșire:
Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5
Clasa interioară anonimă
Este un tip de clasă interioară care este același cu clasele locale, dar singura diferență este că clasa nu are un nume de clasă și este creat un singur obiect al clasei. Face codul mai concis. Este folosit dacă dorim să folosim clasa locală o dată. Putem crea clase anonime în următoarele două moduri:
- Prin utilizarea unei interfețe
- Prin declararea clasei concrete și abstracte
Sintaxă:
// the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; Privind la sintaxa de mai sus, vedem că este aceeași cu invocarea constructorului, cu excepția faptului că clasa are o definiție conținută în bloc.
AnonymousClassExample.java
interface Score { int run = 321; void getScore(); } public class AnonymousClassExample { public static void main(String[] args) { // Myclass is hidden inner class of Score interface // whose name is not written but an object to it // is created. Score s = new Score() { @Override public void getScore() { //prints score System.out.print('Score is '+run); } }; s.getScore(); } } Ieșire:
Score is 321
Java oferă, de asemenea, un alt tip de clasă Java cunoscută sub numele de clasă wrapper. Să o discutăm în detaliu.
Clasa Wrapper
În Java, termenul clasa de ambalare reprezintă o colecție de clase Java care obiectivează tipul primitiv de Java. Înseamnă că pentru fiecare tip primitiv există o clasă wrapper corespunzătoare. Clasele wrapper sunt folosite pentru a efectua conversia de la un tip primitiv la un obiect și invers. Figura următoare demonstrează ierarhia claselor wrapper.
Următorul tabel reprezintă tipul primitiv și clasa wrapper corespunzătoare.
| Tipul primitiv | Clasa Wrapper |
|---|---|
| boolean | boolean |
| int | Întreg |
| char | Caracter |
| dubla | Dubla |
| pluti | Pluti |
| lung | Lung |
| octet | octet |
| mic de statura | Mic de statura |
Să înțelegem clasa wrapper printr-un program Java.
WrapperClassExample.java
public class WrapperClassExample { public static void main(String args[]) { byte x = 0; //wrapping byte primitive type into Byte object Byte byteobj = new Byte(x); int y = 23; //wrapping int primitive type into Integer object Integer intobj = new Integer(y); char c='m'; //wrapping char primitive type into Character object Character charobj=c; //printing values from objects System.out.println('Byte object byteobj: ' + byteobj); System.out.println('Integer object intobj: ' + intobj); System.out.println('Character object charobj: ' + charobj); } } Ieșire:
Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m