In Java zijn klassen en objecten basisconcepten van Object Oriented Programming (OOP's) die worden gebruikt om concepten en entiteiten uit de echte wereld weer te geven. De klasse vertegenwoordigt een groep objecten met vergelijkbare eigenschappen en gedrag. Bijvoorbeeld het diertype Hond is een klasse terwijl een bepaalde hond wordt genoemd Tommy is een voorwerp van de Hond klas.
In dit artikel bespreken we Java-objecten en -klassen en hoe we deze in ons programma kunnen implementeren.
Java-klassen
Een klasse in Java is een reeks objecten die gemeenschappelijke kenmerken/gedrag en gemeenschappelijke eigenschappen/attributen delen. Het is een door de gebruiker gedefinieerde blauwdruk of prototype waaruit objecten worden gemaakt. Student is bijvoorbeeld een klasse, terwijl een bepaalde student met de naam Ravi een object is.
Eigenschappen van Java-klassen
- Klasse is geen echte entiteit. Het is slechts een sjabloon, blauwdruk of prototype waaruit objecten worden gemaakt.
- Klasse neemt geen geheugen in beslag.
- Klasse is een groep variabelen van verschillende gegevenstypen en een groep methoden.
- Een klasse in Java kan het volgende bevatten:
- Gegevens lid
- Methode
- Constructeur
- Geneste klasse
- Koppel
Klassedeclaratie in Java
access_modifier class < class_name>{ gegevenslid; methode; bouwer; geneste klasse; koppel; }> Voorbeeld van Java-klasse
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();> >}> >}> }> |
>
>
wumpus wereld
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();> >}> >}> }> |
>
>
Uitgang 1
0 null>
Uitgang 2
GeeksForGeeks>
Uitgang 3
GeeksForGeeks>
Componenten van Java-klassen
Over het algemeen kunnen klassedeclaraties deze componenten bevatten, in de volgende volgorde:
Java is gelijk aan methode
- Modificatoren : Een klasse kan openbaar zijn of heeft standaardtoegang (zie dit voor details).
- Klasse trefwoord: class trefwoord wordt gebruikt om een klasse te creëren.
- Naam van de klasse: De naam moet beginnen met een beginletter (volgens afspraak met een hoofdletter geschreven).
- Superklasse (indien aanwezig): De naam van de ouder van de klasse (superklasse), indien aanwezig, voorafgegaan door het trefwoord extends. Een klasse kan slechts één ouder uitbreiden (subklasse).
- Interfaces (indien aanwezig): Een door komma's gescheiden lijst met interfaces die door de klasse zijn geïmplementeerd, indien aanwezig, voorafgegaan door het trefwoord implements. Een klasse kan meer dan één interface implementeren.
- Lichaam: De hoofdtekst van de klasse wordt omgeven door accolades, { }.
Constructors worden gebruikt voor het initialiseren van nieuwe objecten. Velden zijn variabelen die de status van de klasse en zijn objecten aangeven, en methoden worden gebruikt om het gedrag van de klasse en zijn objecten te implementeren.
Er zijn verschillende soorten klassen die worden gebruikt in realtime toepassingen, zoals geneste klassen , anonieme lessen , En lambda-uitdrukkingen .
Java-objecten
Een object in Java is een basiseenheid van objectgeoriënteerd programmeren en vertegenwoordigt entiteiten uit het echte leven. Objecten zijn de instanties van een klasse die zijn gemaakt om de attributen en methoden van een klasse te gebruiken. Een typisch Java-programma maakt veel objecten, die, zoals u weet, op elkaar inwerken door methoden aan te roepen. Een object bestaat uit:
- Staat : Het wordt weergegeven door attributen van een object. Het weerspiegelt ook de eigenschappen van een object.
- Gedrag : Het wordt weergegeven door de methoden van een object. Het weerspiegelt ook de reactie van een object met andere objecten.
- Identiteit : Het geeft een unieke naam aan een object en zorgt ervoor dat een object kan communiceren met andere objecten.
Voorbeeld van een object: hond
Java-objecten
Objecten komen overeen met dingen die in de echte wereld worden gevonden. Een grafisch programma kan bijvoorbeeld objecten hebben zoals een cirkel, vierkant en menu. Een online winkelsysteem kan objecten bevatten zoals winkelwagen, klant en product.
Opmerking: Wanneer we een object maken dat een niet-primitief gegevenstype is, wordt het altijd toegewezen aan het heapgeheugen.
Objecten declareren (ook wel het instantiëren van een klasse genoemd)
Wanneer een object van een klasse wordt gemaakt, wordt gezegd dat de klasse dat is geïnstantieerd . Alle instanties delen de attributen en het gedrag van de klasse. Maar de waarden van die attributen, dat wil zeggen de staat, zijn uniek voor elk object. Een enkele klasse kan een willekeurig aantal instanties hebben.
Voorbeeld:
Java-objectdeclaratie
Terwijl we variabelen declareren zoals (typenaam;). Dit laat de compiler weten dat we de naam zullen gebruiken om te verwijzen naar gegevens waarvan het type type is. Bij een primitieve variabele reserveert deze declaratie ook de juiste hoeveelheid geheugen voor de variabele. Voor referentievariabelen moet het type dus strikt een concrete klassenaam zijn. Over het algemeen wij kan niet maak objecten van een abstracte klasse of een interface.
Dog tuffy;>
Als we een referentievariabele (tuffy) op deze manier declareren, zal de waarde ervan onbepaald (null) zijn totdat er daadwerkelijk een object wordt gemaakt en eraan wordt toegewezen. Door simpelweg een referentievariabele te declareren, ontstaat er geen object.
Een Java-object initialiseren
De nieuwe operator instantiëert een klasse door geheugen toe te wijzen aan een nieuw object en een verwijzing naar dat geheugen terug te geven. De nieuwe operator roept ook de klasseconstructor aan.
Voorbeeld:
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());> >}> }> |
>
>Uitvoer
Hi my name is tuffy. My breed,age and color are papillon,5,white>
Initialiseren met behulp van methode/functie:
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();> >}> }> |
>
>Uitvoer
Software name is: Visual studio Software price is: 0.0>
Deze klasse bevat één enkele constructor. We kunnen een constructor herkennen omdat de declaratie dezelfde naam gebruikt als de klasse en geen retourtype heeft. De Java-compiler onderscheidt de constructors op basis van het aantal en het type argumenten. De constructeur in de Hond klasse heeft vier argumenten. De volgende verklaring geeft tuffy, papillon,5 en white als waarden voor deze argumenten:
Dog tuffy = new Dog('tuffy','papillon',5, 'white');> Het resultaat van het uitvoeren van deze instructie kan als volgt worden geïllustreerd:
Geheugentoewijzing van Java-objecten
ingesteld in Java
Opmerking: Alle klassen hebben er tenminste een bouwer. Als een klasse deze niet expliciet declareert, levert de Java-compiler automatisch een constructor zonder argumenten, ook wel de standaardconstructor genoemd. Deze standaardconstructor roept de constructor zonder argumenten van de klasse-ouder aan (aangezien deze slechts één instructie bevat, namelijk super();), of de Voorwerp klasseconstructor als de klasse geen ander ouder heeft (aangezien de klasse Object direct of indirect de ouder is van alle klassen).
Manieren om een object van een klasse te maken
Er zijn vier manieren om objecten in Java te maken. Strikt genomen is er maar één manier (door gebruik te maken van een nieuw trefwoord), en de rest gebruikt intern a nieuw trefwoord.
1. Nieuw trefwoord gebruiken
Het is de meest gebruikelijke en algemene manier om een object in Java te maken.
Voorbeeld:
// creating object of class Test Test t = new Test();>
2. Gebruik de methode Class.forName(String className).
Er is een vooraf gedefinieerde klasse in het java.lang-pakket met de naam Class. De methode forName(String className) retourneert het Class-object dat is gekoppeld aan de klasse met de opgegeven tekenreeksnaam. We moeten een volledig gekwalificeerde naam voor een klasse opgeven. Bij het aanroepen van de nieuwe Instance()-methode op dit Class-object wordt een nieuw exemplaar van de klasse geretourneerd met de opgegeven tekenreeksnaam.
// creating object of public class Test // consider class Test present in com.p1 package Test obj = (Test)Class.forName('com.p1.Test').newInstance();> 3. Gebruik de clone()-methode
clone() methode is aanwezig in de Object klasse. Er wordt een kopie van het object gemaakt en geretourneerd.
// creating object of class Test Test t1 = new Test(); // creating clone of above object Test t2 = (Test)t1.clone();>
4. Deserialisatie
De-serialisatie is een techniek om een object te lezen vanuit de opgeslagen status in een bestand. Verwijzen naar Serialisatie/de-serialisatie in Java
FileInputStream file = new FileInputStream(filename); ObjectInputStream in = new ObjectInputStream(file); Object obj = in.readObject();>
Meerdere objecten maken van slechts één type (een goede gewoonte)
In realtime hebben we verschillende objecten van een klasse op verschillende manieren nodig. Het aanmaken van een aantal referenties om ze op te slaan is geen goede gewoonte en daarom declareren we een statische referentievariabele en gebruiken we deze wanneer dat nodig is. In dit geval is de geheugenverspilling minder. De objecten waarnaar niet meer wordt verwezen, worden vernietigd door de Vuilnisman van Java.
Voorbeeld:
Test test = new Test(); test = new Test();>
In het overervingssysteem gebruiken we een referentievariabele van de ouderklasse om een subklasseobject op te slaan. In dit geval kunnen we overschakelen naar verschillende subklasse-objecten met behulp van dezelfde variabele waarnaar wordt verwezen.
Voorbeeld:
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(); }> Anonieme objecten op Java
Anonieme objecten zijn objecten die zijn geïnstantieerd maar niet zijn opgeslagen in een referentievariabele.
- Ze worden gebruikt voor directe methodeaanroepen.
- Ze worden vernietigd na het aanroepen van de methode.
- Ze worden veel gebruikt in verschillende bibliotheken. In AWT-bibliotheken worden ze bijvoorbeeld gebruikt om een actie uit te voeren bij het vastleggen van een gebeurtenis (bijvoorbeeld een toetsaanslag).
- In het onderstaande voorbeeld, wanneer een sleutelknop (waarnaar wordt verwezen door de btn) wordt ingedrukt, maken we eenvoudigweg een anoniem object van de klasse EventHandler om alleen de handle-methode aan te roepen.
btn.setOnAction(new EventHandler() { public void handle(ActionEvent event) { System.out.println('Hello World!'); } });> Verschil tussen Java-klasse en objecten
De verschillen tussen klasse en object in Java zijn als volgt:
| Klas | Voorwerp |
|---|---|
| Klasse is de blauwdruk van een object. Het wordt gebruikt om objecten te maken. | Een object is een instantie van de klasse. |
| Er wordt geen geheugen toegewezen wanneer een klasse wordt gedeclareerd. | Er wordt geheugen toegewezen zodra een object wordt aangemaakt. |
| Een klasse is een groep vergelijkbare objecten. | Een object is een entiteit uit de echte wereld, zoals een boek, een auto, enz. |
| Klasse is een logische entiteit. | Een object is een fysieke entiteit. |
| Een klasse kan slechts één keer worden gedeclareerd. | Objecten kunnen naar behoefte vele malen worden gemaakt. |
| Een voorbeeld van klasse kan een auto zijn. | Objecten van de klasseauto kunnen BMW, Mercedes, Ferrari, enz. zijn. |