Bună! Astăzi vom vorbi despre cursurile în Java. Ai putea spune că clasele formează piatra de temelie a programării Java. Când devii programator, aproape întreaga ta slujbă va fi să scrii propriile tale clase care au diverse funcții. Să vedem ce înseamnă și cum funcționează. :) După cum știți, Java este un limbaj de programare orientat pe obiecte. Toate programele constau din obiecte care într-un fel sau altul sunt legate între ele. O clasă este, în esență, un șablon pentru un obiect. Determină cum va arăta obiectul și ce funcții va avea. Fiecare obiect este un obiect al unei clase. Luați în considerare acest exemplu foarte simplu:
public class Cat {
String name;
int age;
}
Să presupunem că scriem un program care implică pisici din anumite motive (de exemplu, avem o clinică veterinară care oferă acces la un cont online). Am creat o clasă Cat și am declarat două variabile în ea: String name și int age . Aceste variabile membre se numesc câmpuri. În esență, acesta este un șablon pentru toate pisicile pe care le vom crea în viitor. Fiecare obiect Cat va avea două variabile: un nume și o vârstă.
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);
}
}
Iată cum funcționează! Creăm o pisică, îi dăm un nume și o vârstă și le afișăm pe consolă. Bucată de tort. :) De cele mai multe ori, cursurile descriu lucruri și fenomene din lumea reală. O pisică, o masă, o persoană, un fulger, o pagină de carte, o roată - veți crea toate aceste lucruri în programele dvs. folosind clase individuale. Deocamdată, să ne concentrăm asupra variabilelor pe care le-am declarat în clasa Cat . Ele sunt numite câmpuri sau variabile de instanță. Numele lor chiar spune totul. Fiecare instanță (sau obiect) a clasei Cat va avea aceste variabile. Fiecare pisică pe care o creăm va avea propria sa variabilă de nume și propria sa vârstăvariabil. Acest lucru are sens - practic așa este cu pisicile reale. :) Pe lângă variabilele de instanță, există și variabile de clasă (variabile statice). Să terminăm exemplul nostru:
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);
}
}
Ieșire din consolă: am creat o pisică numită Smudge. Vârsta lui este de 3 ani. Am creat o pisică pe nume Fluffy. Vârsta lui este 5 Număr total de pisici = 2 Acum clasa noastră are o nouă variabilă numită număr. Este responsabil pentru numărarea pisicilor create. De fiecare dată când creăm o pisică în principalmetoda, mărim această variabilă cu 1. Această variabilă este declarată folosind cuvântul cheie static. Asta înseamnă că aparține clasei, nu unui obiect specific al clasei. Ceea ce, desigur, are sens: numele fiecărei pisici aparține acelei pisici specifice, dar avem nevoie de un numărător de pisici care să se aplice tuturor. Acesta este exact ceea ce realizează cuvântul cheie static: face ca variabila de numărare să fie o singură variabilă pentru toate pisicile. Notă: când afișăm variabila, nu folosim smudge.count sau fluffy.count. Nu aparține nici lui Smudge, nici lui Fluffy; aparține întregii clase de pisici . De aceea este pur și simplu numărat. Ai putea scrie și Cat.count. Și asta ar fi corect. Când afișăm variabila nume, nu vom face următoarele:
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);
}
}
Aceasta este o eroare! Fiecare pisică are propriul nume. Compilatorul devine confuz aici. "Trimite un nume pe consolă? Numele cui?" :/"
Metode
Pe lângă variabile, fiecare clasă are metode. Vom vorbi despre ele mai detaliat într-o lecție separată, dar principiile generale sunt destul de simple. Metodele definesc funcționalitatea clasei tale, adică ce pot face obiectele clasei tale. Sunteți deja familiarizat cu una dintre aceste metode: metoda main() . Dar, după cum vă puteți aminti, metoda principală este statică, ceea ce înseamnă că aparține întregii clase (logica este aceeași ca și în cazul variabilelor). Cu toate acestea, metodele standard, non-statice pot fi apelate numai pe anumite obiecte pe care le-am creat. De exemplu, dacă vrem să scriem o clasă de pisici, trebuie să știm ce funcții ar trebui să aibă o pisică din programul nostru. Pe această premisă, să scriem câteva metode pentru pisica noastră:
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();
}
}
Verifică! Acum clasa noastră este mult mai aproape de a semăna cu o pisică! Acum nu avem doar o pisică cu un nume („Smudge”) și o vârstă (3). De asemenea, poate să spună miau și să sară! Ce fel de pisică ar fi fără acea „funcționalitate”? :) Luăm un anumit obiect (smudge) și îi apelăm metodele sayMeow() și jump() . Să ne uităm la consolă: Miau! Păstrează-te! O pisica adevarata! :)
Crearea propriilor clase. Abstracția
În viitor, va trebui să vă scrieți propriile clase. La ce trebuie să fii atent când le scrii? Dacă vorbim despre variabile, atunci va trebui să folosiți ceva numit abstractizare. Abstracția este unul dintre cele patru principii de bază ale programării orientate pe obiecte. Înseamnă extragerea celor mai importante și semnificative caracteristici ale unui articol și, dimpotrivă, aruncarea deoparte pe cele care sunt minore sau nesemnificative. De exemplu, să creăm un dulap pentru angajații companiei. Pentru a crea obiecte angajat, am scris un angajatclasă. Ce caracteristici sunt descriptori importanți ai unui angajat pentru biroul de dosare al companiei noastre? Numele, data nașterii, SSN și ID-ul angajatului. Dar este puțin probabil să avem nevoie de înălțimea angajatului, culoarea ochilor sau culoarea părului pentru evidența angajaților companiei. Companiile nu au nevoie de aceste informații. Deci, în clasa Employee , declarăm următoarele variabile: String name , int age , int socialSecurityNumber și int employeeId. Și omitem informațiile inutile (cum ar fi culoarea ochilor). Cu alte cuvinte, creăm o abstractizare. Totuși, dacă facem un birou de dosare pentru agențiile de modele, situația se schimbă dramatic. Înălțimea unui model, culoarea ochilor și culoarea părului sunt caracteristici importante, dar SSN-ul ei este absolut irelevant pentru noi. Deci, în clasa Model , trebuie să creăm următoarele variabile: String height , String hair , String eyes . Așa funcționează abstracția — este ușor! :)
Constructorii
Să revenim la exemplul nostru de pisică.
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";
}
}
Priviți acest cod și încercați să vă dați seama ce este în neregulă cu programul nostru. Programul nostru a avut o pisică fără nume sau vârstă timp de 2 ore! Desigur, acest lucru este în mod inerent greșit. Baza de date a clinicii veterinare nu ar trebui să includă pisici fără informații. În prezent, pisica noastră este la cheremul programatorului. Avem încredere că nu va uita să precizeze un nume și o vârstă și că totul va fi în regulă. Dacă uită, baza de date va avea o problemă: pisici fără nume. Cum putem rezolva această problemă? Trebuie să împiedicăm cumva pisicile să fie create fără nume și vârstă. Aici constructorii vin în ajutor. Să dăm un exemplu:
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);
}
}
În esență, un constructor este un șablon pentru obiectele unei clase. În acest caz, indicăm că pentru fiecare obiect cat trebuie specificate două argumente, un String și un int . Dacă încercăm să creăm o pisică fără nume acum, nu va funcționa.
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!
}
}
Acum că clasa are un constructor, compilatorul Java știe cum ar trebui să arate obiectele și nu permite ca obiectele să fie create fără a specifica argumentele. Acum, să investigăm cuvântul cheie this, pe care îl vedeți în interiorul constructorului. Este si simplu. Cuvântul cheie this este pentru a indica un anumit obiect. Codul din constructor
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
poate fi interpretat aproape textual: „Numele acestei pisici (cea pe care o creăm) = argumentul transmis pentru parametrul numelui constructorului. Vârsta acestei pisici (cea pe care o creăm) = argumentul transmis pentru parametrul constructorului. parametrul de vârstă”. După rularea constructorului, puteți verifica dacă toate valorile necesare au fost atribuite pisicii noastre:
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);
}
}
Ieșire din consolă: Smudge 5 Când a fost apelat constructorul:
Cat smudge = new Cat("Smudge", 5);
Iată ce s-a întâmplat de fapt pe plan intern:
this.name = "Smudge";
this.age = 5;
Și valorile argumentelor transmise constructorului au fost atribuite obiectului smudge (la asta se referă în acest caz). De fapt, chiar dacă nu declarați niciun constructor într-o clasă, va apela totuși un constructor! Dar cum este posibil asta? О_О Pentru că, toate clasele Java au un așa-numit constructor implicit. Nu ia niciun argument, dar este invocat de fiecare dată când creați orice obiect din orice clasă.
public class Cat {
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
La prima vedere, acest lucru poate să nu fie evident. Am creat un obiect, deci ce? Unde face constructorul ceva aici? Pentru a-l vedea, să scriem în mod explicit un constructor gol pentru clasa Cat . În interior, vom trimite o frază în consolă. Dacă expresia este afișată, atunci constructorul a fost invocat.
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
}
}
Ieșire din consolă: a fost creată o pisică! Acolo este confirmarea. Constructorul implicit este întotdeauna prezent invizibil în clasele dvs. Dar trebuie să mai știi un lucru despre asta. Constructorul implicit este eliminat dintr-o clasă odată ce creați un constructor cu argumente. De fapt, am văzut deja dovezi în acest sens mai sus. Era in acest cod:
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!
}
}
Nu am putut crea un Cat fără nume și vârstă, deoarece am declarat un constructor Cat cu parametri string și int. Acest lucru a făcut ca constructorul implicit să dispară imediat din clasă. Așadar, asigurați-vă că rețineți că dacă aveți nevoie de mai mulți constructori în clasa dvs., inclusiv un constructor fără argument, va trebui să-l declarați separat. Clinica noastră vrea să facă fapte bune și să ajute pisoi fără adăpost ale căror nume și vârste nu sunt cunoscute. Atunci codul nostru ar trebui să arate astfel:
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();
}
}
Acum că am specificat un constructor implicit implicit, putem crea ambele tipuri de pisici. În constructor, puteți aloca valori direct. Nu trebuie să le iei mereu din argumente. De exemplu, am putea eticheta toate pisicile străzii din baza de date folosind „Street cat No. <count>” ca șablon. :
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);
}
}
Avem o variabilă de numărare , care numără pisicile noastre de stradă. De fiecare dată când se execută constructorul implicit, creștem numărul cu 1 și atașăm acest număr la numele pisicii. Ordinea argumentelor este foarte importantă pentru constructori. Să schimbăm argumentele de nume și vârstă transmise constructorului nostru.
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!
}
}
Avem o eroare! Constructorul stipulează clar că atunci când un obiect Cat este creat, trebuie să i se transmită un număr și un șir, în această ordine. Deci, codul nostru nu funcționează. Asigurați-vă că vă amintiți și respectați această regulă atunci când vă declarați propriile cursuri:
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
Aceștia sunt doi constructori total diferiți! Acum, finalizați câteva sarcini pentru a vă consolida înțelegerea materialului. :)
Muzeul de Antichități.
Sarcina ta este să proiectezi o clasă de artefacte .
Există trei tipuri de artefacte păstrate la muzeu.
Nu știm nimic despre primul tip, cu excepția numărului de serie atribuit de muzeu (de exemplu: 212121).
Pentru al doilea tip, cunoaștem numărul de serie și cultura care l-a creat (de exemplu: 212121, „Azteci”).
Pentru al treilea tip, cunoaștem numărul de serie, cultura care l-a creat și secolul în care a fost creat (de exemplu: 212121, „Aztecii”, 12).
Creați o clasă Artefact care descrie antichitățile păstrate la muzeu și scrieți setul necesar de constructori pentru clasă. Apoi, în metoda main() , creați câte un artefact de fiecare fel.
public class Artifact {
// Write your code here
public static void main(String[] args) {
// Write your code here
}
}
Site pentru intalniri
Să creăm o bază de date de utilizatori pentru un site de întâlniri.
Dar iată problema: ați uitat ordinea necesară a argumentelor și nu există documentație tehnică disponibilă.
Proiectați o clasă de utilizator , care va avea următoarele câmpuri: nume ( String ), vârstă ( short ) și înălțime ( int ).
Creați numărul corespunzător de constructori, astfel încât numele, vârsta și înălțimea să poată fi specificate în orice ordine.
public class User {
String name;
short age;
int height;
// Write your code here
public static void main(String[] args) {
}
}
Pentru a consolida ceea ce ați învățat, vă sugerăm să urmăriți o lecție video de la Cursul nostru Java
GO TO FULL VERSION