Методи по подразбиране в интерфейсите

Всяка нова version на Java се различава от предишните. Ето пример за промени в материала, който разгледахме: преди Java 5 езикът нямаше enums. По подобен начин Java 8 се различава значително от Java 7. Повечето от нашите уроци са написани за 7-ма version на езика, но разбира се няма да пренебрегнем важни нововъведения. Тъй като вече говорим за интерфейси в този урок, ще разгледаме една актуализация — методи по подразбиране в интерфейсите . Вече знаете, че интерфейсът не прилага поведение . Неговата задача е да опише поведението, което трябва да имат всички обекти, които го реализират. Но разработчиците често се сблъскват със ситуации, при които имплементацията на даден метод е еднаква във всички класове. Нека разгледаме нашия пример със стара кола:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

„Според вас Howъв е основният проблем с този code? Вероятно сте забелязали, че написахме куп повтарящ се code! Този проблем е често срещан в програмирането и трябва да го избягвате. Друг е въпросът, че конкретни решения не са съществували преди Беше пусната Java 8. С тази version дойде възможността да указвате методи по подразбиране и да ги внедрявате направо в интерфейса! Ето How да направите това:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Сега методите gas()и brake(), които бяха еднакви за всички автомобor, са преместени в интерфейса. Не е необходим повтарящ се code. Нещо повече, методите са налични във всеки клас!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

Ами ако има 100 класа с gas()метода, но само 99 от тях имат същото поведение? Това съсипва ли всичко и прави метода по подразбиране неподходящ за тази ситуация? Разбира се, не :) Методите по подразбиране в интерфейсите могат да бъдат заменени по същия начин като обикновените.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Всичките 99 други типа автомобor ще прилагат метода по подразбиране иUnusualCarклас, което е изключение, няма да развали цялостната картина и спокойно определя собственото си поведение. Множествено наследяване на интерфейси. Както вече знаете, Java не поддържа множествено наследяване. Има много причини за това. Ще ги разгледаме подробно в отделен урок. Други езици, като C++, го поддържат. Без множествено наследяване възниква сериозен проблем: един обект може да има няколко различни характеристики и „поведения“. Ето един пример от живота: ние сме деца за нашите родители, ученици за нашите учители и пациенти за нашите лекари. В живота ние поемаме различни роли и съответно се държим различно: очевидно не бихме говорor с учителите по същия начин, Howто говорим с близките си приятели. Нека се опитаме да преведем това в code. Представете си, че имаме два класа: Езерце и волиера. За езерото имаме нужда от водни птици; за волиерата имаме нужда от летящи птици. За да направим това, създадохме два базови класа:FlyingBirdи Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Съответно ще изпратим птици, чиито класове се наследяват FlyingBirdвъв волиерата, а птици, които наследяват, ще изпратим Waterfowlв езерото. Всичко изглежда много просто. Но къде да изпратим патица? Плува и лети. И ние нямаме множествено наследяване. За щастие Java поддържа множество реализации на интерфейси. Въпреки че един клас не може да наследява няколко родители, той може лесно да имплементира няколко интерфейса! Нашата патица може да бъде Howто летяща птица, така и водна птица :) Просто трябва да направим FlyingBirdинтерфейси Waterfowl, а не класове, за да постигнем желания резултат.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

Съответно, нашата програма запазва гъвкавостта на класовете и в комбинация с методите по подразбиране способността ни да дефинираме поведението на обектите става почти неограничена! :)