Определение внутреннего интерфейса в Java как переменной экземпляра для класса

Question

Я озадачен некоторым исходным кодом, на который я смотрю, и я пытаюсь получить лучшее понимание. Код ниже, но он также доступен at Ideone, где вы можете играть с ним самостоятельно.

import java.util.*; 
import java.lang.*; 
import java.io.*; 

class Ideone 
{ 
    public interface Fruit { 
     public void apple(); 
    } 

    Fruit interfaceFruit; 

    public void apple(){ 
     System.out.println("apple"); 
     if (interfaceFruit != null) { 
      interfaceFruit.apple(); 
     } 
    } 

    public void setFruit(Fruit f) { 
     interfaceFruit = f; 
    } 

    public static void main (String[] args) throws java.lang.Exception 
    { 
     Ideone test = new Ideone(){ 
      @Override 
      public void apple() { 
       System.out.println("local override of apple"); 
      } 
     }; 
     System.out.println("1) ---"); 
     test.apple(); 

     Ideone test2 = new Ideone(); 
     System.out.println("2) ---"); 
     test2.apple(); 

     test2.setFruit(new Fruit() { 
      @Override 
      public void apple() { 
       System.out.println("interface override of apple"); 
      } 
     }); 
     System.out.println("3) ---"); 
     test2.apple(); 
    } 
} 

Выход:

1) --- 
local override of apple 
2) --- 
apple 
3) --- 
apple 
interface override of apple 

Что именно происходит в этом коде? Существует интерфейс, объявленный внутри класса (так, внутренний интерфейс, правильно?), А затем интерфейс объявляется как переменная экземпляра для класса. Здесь я смущен.

Я думаю, что происходит то, что если анонимный внутренний класс создается для интерфейса Fruit, мы создаем неназванный класс, который реализует интерфейс. Я не полностью понимаю, как и почему интерфейс хранится в переменной экземпляра класса. Какова цель этого? Как называется эта практика? Это кажется очень странным, и я не совсем уверен, что кто-то уберется от этого.

Answer 1

Это не обычный код, это просто упражнение, чтобы вы могли видеть, как он работает. Так что да, все может выглядеть «странно».

What I'm not totally getting is how or why the interface is stored in an instance variable to the class

Не хранится, это определяется. Вы можете иметь внутренние классы и интерфейсы, определенные в классе; несколько примеров:

• Классы и интерфейсы используются только во внутренней логике класса и не нужны в другом месте; обычно они определяются как частные. Работает более или менее так же, как анонимный класс.

• Классы и интерфейсы тесно связаны с классом. Например, вы определяете класс и реализацию Comparator для этого компонента; поскольку такой Comparator полезен только для элементов этого класса, вы определяете это как вложенный класс. Он работает так же, как еще один уровень «упаковки».

Например, я адепт контролировать значения, передаваемые мои методы так, когда это имеет смысл, я такие вещи, как (очень тупой пример)

public class Calendar { 
    public static enum WeekDay { 
    MONDAY, 
    ... 
    SUNDAY; 
    } 

    public Date getNextDay(WeekDay weekDay) { 
    ... 
    } 
} 

Перечисление полезно только доступ к логике класса, поэтому он определен внутри класса.

И пример в Java API - это класс java.util.Map.Entry<K,V>, который используется реализациями Map, чтобы предоставить доступ к парам значений ключей, которые они хранят.

Answer 2

Объявление:

Fruit interfaceFruit; 

Просто говорит: «объявить переменную interfaceFruit, которая будет использоваться для хранения ссылки на объект, который реализует Fruit

Такая переменная может содержать ссылку. любой класс, при условии, что он реализует интерфейс.И что вы можете сделать с ним, это доступ ко всем методам и константам, которые определены в интерфейсе, потому что Java знает, что независимо от класса, он будет иметь переопределяющие методы, соответствующие объявлениям в Fruit (который в этом случае имеет только apple()).

Эта вещь очень часто используется в Java. Он позволяет использовать переменную для хранения любого объекта, который соответствует контракту, но в нем могут быть разные реализации. Практика называется «Программирование на интерфейс». Очень распространенный пример объявления переменной как:

List<Integer> list; 

(Где List это интерфейс java.util.List), а затем присвоить ей конкретную реализацию:

list = new LinkedList<Integer>(); 
list = new ArrayList<Integer>(); 
list = Arrays.asList(1,5,8,9); 

Какой класс объект, который назначен на (и в случае Arrays.asList вы даже не знаете, какой класс будет), он будет иметь все операции, которые определяет java.util.List - например, add() или iterator().

То же самое относится к вашему интерфейсу Fruit. Тот факт, что он является вложенным интерфейсом, не так важен.