Abstract sınıflar ve arayüzler (interface)

Geçen hafta Shape sınıfına area() yazıp 0 döndürdük. Ama “genel bir şekil”in alanı anlamsız; o metodun tek görevi alt sınıflara “sen bunu yazacaksın” demekti. Abstract sınıflar ve arayüzler (interface) bu niyeti dile döker: derleyici, sözleşmeyi yerine getirmeyen sınıfı derlemez. Sınavda bu yüzden çok “find the compile error” sorusu gelir, ayrıca Comparable ile “sort this array” tipi yazma soruları.

Altın kurallar:

1. Abstract sınıftan new yapılmaz ama tip olarak kullanılır.
2. Abstract metodu olan sınıf abstract olmak zorunda. Somut alt sınıf hepsini yazmak zorunda.
3. Arayüz metotları public’tir. Implement ederken public yazmayı unutma.
4. Tek extends, çok implements.
5. compareTo: negatif, sıfır, pozitif. Arrays.sort bunu kullanır.

Abstract sınıf

abstract anahtar kelimesiyle işaretlenen sınıf eksik bir kalıptır. İçinde gövdesiz (abstract) metotlar olabilir. Normal sınıf gibi alanları, constructor’ı ve gövdeli metotları da olabilir.

abstract class Employee {
    private final String name;

    Employee(String name) {                 // abstract sınıfın da constructor'ı var
        this.name = name;
        System.out.println("Employee(" + name + ")");
    }
    String getName() { return name; }

    abstract double earnings();             // gövde yok, noktalı virgül

    @Override
    public String toString() { return getName() + ": " + earnings(); }
}

class Salaried extends Employee {
    private final double monthly;
    Salaried(String n, double m) { super(n); monthly = m; }
    @Override double earnings() { return monthly; }
}

class Hourly extends Employee {
    private final double rate;
    private final int hours;
    Hourly(String n, double r, int h) { super(n); rate = r; hours = h; }
    @Override double earnings() {
        if (hours <= 40) return rate * hours;
        return rate * 40 + rate * 1.5 * (hours - 40);   // fazla mesai
    }
}

Employee[] staff = { new Salaried("Ada", 3000), new Hourly("Bora", 100, 45) };
for (Employee e : staff) System.out.println(e);

Employee(Ada)
Employee(Bora)
Ada: 3000.0
Bora: 4750.0

new Employee("X") yazsaydın: Employee is abstract; cannot be instantiated. Ama Employee[] dizisi ve Employee e değişkeni sorunsuz; abstract sınıf polimorfizm için ortak tip olarak kullanılır.

Abstract ile ilgili kurallar

Arayüz (interface)

Arayüz, bir sınıfın “neler yapabildiğini” söyleyen sözleşmedir. Kalıtımdaki “is-a” ilişkisinden daha gevşek: “can-do” ilişkisi. Birbiriyle hiç ilgisi olmayan sınıflar (fatura, çalışan, kira) aynı Payable arayüzünü uygulayabilir.

Arayüzde yazılanların gizli anlamları:

interface Payable {
    double TAX = 0.2;
    double amount();
    default double afterTax() { return amount() * (1 - TAX); }
}

class Invoice implements Payable {
    private final int qty;
    private final double price;
    Invoice(int q, double p) { qty = q; price = p; }
    public double amount() { return qty * price; }   // public ŞART
}

Payable p = new Invoice(3, 50);
System.out.println(p.amount() + " " + p.afterTax());
System.out.println(Payable.TAX);

150.0 120.0
0.2

TUZAK · public unutmak. Arayüzde public yazmasan da metot public’tir. Sınıfta yazmazsan package-private olur ve erişim daralır: attempting to assign weaker access privileges; was public. En sık görülen interface derleme hatası budur.

Arayüz sabitini değiştirmeye çalışmak da hata verir: Payable.TAX = 0.3; → cannot assign a value to static final variable TAX.

Birden fazla arayüz

Bir sınıf tek bir sınıftan türeyebilir ama istediği kadar arayüz uygulayabilir. Yazım sırası önemli: önce extends, sonra implements.

class Robot extends Machine implements Payable, Comparable<Robot> { ... }

İki arayüz aynı imzalı default metodu getirirse Java hangisini seçeceğini bilemez ve derleme hatası verir. Çözüm: sınıf metodu override eder, isterse ArayuzAdi.super.metot() ile birini (ya da ikisini) çağırır.

interface Flyer   { default String move() { return "fly"; } }
interface Swimmer { default String move() { return "swim"; } }

class Duck implements Flyer, Swimmer {
    public String move() { return Flyer.super.move() + "+" + Swimmer.super.move(); }
}
System.out.println(new Duck().move());

fly+swim

Override olmadan class Duck implements Flyer, Swimmer { } yazarsan: types Flyer and Swimmer are incompatible; class Duck inherits unrelated defaults for move() from types Flyer and Swimmer.

Abstract sınıf mı, arayüz mü?

Pratik kural: alt sınıflar ortak alan ve kod paylaşıyorsa abstract sınıf. Sadece ortak yetenek varsa arayüz.

Comparable ve compareTo

java.lang.Comparable<T> tek metotlu bir arayüz: int compareTo(T other). Bir sınıf bunu uygulayınca nesneleri için “doğal sıra” tanımlamış olur. Arrays.sort ve Collections.sort bu sırayı kullanır.

compareTo’nun döndürdüğü değerin anlamı:

class Student implements Comparable<Student> {
    String name; double gpa;
    Student(String n, double g) { name = n; gpa = g; }

    @Override
    public int compareTo(Student o) { return Double.compare(gpa, o.gpa); }

    @Override
    public String toString() { return name + "(" + gpa + ")"; }
}

Student[] st = { new Student("Ece", 3.1), new Student("Ali", 3.8), new Student("Can", 2.5) };
Arrays.sort(st);
System.out.println(Arrays.toString(st));
System.out.println(st[0].compareTo(st[2]));
System.out.println("apple".compareTo("banana"));
System.out.println("b".compareTo("a"));
System.out.println(Integer.valueOf(5).compareTo(5));

[Can(2.5), Ece(3.1), Ali(3.8)]
-1
-1
1
0

İPUCU · ters sıra. Büyükten küçüğe sıralamak için argümanları değiştir: Double.compare(o.gpa, gpa). İsme göre sıralamak için String’in kendi compareTo’sunu kullan: name.compareTo(o.name).

String, Integer, Double gibi hazır sınıflar zaten Comparable. Bu yüzden String[] dizisini doğrudan Arrays.sort ile alfabetik dizebilirsin. Kendi sınıfın Comparable değilse ve Arrays.sort çağırırsan derleme hatası almazsın, ama çalışırken ClassCastException fırlar.

Arayüz tipi ve instanceof

Arayüz de bir tiptir: Payable p = new Invoice(...) geçerli, p instanceof Payable çalışır. Arayüz tipindeki değişkenle sadece arayüzde tanımlı metotları çağırabilirsin (geçen haftaki static tip kuralı aynen geçerli).

Object o = new Invoice(1, 1);
System.out.println(o instanceof Payable);
System.out.println(o instanceof Comparable);

true
false

Sık yapılan hatalar

abstract class Shape { abstract double area(); }
// in main:
Shape s = new Shape();

abstract class Shape { abstract double area(); }
class Circle extends Shape {
    double r;
}

interface Payable { double amount(); }
class Bill implements Payable {
    double amount() { return 10; }
}

class Shape {
    abstract double area();
}

abstract class Employee {
    private final String name;
    Employee(String name) { this.name = name; }
    String getName() { return name; }
    abstract double earnings();
    public String toString() { return getName() + ": " + earnings(); }
}
class Hourly extends Employee {
    private double rate; private int hours;
    Hourly(String n, double r, int h) { super(n); rate = r; hours = h; }
    double earnings() {
        if (hours <= 40) return rate * hours;
        return rate * 40 + rate * 1.5 * (hours - 40);
    }
}
// in main:
System.out.println(new Hourly("Bora", 100, 45));

interface Payable {
    double TAX = 0.2;
    double amount();
    default double afterTax() { return amount() * (1 - TAX); }
}
class Invoice implements Payable {
    private int qty; private double price;
    Invoice(int q, double p) { qty = q; price = p; }
    public double amount() { return qty * price; }
}
// in main:
Payable p = new Invoice(3, 50);
System.out.println(p.amount() + " " + p.afterTax());

interface Flyer   { default String move() { return "fly"; } }
interface Swimmer { default String move() { return "swim"; } }
class Duck implements Flyer, Swimmer { }

class Student implements Comparable<Student> {
    String name; double gpa;
    Student(String n, double g) { name = n; gpa = g; }
    public int compareTo(Student o) { return Double.compare(gpa, o.gpa); }
    public String toString() { return name + "(" + gpa + ")"; }
}
// in main:
Student[] st = { new Student("Ece", 3.1), new Student("Ali", 3.8), new Student("Can", 2.5) };
Arrays.sort(st);
System.out.println(Arrays.toString(st));

System.out.println("apple".compareTo("banana"));
System.out.println("b".compareTo("a"));
System.out.println(Integer.valueOf(5).compareTo(5));

abstract class Base {
    Base() { System.out.println("Base " + id()); }
    abstract String id();
}
class Impl extends Base {
    Impl() { super(); System.out.println("Impl"); }
    String id() { return "impl-id"; }
}

public class Money implements Comparable<Money> {
    private final int cents;

    @Override
    public int compareTo(Money other) {
        return Integer.compare(cents, other.cents);
    }

    @Override
    public String toString() { return cents + "c"; }
}