Innere Klasse innerhalb einer Schnittstelle, die dieselbe Schnittstelle implementiert, was erreichen wir dadurch?

Question

Ich schaute auf den Quellcode von TextWatcher und ich habe das Konzept hier nicht erhalten Welchen Sinn hatte die Erweiterung auf NoCopySpan?

TextWatcher.java:

public interface TextWatcher extends NoCopySpan { 
    public void beforeTextChanged(CharSequence s, int start, int count, int after); 
    public void onTextChanged(CharSequence s, int start, int before, int count); 
    public void afterTextChanged(Editable s); 
} 

NoCopySpan.java:

package android.text; 

/** 
* This interface should be added to a span object that should not be copied into a new Spanned when performing a slice or copy operation on the original Spanned it was placed in. 
*/ 
public interface NoCopySpan { 
    /** 
    * Convenience equivalent for when you would just want a new Object() for 
    * a span but want it to be no-copy. Use this instead. 
    */ 
    public class Concrete implements NoCopySpan {} 
} 

Answer 1

NoCopySpan ist nur ein marker interface. Laut javadoc wird es verwendet, um das Verhalten der Kopierroutine von Spanned Objekten zu modifizieren (es hängt vom Typ der Komponenten ab). Zum Beispiel verwendet android.text.SpannableStringBuilder solche Vererbungsinformationen, um das Kopieren von Bereichen nach der Konstruktion zu überspringen.

Dieser Ansatz hat einige Nachteile, aber immer noch ziemlich häufig. Der Grund der Concrete Klassenexistenz ist es, eine bequeme Möglichkeit zu bieten, eine On-Op-Dummy (oder Standard) -Realisierung der NoCopySpan Schnittstelle zu konstruieren.

Answer 2

Wie für die Spezifikation der Schnittstelle NoCopyScan, die innere Klasse, die die gleiche Schnittstelle implementieren kann als Standardimplementierung/Darstellung der Schnittstelle überall außerhalb verwendet werden.

Ein inner class in an interface wird implizit als statische innere Klasse behandelt. Wir können die innere Klasse der Schnittstelle wie eine statische innere Klasse instanziieren und NoCopyScan verwenden. Hier finden Sie ein einfaches Beispiel die Verwendung von Standard-Implementierung der Schnittstelle mit Hilfe der inneren Klasse zeigt unter:

/* package whatever; // don't place package name! */ 

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

/* Name of the class has to be "Main" only if the class is public. */ 
interface NoCopy{ 

public void doStuff(); 

public class Conc {    //Inner Class 
    public int retStuff(){ 
     return 2; 
    } 
    } 




// public void doStuff(){ 
//  System.out.println("Overriding in inner class"); 
// } 
} 


class ConcOut { 

    public int returnStuff(){ 
     return 5; 
    } 


    public void doStuff(){ 
     NoCopy.Conc innerObj = new NoCopy.Conc(); //Instantiating inner class 
     //NoCopy.Conc innerObj = (new ConcOut()).new Conc(); 

     System.out.println("overriding in outside class ConcOut "+ innerObj.retStuff());        // calling the method of inner class 
    } 
} 

class Ideone 
{ 
    public static void main (String[] args) throws java.lang.Exception 
    { 
     // your code goes here 
     ConcOut conObj = new ConcOut(); 
     conObj.doStuff(); 
     //ConcOut.Conc concInner = conObj.new Conc(); 

    } 
}