logo

Classi e oggetti in Java

In Java, le classi e gli oggetti sono concetti base della programmazione orientata agli oggetti (OOP) utilizzati per rappresentare concetti ed entità del mondo reale. La classe rappresenta un gruppo di oggetti con proprietà e comportamento simili. Ad esempio, il tipo di animale Cane è una classe mentre viene chiamato un particolare cane Tommy è un oggetto di Cane classe.

In questo articolo discuteremo degli oggetti e delle classi Java e di come implementarli nel nostro programma.



Classi Java

Una classe in Java è un insieme di oggetti che condividono caratteristiche/comportamenti comuni e proprietà/attributi comuni. È un progetto o prototipo definito dall'utente da cui vengono creati gli oggetti. Ad esempio, Student è una classe mentre un particolare studente chiamato Ravi è un oggetto.

Proprietà delle classi Java

  1. La classe non è un'entità del mondo reale. È solo un modello, un progetto o un prototipo da cui vengono creati gli oggetti.
  2. La classe non occupa memoria.
  3. La classe è un gruppo di variabili di diversi tipi di dati e un gruppo di metodi.
  4. Una classe in Java può contenere:
    • Membro dati
    • Metodo
    • Costruttore
    • Classe nidificata
    • Interfaccia

Dichiarazione di classe in Java

  access_modifier     class   <  class_name>{ membro dati; metodo; costruttore; classe annidata; interfaccia; }>

Esempio di classe Java

Giava








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

>

>

Giava




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

>

>

rimuovendo l'ultimo commit git

Giava




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

>

>

Uscita 1

0 null>

Uscita 2

polimorfismo in Java
GeeksForGeeks>

Uscita 3

GeeksForGeeks>

Componenti delle classi Java

In generale, le dichiarazioni di classe possono includere questi componenti, nell'ordine:

  1. Modificatori : Una classe può essere pubblica o avere accesso predefinito (Rif Questo per dettagli).
  2. Parola chiave della classe: La parola chiave class viene utilizzata per creare una classe.
  3. Nome della classe: Il nome dovrebbe iniziare con la lettera iniziale (maiuscola per convenzione).
  4. Superclasse (se presente): Il nome del genitore della classe (superclasse), se presente, preceduto dalla parola chiave extends. Una classe può estendere (sottoclasse) solo un genitore.
  5. Interfacce (se presenti): Un elenco separato da virgole delle interfacce implementate dalla classe, se presenti, precedute dalla parola chiave implements. Una classe può implementare più di un'interfaccia.
  6. Corpo: Il corpo della classe è racchiuso tra parentesi graffe, { }.

I costruttori vengono utilizzati per inizializzare nuovi oggetti. I campi sono variabili che forniscono lo stato della classe e dei suoi oggetti, mentre i metodi vengono utilizzati per implementare il comportamento della classe e dei suoi oggetti.
Esistono vari tipi di classi utilizzate in applicazioni in tempo reale come classi annidate , classi anonime , E espressioni lambda .

Oggetti Java

Un oggetto in Java è un'unità base della programmazione orientata agli oggetti e rappresenta entità della vita reale. Gli oggetti sono le istanze di una classe create per utilizzare gli attributi e i metodi di una classe. Un tipico programma Java crea molti oggetti che, come sai, interagiscono invocando metodi. Un oggetto è composto da:

  1. Stato : È rappresentato dagli attributi di un oggetto. Riflette anche le proprietà di un oggetto.
  2. Comportamento : È rappresentato dai metodi di un oggetto. Riflette anche la risposta di un oggetto con altri oggetti.
  3. Identità : Dà un nome univoco a un oggetto e consente a un oggetto di interagire con altri oggetti.

Esempio di oggetto: cane

Oggetti Java

Gli oggetti corrispondono a cose trovate nel mondo reale. Ad esempio, un programma di grafica può avere oggetti come cerchio, quadrato e menu. Un sistema di acquisto online potrebbe contenere oggetti come carrello, cliente e prodotto.

Nota: Quando creiamo un oggetto che è un tipo di dati non primitivo, viene sempre allocato nella memoria heap.

Dichiarazione di oggetti (chiamata anche creazione di un'istanza di una classe)

Quando viene creato un oggetto di una classe, si dice che la classe sia istanziato . Tutte le istanze condividono gli attributi e il comportamento della classe. Ma i valori di tali attributi, ovvero lo stato, sono unici per ciascun oggetto. Una singola classe può avere un numero qualsiasi di istanze.

Esempio:

Dichiarazione di oggetti Java

Mentre dichiariamo variabili come (nome del tipo;). Ciò notifica al compilatore che utilizzeremo il nome per fare riferimento ai dati il ​​cui tipo è type. Con una variabile primitiva, questa dichiarazione riserva anche la giusta quantità di memoria per la variabile. Pertanto, per le variabili di riferimento, il tipo deve essere rigorosamente il nome di una classe concreta. In generale, noi non posso creare oggetti di una classe astratta o di un'interfaccia.

Dog tuffy;>

Se dichiariamo una variabile di riferimento (tuffy) come questa, il suo valore sarà indeterminato (null) finché non verrà effettivamente creato e assegnato un oggetto. La semplice dichiarazione di una variabile di riferimento non crea un oggetto.

Inizializzazione di un oggetto Java

L'operatore new crea un'istanza di una classe allocando memoria per un nuovo oggetto e restituendo un riferimento a quella memoria. L'operatore new invoca anche il costruttore della classe.

Esempio:

Giava




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

>

>

Produzione

Hi my name is tuffy. My breed,age and color are papillon,5,white>

Inizializza utilizzando il metodo/funzione:

Giava




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

>

>

Produzione

Software name is: Visual studio Software price is: 0.0>

Questa classe contiene un singolo costruttore. Possiamo riconoscere un costruttore perché la sua dichiarazione utilizza lo stesso nome della classe e non ha un tipo restituito. Il compilatore Java differenzia i costruttori in base al numero e al tipo degli argomenti. Il costruttore in Cane la classe accetta quattro argomenti. La seguente istruzione fornisce tuffy, papillon,5 e white come valori per questi argomenti:

aprire il menu delle impostazioni
Dog tuffy = new Dog('tuffy','papillon',5, 'white');>

Il risultato dell'esecuzione di questa istruzione può essere illustrato come:

Allocazione della memoria di oggetti Java

Nota: Tutte le classi hanno almeno uno costruttore. Se una classe non ne dichiara esplicitamente alcuno, il compilatore Java fornisce automaticamente un costruttore senza argomenti, chiamato anche costruttore predefinito. Questo costruttore predefinito chiama il costruttore senza argomenti del genitore della classe (poiché contiene solo un'istruzione, ovvero super();), o il Oggetto costruttore della classe se la classe non ha altri genitori (poiché la classe Object è il genitore di tutte le classi direttamente o indirettamente).

Modi per creare un oggetto di una classe

Esistono quattro modi per creare oggetti in Java. A rigor di termini, c'è solo un modo (usando a nuovo parola chiave) e il resto utilizza internamente a nuovo parola chiave.

1. Utilizzando una nuova parola chiave

È il modo più comune e generale per creare un oggetto in Java.

Esempio:

// creating object of class Test Test t = new Test();>

2. Utilizzo del metodo Class.forName(String className).

Esiste una classe predefinita nel pacchetto java.lang con il nome Class. Il metodo forName(String className) restituisce l'oggetto Class associato alla classe con il nome stringa specificato. Dobbiamo fornire un nome completo per una classe. Chiamando il nuovo metodo Instance() su questo oggetto Classe restituisce una nuova istanza della classe con il nome di stringa specificato.

// creating object of public class Test // consider class Test present in   com.p1   package Test obj = (Test)Class.forName('com.p1.Test').newInstance();>

3. Utilizzo del metodo clone()

Il metodo clone() è presente nella classe Object. Crea e restituisce una copia dell'oggetto.

// creating object of class Test Test t1 = new Test(); // creating clone of above object Test t2 = (Test)t1.clone();>

4. Deserializzazione

La deserializzazione è una tecnica per leggere un oggetto dallo stato salvato in un file. Fare riferimento a Serializzazione/Deserializzazione in Java

FileInputStream file = new FileInputStream(filename); ObjectInputStream in = new ObjectInputStream(file); Object obj = in.readObject();>

Creare più oggetti di un solo tipo (una buona pratica)

In tempo reale, abbiamo bisogno di diversi oggetti di una classe in diversi metodi. Creare un numero di riferimenti per memorizzarli non è una buona pratica e quindi dichiariamo una variabile di riferimento statica e la utilizziamo quando richiesto. In questo caso, lo spreco di memoria è minore. Gli oggetti a cui non si fa più riferimento verranno distrutti dal file Netturbino di Giava.

Esempio:

Test test = new Test(); test = new Test();>

Nel sistema di ereditarietà, utilizziamo una variabile di riferimento della classe genitore per memorizzare un oggetto di sottoclasse. In questo caso, possiamo passare a diversi oggetti sottoclasse utilizzando la stessa variabile referenziata.

Esempio:

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

Oggetti anonimi in Java

Gli oggetti anonimi sono oggetti istanziati ma non archiviati in una variabile di riferimento.

  • Vengono utilizzati per chiamate di metodo immediate.
  • Verranno distrutti dopo la chiamata al metodo.
  • Sono ampiamente utilizzati in diverse biblioteche. Ad esempio, nelle librerie AWT, vengono utilizzati per eseguire alcune azioni sull'acquisizione di un evento (ad esempio la pressione di un tasto).
  • Nell'esempio seguente, quando viene premuto un pulsante chiave (a cui fa riferimento btn), stiamo semplicemente creando un oggetto anonimo della classe EventHandler solo per chiamare il metodo handle.
btn.setOnAction(new EventHandler() { public void handle(ActionEvent event) { System.out.println('Hello World!'); } });>

Differenza tra classe Java e oggetti

Le differenze tra classe e oggetto in Java sono le seguenti:

Classe

Oggetto

La classe è il progetto di un oggetto. Viene utilizzato per creare oggetti. Un oggetto è un'istanza della classe.
Non viene allocata memoria quando viene dichiarata una classe. La memoria viene allocata non appena viene creato un oggetto.
Una classe è un gruppo di oggetti simili. Un oggetto è un'entità del mondo reale come un libro, un'auto, ecc.
La classe è un'entità logica. Un oggetto è un'entità fisica.
Una classe può essere dichiarata solo una volta. Gli oggetti possono essere creati più volte secondo i requisiti.
Un esempio di classe può essere un'auto. Gli oggetti della classe auto possono essere BMW, Mercedes, Ferrari, ecc.