Clasele abstracte
Pe lângă clasele obișnuite, în Java există clase abstracte. O clasă abstractă este asemănătoare unei clase obișnuite. Într-o clasă abstractă, pot fi definite câmpuri și metode, dar nu se poate crea un obiect sau o instanță a acestei clase. Clasele abstracte sunt menite să ofere funcționalitate de bază pentru clasele derivate, iar clasele derivate implementează această funcționalitate.
La definirea claselor abstracte se folosește cuvântul cheie abstract:
public abstract class Human{
private String name;
public String getName() { return name; }
}Dar principala diferență constă în faptul că nu putem folosi constructorul unei clase abstracte pentru a crea un obiect al acesteia. De exemplu, astfel:
Human h = new Human();Pe lângă metodele obișnuite, o clasă abstractă poate conține metode abstracte. Aceste metode sunt definite folosind cuvântul cheie abstract și nu au nicio implementare:
public abstract void display();Clasa derivată este obligată să suprascrie și să implementeze toate metodele abstracte din clasa abstractă de bază. De asemenea, trebuie avut în vedere că, dacă o clasă are măcar o metodă abstractă, această clasă trebuie să fie definită ca abstractă.
De ce avem nevoie de clase abstracte? Să presupunem că facem o aplicație pentru gestionarea operațiunilor bancare și definim trei clase: Person, care descrie o persoană, Employee, care descrie un angajat bancar, și Client, care reprezintă un client al băncii.
Evident, clasele Employee și Client vor fi derivate din clasa Person, deoarece ambele clase au câmpuri și metode comune. Și deoarece toate obiectele vor reprezenta fie un angajat, fie un client al băncii, nu vom crea obiecte direct din clasa Person. De aceea, are sens să facem această clasă abstractă.
public class Program{
public static void main(String[] args) {
Employee sam = new Employee("Sam", "Leman Brothers");
sam.display();
Client bob = new Client("Bob", "Leman Brothers");
bob.display();
}
}
abstract class Person {
private String name;
public String getName() { return name; }
public Person(String name){
this.name = name;
}
public abstract void display();
}
class Employee extends Person {
private String bank;
public Employee(String name, String company) {
super(name);
this.bank = company;
}
public void display(){
System.out.printf("Employee Name: %s \t Bank: %s \n", super.getName(), bank);
}
}
class Client extends Person {
private String bank;
public Client(String name, String company) {
super(name);
this.bank = company;
}
public void display(){
System.out.printf("Client Name: %s \t Bank: %s \n", super.getName(), bank);
}
}Un alt exemplu clasic este sistemul de figuri geometrice. În realitate, nu există o figură geometrică generică. Există cercuri, dreptunghiuri, pătrate, dar nu există pur și simplu „figură”. Totuși, cercul și dreptunghiul au ceva în comun și sunt figuri:
// clasă abstractă pentru figuri
abstract class Figure{
float x; // coordonata x a punctului
float y; // coordonata y a punctului
Figure(float x, float y){
this.x = x;
this.y = y;
}
// metodă abstractă pentru obținerea perimetrului
public abstract float getPerimeter();
// metodă abstractă pentru obținerea ariei
public abstract float getArea();
}
// clasă derivată pentru dreptunghi
class Rectangle extends Figure {
private float width;
private float height;
// constructor cu apel la constructorul clasei Figure
Rectangle(float x, float y, float width, float height){
super(x, y);
this.width = width;
this.height = height;
}
public float getPerimeter(){
return width * 2 + height * 2;
}
public float getArea(){
return width * height;
}
}