在学习Android事件机制之前，有必要把相关的Java知识先进行一下回顾。与Android事件相关的Java知识主要包括：接口、内部类，下面讲解这些知识点。

1、接口

Java下接口主要描述类应该具备什么功能。接口是一种契约机制，描述了相关的类应遵循一定的、统一的格式定义。在Java中，接口通过关键字Interface定义。例如下面的接口定义：

       该接口描述了这样一种契约，实现该接口的类必须提供findUserName方法，该方法必须要有一个String类型的参数。

       为了让类实现某个接口，只需要一下两步：

1. 通过Implements声明某个类实现特定的接口；
2. 对接口的中所有方法进行定义；

下面给出UserDao接口的实现，如下所示：

这里需要注意的是，在接口中，不用把方法申明为public，因为接口中的方法都是public。但是在实现接口时，必须在实现类里面将对应的方法申明为public，否则方法默认为包可见。

关于接口还有几点要说明：

1. 接口不是类，不能用new实例化；
2. 可以申明接口的变量，但是接口的变量必须复制具体实现类的对象；
3. 可以使用instance检查一个类是否实现了特定的接口，如下所示：

1. 类似于类的继承关系，接口也可以进行继承扩展；
2. 一个类可以实现多个接口，实现的多个接口之间用,分割
3. 接口中可以定义常量
4. 在Java SE 8中，接口可以定义静态方法，但这样的设计有悖于接口抽象机制的初衷，不推荐。
5. 接口可以通过关键字default声明默认方法，提供默认实现，这样实现接口的开发人员可以只覆盖需要的方法，例如下面代码所示：

2、内部类

内部类是定义在一个类里面的类，内部类有以下特点：

1. 内部类方法可以访问外部类的数据
2. 内部类可以对同一个包中的其他类隐藏起来；
3. 通常使用匿名内部类实现回调机制

下面给出一个内部类的样例

    这里我们定义了UserDaoImp类，该类是MyWindow的内部类，此外我们还在MyWinow类的内部定了一个接口StartListener，并在load2方法中，通过一个匿名类实现了该接口。

      这里需要说明的是：

1. 内部类主要用于方法的回调处理；
2. 在内部类可以通过<外部类的名称.this>访问外部类的this指针。
3. 在类的内部也可以定义接口，如上所StartListener

（张伟：2018年9月20日）

（转载时请注明来源）

简介

一般来说，我们创建类和接口的时候都是一个类一个文件，一个接口一个文件，但有时候为了方便或者某些特殊的原因，java并不介意在一个文件中写多个类和多个接口，这就有了我们今天要讲的内部类和内部接口。

内部类

先讲内部类，内部类就是在类中定义的类。类中的类可以看做是类的一个属性，一个属性可以是static也可以是非static的。而内部类也可以定义在类的方法中，再加上匿名类，总共有5种内部类。

静态内部类

我们在class内部定义一个static的class，如下所示：

@Slf4j
public class StaticInnerClass {

    static class Inner {
        void print() {
            log.info("Inner class is: " + this);
        }
    }

    public static void main(String[] args) {
        StaticInnerClass.Inner inner = new StaticInnerClass.Inner();
        inner.print();
    }
}

因为static变量可以直接根据类名来存取，所以我们使用new StaticInnerClass.Inner()来实例化内部类。

非静态内部类

class中定义的类也可以是非静态的，如下所示：

@Slf4j
public class InnerClass {

     class Inner {
        void print() {
            log.info("Inner class is: " + this);
        }
    }

    public static void main(String[] args) {
        InnerClass.Inner inner = new InnerClass().new Inner();
        inner.print();
    }
}

要访问到类的变量，需要实例化外部内，然后再实例化内部类：new InnerClass().new Inner()。

注意这里我们需要使用到两个new。

静态方法内部类

我们可以在静态方法中定义一个类，这个类其实就相当于方法中的变量，这个变量当然不能是static的。我们看下面的例子：

@Slf4j
public class StaticMethodInnerClass {

    private static String x = "static x";

    public static void print() {
        class MyInner {
            public void printOuter() {
                log.info("x is " + x);
            }
        }
        MyInner i = new MyInner();
        i.printOuter();
    }

    public static void main(String[] args) {
        StaticMethodInnerClass.print();
    }
}

方法中的类，我们是无法在外部实例化的。

非静态方法的内部类

同样的非静态方法也可以定义内部类：

@Slf4j
public class MethodInnerClass {

    private  String x = "non static x";

    public  void print() {
        class MyInner {
            public void printOuter() {
                log.info("x is " + x);
            }
        }
        MyInner i = new MyInner();
        i.printOuter();
    }

    public static void main(String[] args) {
        new MethodInnerClass().print();
    }
}

注意，这里需要先实例化外部类才可以继续调用。

匿名类

最后一个，匿名类，直接在需要的时候实例化的类。匿名类我们遇到了很多次了，比如在构建SortedSet的时候，可以传入自定义的Comparator，我们可以用匿名类来实现，也可以直接使用lambda表达式。

public class AnonymousClass {

    public static void main(String[] args) {
        SortedSet sortedSet1 = new ConcurrentSkipListSet(new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        });

        SortedSet sortedSet2 = new ConcurrentSkipListSet((o1, o2) -> 0);
    }
}

内部接口

Inner Interface是指在接口中定义的接口。最常见的就是Map中的Entry了：

public interface Map<K, V> {
    interface Entry<K, V> {
        K getKey();
    }

这里的内部接口一定是static的，因为接口是不能实例化的，所以为了访问到接口中的接口，必须定义为static。如果不指定，则默认就是static。

我们看一个该内部接口的实现：

public class MapImpl implements Map.Entry{
    @Override
    public Object getKey() {
        return 0;
    }

    @Override
    public Object getValue() {
        return null;
    }

    @Override
    public Object setValue(Object value) {
        return null;
    }
}

总结

本文讲解了5个内部类的实现和一个内部接口的应用。大家只要把内部的类或者接口看成一个变量，就可以很好的理解上面的内容了。

本文的例子https://github.com/ddean2009/learn-java-base-9-to-20

更多精彩内容且看：

• 区块链从入门到放弃系列教程-涵盖密码学,超级账本,以太坊,Libra,比特币等持续更新
• Spring Boot 2.X系列教程:七天从无到有掌握Spring Boot-持续更新
• Spring 5.X系列教程:满足你对Spring5的一切想象-持续更新
• java程序员从小工到专家成神之路（2020版）-持续更新中,附详细文章教程

本文作者：flydean程序那些事

本文链接：http://www.flydean.com/inner-class-inner-interface/

本文来源：flydean的博客

欢迎关注我的公众号:程序那些事，更多精彩等着您！

内部类

package Learn.com.seven;

public class ParcellA {//外部类
    
    private int pMember;//声明一个私有成员
    private static int pstMember;//声明一个私有静态成员
    private final int pfMember=9;//常量值
    private final static int pfsMember=0;//常量静态成员
    
    /**
     * 
     *  -#  普通内部类可以访问外部类的所有成员和方法,
     *  -#  如何在其他的类访问此内部类呢
     *  -#  必须使用外部类的对象来创建内部类对象
     *  -#  ParcellA parcel = new ParcellA(); 见Entry.java
     *      ParcellA.Contents content = parcel.new Contents();
     */
    public class Contents{//嵌套定义一个内部类
        private int i = 11;
        
        public int value(){//给内部类，定义的一个方法
            System.out.println(pMember);//所有成员
            System.out.println(pstMember);
            System.out.println(pfMember);
            System.out.println(pfsMember);
            outClassMethod();//可以访问外部类的普通方法
            outClassStaticMehtod();//及静态方法
            return i;
        }    
      
        /**
         * @see 但是若Contesnts是静态的，则可以声明静态成员和静态方法
         */
//        private static int j=0;//非静态内部类，不能声明[静态成员]
//        private static int  out(){//非静态内部类，不能声明[静态方法]        
//        }
    
    }
    /**
     * 
     *    - 定义一个嵌套静态内部类
     *    -# 不能访问外部内的【非静态成员】,只能访问外部类的【静态成员】。同理也不能访问外部类的非静态方法
     *      
     */
    public static class InnerStaticClass{
        private static int memberOfStatic;//可以定义静态成员        
        private static int Out(){//可以定义静态方法
            //outClassMethod();//不能访问外部类的非静态方法
            //System.out.println(pMember);//由于ParcellA,是静态内部类，所以不能访问外部内的非静态成员
              //因为静态类，是在加载类时，就初始化了。而非静态成员，是在创建对象时才初始化，分配内存
              //因此，在静态类初始化时访问外部类的非静态成员时，非静态成员还不存在，所以不能访问
            System.out.println(pstMember);//可以访问静态成员
            System.out.println(pfsMember);//可以访问常量成员.由于final int是不可变的成员，即在程序运行中它的值不可以修改。因此
                          //final成员的值，就可以在加载类时就确定下来。所以在静态内部类访问它时，它是已知的，所以就 
                          //可以访问
            System.out.println(pfsMember);//同上原因，所以可以访问        
            outClassStaticMehtod();//可以访问静态方法            
            return memberOfStatic;
        }    
        
        public void Myout(){
            Out();
        }
    }
   
    class Destination{//定义另一个内部类,注意默认访问权限为包访问权限，不能在另一个包访问
        private String label;
        Destination(String WhereTo){//内部类的构造方法
            label =WhereTo;
        }
        String ReadLabel(){//给内部类，定义的一个方法
            return label;
        }
    }
    
    
    public void outClassMethod(){
        System.out.println("outClass Non_Static Method");
    }
    public static void outClassStaticMehtod(){
        System.out.println("outClass Static Method");
    }
}



package Learn.com.test;
import Learn.com.seven.ParcellA;

public class Entry {

    public static void main(String[] args) {
        ParcellA parcel = new ParcellA();
        //由于Contests这个内部类，是public权限，所以可以访问，
        //但注意必须是用外部类ParcellA的对象来parcel.new 来创建内部类的对象.
        //并且声明内部类的对象时，需要使用ParcellA.Contents 这种"外部类.内部类"的方式
        
        ParcellA.Contents content = parcel.new Contents();
        content.value();
                
        
        //由于Destination,是包访问权限，所以下面的访问错误 
        //ParcellA.Destination desten = parcel.new Destination("china");
        
        //注意，由于InnerStaticClass是ParcellA的静态内部类，所以可以直接用它来创建对象
        //对于这种用法，在android中的布局中用到，比如
        //LinearLayout.LayoutParams params =  new LinearLayout.LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT);
        //LinearLayout.LayoutParams 类就是LinearLayout中的静态内部类，可以通过android的LinearLayout.java源码查看        
        ParcellA.InnerStaticClass obj = new ParcellA.InnerStaticClass();
        obj.Myout();//可以调用public方法    ,只能访问自己的方法,在这里不能直接访问外部类的方法,外部方法对它不可见                    
    }

}

普通内部类

常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。

1. 常规内部类中的方法可以直接使用外部类的实例变量和实例方法。
2. 在常规内部类中可以直接用内部类创建对象

public class MyOuter {
    private int x = 100;
     
    class MyInner{
        private String y="Hello!";
        public void innerMethod(){
            System.out.println("内部类中 String ="+y);
            System.out.println("外部类中的x ="+x);
            outerMethod();
            System.out.println("x is "+MyOuter.this.x);
        }
    }
     
    public void outerMethod(){
        x++;
    }
     
    public void makeInner(){
        //在外部类方法中创建内部类实例
        MyInner in = new MyInner();
    }
     
    public static void main(String[] args){
        MyOuter mo = new MyOuter();
        //使用外部类构造方法创建 mo 常规内部类需要通过外部类实例来new
        MyOuter.MyInner inner = mo.new MyInner();
        inner.innerMethod();
    }
}

应用

@Service("brandShopUgcExecutor")
@Slf4j
public class BrandShopUgcExecutor implements JobExecutor {
   
    private List<Integer> sortReviews(List<ReviewData> reviewDataList) {
        BrandShopUgcExecutor brandShopUgcExecutor = new BrandShopUgcExecutor();
        //使用内部类
        OrderByWeight orderByWeight = brandShopUgcExecutor.new OrderByWeight();
        OrderByFollowNote orderByFollowNote = brandShopUgcExecutor.new OrderByFollowNote();
        Ordering<ReviewData> ordering = Ordering.from(orderByWeight).compound(orderByFollowNote);
        //使用匿名内部类更合适，因为只有这一个地方使用
     Ordering.from(new Comparator<ReviewData>() {

            @Override
            public int compare(ReviewData o1, ReviewData o2) {
                return Doubles.compare(getReviewWeight(o2), getReviewWeight(o1));
            }
        }).compound(new Comparator<ReviewData>() {

            @Override
            public int compare(ReviewData o1, ReviewData o2) {
                return Ints.compare(o1.getFollowNoteNo(), o2.getFollowNoteNo());
            }
        });
        Collections.sort(reviewDataList, ordering);
        List<Integer> reviewIdList = Lists.newArrayList();
        for (ReviewData reviewData : reviewDataList) {
            reviewIdList.add(reviewData.getReviewId());
        }
        return reviewIdList;
    }

    /**
     * 按权重排序
     */
    public class OrderByWeight implements Comparator<ReviewData> {
        @Override
        public int compare(ReviewData r1, ReviewData r2) {
            return Doubles.compare(getReviewWeight(r2), getReviewWeight(r1));
        }
    }

    /**
     * 按回复数排序
     */
    public class OrderByFollowNote implements Comparator<ReviewData> {
        @Override
        public int compare(ReviewData r1, ReviewData r2) {
            return Ints.compare(r1.getFollowNoteNo(), r2.getFollowNoteNo());
        }
    }
}

静态内部类

静态内部类：与类的其他成员相似，可以用static修饰内部类，这样的类称为静态内类。静态内部类与静态内部方法相似，只能访问外部类的static成员，不能直接访问外部类的实例变量，与实例方法，只有通过对象引用才能访问。

public class MyOuter2 {
     
    public static int x=100;
     
    public static class Myinner{
        private String y="Hello!";
        /**
         * 由于static内部类不具有任何对外部类实例的引用，
         * 因此static内部类中不能使用this关键字来访问外部类中的实例成员，
         * 但是可以访问外部类中的static成员。这与一般类的static方法相通
         */
        public void innerMethod(){
            System.out.println("x="+x);
            System.out.println("y="+y);
        }
    }
     
    public static void main(String[] args){
        MyOuter2.Myinner si = new MyOuter2.Myinner();
        si.innerMethod();
    }
    
}

局部内部类

局部内部类：在方法体或语句块（包括方法、构造方法、局部块或静态初始化块）内部定义的类成为局部内部类。
局部内部类不能加任何访问修饰符，因为它只对局部块有效。

1. 局部内部类只在方法体中有效，就想定义的局部变量一样，在定义的方法体外不能创建局部内部类的对象
2. 在方法内部定义类时，应注意以下问题：
   2.1 方法定义局部内部类同方法定义局部变量一样，不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和 abstract修饰
   2.2方法中的内部类可以访问外部类成员。对于方法的参数和局部变量，必须有final修饰才可以访问。
   2.3static方法中定义的内部类可以访问外部类定义的static成员

public class MyOuter3 {
    private int size=5,y=7;
     
    public Object makeInner(int localVar){
        final int finalLocalVar = localVar;
         
        //创建内部类，该类只在makeInner（）方法有效，就像局部变量一样。
        //在方法体外部不能创建MyInner类的对象
        class Myinner{
            int y=4;
            public String toString(){
                return "OuterSize:"+size+" localVar:"+finalLocalVar+"\nthis.y="+this.y;
            }
        }
         
        return new Myinner();
    }
     
    public static void main(String[] args){
        Object obj = new MyOuter3().makeInner(47);
        System.out.println(obj.toString());
    }
}

匿名内部类

定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类的创建，放到与一起完成，或者说在定义类的同时就创建一个类以这种方法定义的没有名字的类成为匿名内部类。
声明和构造匿名内部类的一般格式如下：

   new ClassOrInterfaceName(){
    类体 }

1. 匿名内部类可以继承一个类或实现一个接口，这里的ClassOrInterfaceName是匿名内部类所继承的类名或实现的接口名。但匿名内部类不能同时实现一个接口和继承一个类也不能实现多个接口。如果实现了一个接口，该类是Object类的直接子类，匿名类继承一个类或实现一个接口，不需要extends和implements关键字。
2. 由于匿名内部类没有名称，所以类体中不能定义构造方法，由于不知道类名也不能使用关键字来创建该类的实例。实际上匿名内部类的定义、构造、和第一次使用都发生在同样一个地方。此外，上式是一个表达式，返回的是一个对象的引用，所以可以直接使用或将其复制给一个对象变量。例：

   TypeName obj=new Name（）{
   此处为类体
      }
  同样，也可以将构造的对象作为调用的参数。例：
    
   someMethod(new Name(){
   此处为类体  });*/

内部接口

为了弄清楚内部接口是如何工作的，我们可以拿它与内部类作比较。内部类可以被认为是一个外部类内部定义的一个常规方法。因为一个方法可以被声明为静态和非静态，类似的内部类也可以被声明为静态和非静态。静态类类似于静态方法，它只能访问外部类的静态成员属性。非静态方法可以访问外部类的所有成员属性。

• 一种对那些在同一个地方使用的接口进行逻辑上分组；
• 封装思想的体现；
• 因为接口是不能实例化的，内部接口只有当它是静态的才有意义。因此，默认情况下，内部接口是静态的，不管你是否手动加了static关键字。

public class MyOuter4 {
    private int size=5;
    private int id;
     
    public interface OnClickListener{
        void onClick(int id);
    }
     
    public void onClick(OnClickListener obj){
        obj.onClick(this.id);
    }
     
    public Object makeInner(int localvar){
        final int finallocalvar = localvar;
        return new Object(){
            public String toString(){
                return "OuterSize="+size+"\nfinalLocalvar="+finallocalvar;
            }
        };
    }
     
    public static void main(String args[]){
        Object obj=new MyOuter4().makeInner(67);
        System.out.println(obj.toString());
         
        MyOuter4 m = new MyOuter4();
        m.onClick(new OnClickListener() {
             
            @Override
            public void onClick(int id) {
                System.out.println(id);
            }
        });
    }
}

public class Util {
    public interface Worker {
        void work();
    }
}
  
package com.dao.util;
 
import com.dao.util.Util.Worker;
 
public class Demo implements Worker {
    public void work() {
        System.out.println("Is working");
    }

在这个util类里面封装了会改变的Worker，也就是说，util类里面有自己的算法：一部分是固定，另外一部分是可变的，而这个可变的部分就变成了一个接口（接口是特殊的抽象类其实的意思大概的这个worker可能在不同的工作环境有不同的工作方式，例如work(),onvaction()）所以在类里面放一个接口不是什么新的设计，而是一种思想方式，让代码扩展性更高。

参考：
https://www.cnblogs.com/activity-life/p/3622850.html
https://www.cnblogs.com/as3lib/p/6107915.html（java 四种内部类和内部接口）