4.4.7 Clase, obiecte

În JAVA întreg programul este o clasă

Metoda main este executată automat cînd programul începe să ruleze

Clasele reprezintă inima limbajului Java. Orice concept vom implemanta în Java îl vom încapsula într-o clasă.

Accesarea unei clase

 Puteti accesa o clasa cu folosind numele ei complet

import:

 Cu import nu importam cod ci importam o cale spre pt a evita folosirea intregului nume

import:

 Putem importa tot ce tine de o clasa folosind *

 un singur nivel de *

 nu putem folosi import java.*.*

Putem importa metodele si campurile statice

 De exemplu:

 import static java.lang.System.*;

 out.println(„FTC competition”);

 static asociat cu clasa

 non static asociat cu instanţa clasei

Obiectele se caracterizează prin:

• COMPORTAMENT

• STARE

• IDENTITATE
  
  FOLOSIM

• SUBSTANTIVE PENTRU NUMELE CLASELOR

• VERBE PENTRU NUMELE METODELOR
  
  

O clasă reprezintă un plan după care vor fi create obiectele. Evident că nu toate obiectele vor fi la fel. La fel ca şi în cazul unui anumit tip de maşină unde poate să difere culoarea, anumite dotări etc.

Dacă suntem în curtea şcolii şi îl strigăm pe Mircea mai mulţi elevi vor răspunde deoarece vor crede că ei sunt celor care vrem să ne adresăm. Ca să nu creeăm confuzie îl vom apela folosind numele lui întreg, Mircea Măierean. Totuşi dacă vom merge în hub-ul de robotică şi îl vom chema pe Mircea să vadă noua manual de joc FTC doar Mircea Măierean va răspunde. Va răspunde doar el deoarece membrii echipei de robotică au nume diferite.

În mod similar putem importa un pachet ce conţine clasă de care avem nevoie iar apoi vom putea accesa respectiva clasă scriindu-i doar numele

Exemplu

import com.qualcomm.robotcore.hardware.DcMotor;

DcMotor motor1=null;

Obiectele sunt instanțe ale claselor!

Obiecte din clasa Masina:

Obiecte din clasa Animal:

În Java, conceptele de clase și obiecte sunt esențiale pentru programarea orientată pe obiecte (OOP). Perspectiva FTC (Fields, Types, and Constructors) se referă la o metodă structurată de înțelegere și implementare a claselor și obiectelor. Să detaliem fiecare componentă din această perspectivă:

1. Fields (Câmpuri)

Câmpurile sunt variabilele de instanță ale unei clase. Ele definesc starea sau proprietățile pe care obiectele clasei le pot avea.

• Exemplu:
  
  public class Person
{ private String name; private int age; }
  
  În acest exemplu, name și age sunt câmpuri ale clasei Person.

2. Types (Tipuri)

Tipurile se referă la tipurile de date ale câmpurilor, metodelor, și return types ale metodelor dintr-o clasă. Tipurile pot fi primitive (e.g., int, boolean, char) sau de referință (e.g., String, Person).

• Exemplu:
  public class Person {
private String name; // Tip de referință private
int age; // Tip primitiv
public String getName()
{ return name; }
public void setName(String name)
{ this.name = name; } }

3. Constructors (Constructori)

Constructorii sunt metode speciale folosite pentru inițializarea obiectelor. Ei au același nume ca și clasa și nu au un tip de returnare.

• Exemplu:
  public class Person
{ private String name;
private int age; // Constructor fără argumente
public Person()
{ this.name = "Unknown"; this.age = 0; }
// Constructor cu argumente
public Person(String name, int age)
{ this.name = name; this.age = age; } }

Crearea și utilizarea unui obiect

Pentru a crea un obiect dintr-o clasă, folosim cuvântul cheie new urmat de apelul constructorului.

• Exemplu:
  public class Main
{ public static void main(String[] args)
{ // Crearea unui obiect folosind constructorul fără argumente Person person1 = new Person();
// Crearea unui obiect folosind constructorul cu argumente Person
person2 = new Person("Alice", 30); // Accesarea și modificarea câmpurilor prin metodele getter și setter
System.out.println(person2.getName()); // Output: Alice person2.setAge(31);
System.out.println(person2.getAge()); // Output: 31 } }

Rezumat

• Fields (Câmpuri): Definirea stării obiectului.
• Types (Tipuri): Tipurile de date pentru câmpuri și metode.
• Constructors (Constructori): Inițializarea obiectelor clasei.

Aceste concepte fundamentale sunt esențiale pentru dezvoltarea aplicațiilor orientate pe obiecte în Java și ajută la structurarea clară și eficientă a codului.