CIAO! Oggi parleremo di classi in Java. Si potrebbe dire che le classi costituiscono la pietra angolare della programmazione Java. Quando diventi un programmatore, quasi tutto il tuo lavoro sarà scrivere le tue classi che hanno varie funzioni. Vediamo cosa significa e come funziona. :) Come sai, Java è un linguaggio di programmazione orientato agli oggetti. Tutti i programmi sono costituiti da oggetti che in un modo o nell'altro sono correlati tra loro. Una classe è, essenzialmente, un modello per un oggetto. Determina come sarà l'oggetto e quali funzioni avrà. Ogni oggetto è un oggetto di qualche classe. Considera questo esempio molto semplice:
public class Cat {
String name;
int age;
}
Diciamo che stiamo scrivendo un programma che coinvolge i gatti per qualche motivo (ad esempio, abbiamo una clinica veterinaria che offre l'accesso a un account online). Abbiamo creato una classe Cat e dichiarato due variabili al suo interno: String name e int age . Queste variabili membro sono chiamate campi. Essenzialmente, questo è un modello per tutti i gatti che creeremo in futuro. Ogni oggetto Cat avrà due variabili: un nome e un'età.
public class Cat {
String name;
int age;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
}
}
Ecco come funziona! Creiamo un gatto, gli diamo un nome e un'età e visualizziamo tutto sulla console. Pezzo di torta. :) Il più delle volte, le lezioni descrivono cose e fenomeni nel mondo reale. Un gatto, un tavolo, una persona, un fulmine, una pagina di un libro, una ruota: creerai tutte queste cose nei tuoi programmi usando classi individuali. Per ora, concentriamoci sulle variabili che abbiamo dichiarato nella classe Cat . Sono chiamati campi o variabili di istanza. Il loro nome dice davvero tutto. Ogni istanza (o oggetto) della classe Cat avrà queste variabili. Ogni gatto che creiamo avrà il proprio nome variabile e la propria etàvariabile. Questo ha senso: è fondamentalmente come è con i gatti veri. :) Oltre alle variabili di istanza, ci sono anche variabili di classe (variabili statiche). Concludiamo il nostro esempio:
public class Cat {
String name;
int age;
static int count = 0;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
count++;
Cat fluffy = new Cat();
fluffy.age = 5;
fluffy.name = "Fluffy";
count++;
System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);
System.out.println("Total number of cats = " + count);
}
}
Output della console: abbiamo creato un gatto chiamato Smudge. Ha 3 anni Abbiamo creato un gatto di nome Fluffy. La sua età è 5 Numero totale di gatti = 2 Ora la nostra classe ha una nuova variabile chiamata count. È responsabile del conteggio dei gatti creati. Ogni volta che creiamo un gatto nel principalemetodo, incrementiamo questa variabile di 1. Questa variabile viene dichiarata utilizzando la parola chiave static. Ciò significa che appartiene alla classe, non a un oggetto specifico della classe. Il che, ovviamente, ha senso: il nome di ogni gatto appartiene a quel gatto specifico, ma abbiamo bisogno di un contatore di gatti che si applichi a tutti loro. Questo è esattamente ciò che realizza la parola chiave static: rende la variabile count una singola variabile per tutti i gatti. Nota: quando visualizziamo la variabile, non stiamo usando smudge.count o Fluffy.count. Non appartiene né a Smudge né a Fluffy; appartiene all'intera classe Cat . Ecco perché conta semplicemente. Potresti anche scrivere Cat.count. Anche questo sarebbe corretto. Quando visualizzi la variabile name, non faremmo quanto segue:
public class Cat {
String name;
int age;
static int count = 0;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
count++;
System.out.println("We created a cat named " + name + ". His age is " + smudge.age);
System.out.println("Total number of cats = " + count);
}
}
Questo è un errore! Ogni gatto ha il suo nome. Il compilatore si confonde qui. "Invia un nome alla console? Di chi è il nome?" :/"
Metodi
Oltre alle variabili, ogni classe ha metodi. Ne parleremo più dettagliatamente in una lezione separata, ma i principi generali sono abbastanza semplici. I metodi definiscono la funzionalità della tua classe, cioè cosa possono fare gli oggetti della tua classe. Conosci già uno di questi metodi: il metodo main() . Ma, come forse ricorderete, il metodo principale è statico, il che significa che appartiene all'intera classe (la logica è la stessa delle variabili). Tuttavia, i metodi standard non statici possono essere chiamati solo su oggetti specifici che abbiamo creato. Ad esempio, se vogliamo scrivere una classe cat, dobbiamo sapere quali funzioni dovrebbe avere un gatto nel nostro programma. Su questa premessa, scriviamo un paio di metodi per il nostro gatto:
public class Cat {
String name;
int age;
public void sayMeow() {
System.out.println("Meow!");
}
public void jump() {
System.out.println("Pounce!");
}
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
smudge.sayMeow();
smudge.jump();
}
}
Controlla! Ora la nostra classe è molto più vicina a somigliare a un gatto! Ora non abbiamo solo un gatto con un nome ("Smudge") e un'età (3). Può anche dire miao e saltare! Che tipo di gatto sarebbe senza quella "funzionalità"? :) Stiamo prendendo un oggetto specifico (sfumino) e chiamando i suoi metodi sayMeow() e jump() . Diamo un'occhiata alla console: Miao! Salta! Un vero gatto! :)
Creare le proprie classi. Astrazione
In futuro, dovrai scrivere le tue classi. A cosa devi prestare attenzione quando li scrivi? Se parliamo di variabili, allora dovrai usare qualcosa chiamato astrazione. L'astrazione è uno dei quattro principi di base della programmazione orientata agli oggetti. Significa estrarre le caratteristiche più importanti e significative di un oggetto e, viceversa, scartare quelle minori o insignificanti. Ad esempio, creiamo uno schedario per i dipendenti dell'azienda. Per creare oggetti dipendente, abbiamo scritto un dipendenteclasse. Quali caratteristiche sono importanti descrittori di un dipendente per lo schedario della nostra azienda? Nome, data di nascita, SSN e ID dipendente. Ma è improbabile che avremo bisogno dell'altezza, del colore degli occhi o dei capelli del dipendente per il registro dei dipendenti dell'azienda. Le aziende non hanno bisogno di queste informazioni. Quindi, nella classe Employee , dichiariamo le seguenti variabili: String name , int age , int socialSecurityNumber e int employeeId. E tralasciamo le informazioni non necessarie (come il colore degli occhi). In altre parole, creiamo un'astrazione. Tuttavia, se stiamo realizzando uno schedario per agenzie di modelle, la situazione cambia radicalmente. L'altezza, il colore degli occhi e dei capelli di una modella sono caratteristiche importanti, ma il suo SSN è assolutamente irrilevante per noi. Quindi, nella classe Model , dobbiamo creare le seguenti variabili: String height , String hair , String eyes . Ecco come funziona l'astrazione: è facile! :)
Costruttori
Torniamo al nostro esempio del gatto.
public class Cat {
String name;
int age;
public static void main(String[] args) {
Cat smudge = new Cat();
System.out.println("Here the program does something for 2 hours...");
smudge.age = 3;
smudge.name = "Smudge";
}
}
Esamina questo codice e cerca di capire cosa c'è che non va nel nostro programma. Il nostro programma ha avuto un gatto senza nome o età per 2 ore! Naturalmente, questo è intrinsecamente sbagliato. Il database della clinica veterinaria non dovrebbe includere gatti senza informazioni. Attualmente, il nostro gatto è in balia del programmatore. Confidiamo che non dimenticherà di specificare nome ed età, e che andrà tutto bene. Se dimentica, il database avrà un problema: gatti senza nome. come possiamo risolvere questo problema? Dobbiamo in qualche modo impedire che vengano creati gatti senza nome ed età. È qui che i costruttori vengono in soccorso. Facciamo un esempio:
public class Cat {
String name;
int age;
// Constructor for the Cat class
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
}
}
Essenzialmente, un costruttore è un modello per gli oggetti di una classe. In questo caso, indichiamo che per ogni oggetto cat devono essere specificati due argomenti, uno String e un int . Se proviamo a creare un gatto senza nome ora, non funzionerà.
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat(); // Error!
}
}
Ora che la classe ha un costruttore, il compilatore Java sa come dovrebbero apparire gli oggetti e non consente la creazione di oggetti senza specificare gli argomenti. Ora esaminiamo la parola chiave this, che vedi all'interno del costruttore. È anche semplice. La parola chiave this serve per indicare un particolare oggetto. Il codice nel costruttore
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
può essere interpretato quasi alla lettera: "Il nome di questo gatto (quello che stiamo creando) = l'argomento passato per il parametro del nome del costruttore. L'età di questo gatto (quello che stiamo creando) = l'argomento passato per il parametro del costruttore parametro di età." Dopo l'esecuzione del costruttore, puoi verificare che tutti i valori necessari siano stati assegnati al nostro cat:
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
System.out.println(smudge.name);
System.out.println(smudge.age);
}
}
Output della console: Smudge 5 Quando è stato chiamato il costruttore:
Cat smudge = new Cat("Smudge", 5);
Questo è ciò che è realmente accaduto internamente:
this.name = "Smudge";
this.age = 5;
E i valori degli argomenti passati al costruttore sono stati assegnati all'oggetto smudge (questo è ciò a cui si riferisce in questo caso). Infatti, anche se non dichiari alcun costruttore in una classe, chiamerà comunque un costruttore! Ma come è possibile? О_О Perché tutte le classi Java hanno un cosiddetto costruttore predefinito. Non accetta argomenti, ma viene invocato ogni volta che crei un oggetto di qualsiasi classe.
public class Cat {
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
A prima vista, questo potrebbe non essere ovvio. Abbiamo creato un oggetto, e allora? Dove sta facendo qualcosa il costruttore qui? Per vederlo, scriviamo esplicitamente un costruttore vuoto per la classe Cat . All'interno, invieremo alcune frasi alla console. Se la frase viene visualizzata, il costruttore è stato richiamato.
public class Cat {
public Cat() {
System.out.println("A cat has been created!");
}
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
Output della console: è stato creato un gatto! C'è la conferma. Il costruttore predefinito è sempre presente in modo invisibile nelle tue classi. Ma devi sapere un'altra cosa al riguardo. Il costruttore predefinito viene eliminato da una classe una volta creato un costruttore con argomenti. In effetti, ne abbiamo già visto la prova sopra. Era in questo codice:
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat(); // Error!
}
}
Non è stato possibile creare un Cat senza nome ed età, perché abbiamo dichiarato un costruttore Cat con parametri string e int. Ciò ha causato l'immediata scomparsa del costruttore predefinito dalla classe. Quindi assicurati di ricordare che se hai bisogno di diversi costruttori nella tua classe, incluso un costruttore senza argomenti, dovrai dichiararlo separatamente. La nostra clinica vuole fare buone azioni e aiutare i gattini senzatetto i cui nomi ed età sono sconosciuti. Quindi il nostro codice dovrebbe assomigliare a questo:
public class Cat {
String name;
int age;
// For cats with owners
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
// For street cats
public Cat() {
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
Cat streetCat = new Cat();
}
}
Ora che abbiamo specificato un costruttore predefinito esplicito, possiamo creare entrambi i tipi di gatti. Nel costruttore è possibile assegnare direttamente i valori. Non devi prenderli sempre dalle discussioni. Ad esempio, potremmo etichettare tutti i gatti di strada nel database utilizzando "Street cat No. <count>" come modello. :
public class Cat {
String name;
int age;
static int count = 0;
public Cat() {
count++;
this.name = "Street cat No. " + count;
}
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat streetCat1 = new Cat();
Cat streetCat2 = new Cat();
System.out.println(streetCat1.name);
System.out.println(streetCat2.name);
}
}
Abbiamo una variabile di conteggio , che conta i nostri gatti di strada. Ogni volta che viene eseguito il costruttore predefinito, incrementiamo count di 1 e alleghiamo questo numero al nome del gatto. L'ordine degli argomenti è molto importante per i costruttori. Scambiamo gli argomenti name ed age passati al nostro costruttore.
public class Cat {
String name;
int age;
public Cat(int age, String name) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 10); // Error!
}
}
Abbiamo un errore! Il costruttore stabilisce chiaramente che quando viene creato un oggetto Cat , deve essere passato un numero e una stringa, in questo ordine. Quindi, il nostro codice non funziona. Assicurati di ricordare e rispettare questa regola quando dichiari le tue classi:
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
Questi sono due costruttori completamente diversi! Ora, completa un paio di attività per consolidare la tua comprensione del materiale. :)
Museo delle Antichità.
Il tuo compito è progettare una classe Artifact .
Ci sono tre tipi di manufatti conservati nel museo.
Del primo tipo non sappiamo nulla se non il numero di serie assegnato dal museo (ad esempio: 212121).
Per il secondo tipo, conosciamo il numero di serie e la cultura che lo ha creato (ad esempio: 212121, "Aztecs").
Per il terzo tipo, conosciamo il numero di serie, la cultura che lo ha creato e il secolo in cui è stato creato (ad esempio: 212121, "Aztecs", 12).
Crea una classe Artifact che descriva le antichità custodite nel museo e scrivi l'insieme richiesto di costruttori per la classe. Quindi, nel metodo main() , crea un artefatto di ogni tipo.
public class Artifact {
// Write your code here
public static void main(String[] args) {
// Write your code here
}
}
Sito di incontri
Creiamo un database utenti per un sito di incontri.
Ma ecco il problema: hai dimenticato l'ordine richiesto degli argomenti e non è disponibile alcuna documentazione tecnica.
Progetta una classe utente , che avrà i seguenti campi: name ( String ), age ( short ) e height ( int ).
Creare il numero appropriato di costruttori, in modo che il nome, l'età e l'altezza possano essere specificati in qualsiasi ordine.
public class User {
String name;
short age;
int height;
// Write your code here
public static void main(String[] args) {
}
}
Per rafforzare ciò che hai imparato, ti suggeriamo di guardare una lezione video dal nostro corso Java
GO TO FULL VERSION