文章目录
简介
内部类
静态内部类
非静态内部类
静态方法内部类
非静态方法的内部类
匿名类
内部接口
总结

简介
一般来说，我们创建类和接口的时候都是一个类一个文件，一个接口一个文件，但有时候为了方便或者某些特殊的原因，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的博客
欢迎关注我的公众号:程序那些事，更多精彩等着您！

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

1、接口

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


			
package com.zhangw.crazyandroid;

			
 

			
public interface UserDao {

			
    String findUserName(String id);

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

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

通过Implements声明某个类实现特定的接口；
	
对接口的中所有方法进行定义；
下面给出UserDao接口的实现，如下所示：


			
package com.zhangw.crazyandroid;

			
 

			
public class UserTableDao implements UserDao {

			
    public String findUserName(String id) {

			
        return "zhangw";

			
    }

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

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

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

			
if(userDao instanceof UserDao){

			
   Log.d("接口测试", "是UserDao接口");

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

			
package com.salary.myjava;

			
 

			
public interface UserDao {

			
    String queryNameById(String id);

			
    default String queryOrgById(String id){return id;};

			
}
			
		
2、内部类

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

内部类方法可以访问外部类的数据
	
内部类可以对同一个包中的其他类隐藏起来；
	
通常使用匿名内部类实现回调机制
下面给出一个内部类的样例


			
package com.salary.myjava;

			
 

			
public class MyWindow {

			
    private String title = "111";

			
    private String name = "222";

			
 

			
    // 内部接口

			
    public interface StartListener{

			
        String getWindowTitle();

			
    }

			
   

			
    // 内部类

			
    public class UserDaoImp implements UserDao{

			
        public String queryNameById(String id){

			
            return MyWindow.this.title;

			
        }

			
    }

			
 

			
    public void load(){

			
        UserDao userDao = new UserDaoImp();

			
        System.out.println(userDao.queryNameById("111"));

			
    }

			
 

			
    public void load2(){

			
        //  匿名类

			
        StartListener startListener = new StartListener(){

			
            public String getWindowTitle(){

			
                return MyWindow.this.title;

			
            }

			
        };

			
        System.out.print(startListener.getWindowTitle());

			
    }

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

      这里需要说明的是：

内部类主要用于方法的回调处理；
	
在内部类可以通过<外部类的名称.this>访问外部类的this指针。
	
在类的内部也可以定义接口，如上所StartListener
（张伟：2018年9月20日）

（转载时请注明来源）

接口是对类的一组需求描述。接口中的方法自动的属于public。接口中的属性自动的属于public static final。因此接口中的属性是常量，必须声明的时候进行初始化。
下面是一个接口的示例：

public interface InterfaceM {
    String id="1190";
    void value();
}



实现测试类：

public class Test implements InterfaceM{


    @Override
    public void value() {
        System.out.println("id:"+Test.id);
    }
     
    public static void main(String[] args){
        (new Test()).value();
        
    }
}



运行结果：

run：
id:1190
成功生成（总时间：1 秒）



接口和抽象类的比较
先说一下接口和抽象类的一些区别：
接口的属性是常量；抽象类的属性则没有什么限制，同正常类的属性是一样的。接口的方法都是方法的声明，没有实现，就是没有方法体；抽象类的方法中非抽象方法和正常类的一样，抽象方法要加abstract修饰，同时没有方法体。更深层次的区别是接口时一种双方交互的协议；抽象类则是一种类型的限定，一种提供公共属性和方法的载体。
更底层的区别是Java选择单继承多实现的原因是多继承会让语言本身变得更加复杂，效率也会降低。


内部类
使用内部类的原因有三点：
内部类可以访问该类作用域中所有的数据，包括私有数据
内部类可以对同一个包中的其他类隐藏起来
当想要定义一个回调函数且不想编写大量的代码时，使用匿名内部类比较便捷。


先看下面的一个例子：

public class Test{
    private String id="1899";


    private void detai(){
       System.out.println("I am a private method in Test class!");
    }
    
    public class Inner{
       public void info(){
          System.out.println("id:"+id);
          
          detai();
          System.out.println("I am a inner class method");
       }
    }
    
    public void value(){
       Inner inner=new Inner();
       inner.info();
       System.out.println("I'm a public method in Test class!");
    }
   


     
    public static void main(String[] args){
       Test test=new Test();
       test.value();
        
    }
}
运行结果：
run：
id:1899
I am a private method in Test class!
I am a inner class method
I'm a public method in Test class!
成功生成（总时间：0 秒）
从这里面可以看见一些内部类的语法规则：
可以毫无限制的引用外部类的属性和方法，private限定不起作用
外部类引用内部类可以像引用其他类一样的引用方式，static参照其他的普通类一样使用。



下面是局部内部类的情形：

public class Test{
    private String id="1899";


    private void detai(){
       System.out.println("I am a private method in Test class!");
    }


    public void value() {
        class Inner {
            public void info() {
                System.out.println("id:" + id);
                detai();
                System.out.println("I am a inner class method");
            }
        }
        Inner inner = new Inner();
        inner.info();
        System.out.println("I'm a public method in Test class!");
    }
   


     
    public static void main(String[] args){
       Test test=new Test();
       test.value();
        
    }
}



如果内部类没有引用外部类的非静态属性和方法，可以把内部类声明为static，来消去对外部类的引用。


一般在开发中最常用的是接口，内部类多用在swing等图形界面开发添加Listener的时候使用。

大家面试的时候肯定被问过java 接口、抽象类、类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。(主要是总结了下网上的资料，不是自己原创的。)总结的不好，请勿喷。^_^
java 接口：
 使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下：


[修饰符] interface 接口名 [extends 父接口名列表]{
[public] [static] [final] 常量;
[public] [abstract] 方法;
}
修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。
接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。（个人习惯：在接口类名前先写一个I_后面跟着接口名称）
extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。
方法：接口中的方法只有定义而没有被实现。

接口中可以定义变量和方法，但是一般人不会在接口中定义变量，因为在接口中定义的变量会被隐式的定义为public
 static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误）。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法，编译器会编译不过去，就会报错。并且接口中所有的方法不能有具体的实现。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法，编译器会编译不过去，就会报错。并且接口允许任何类去实现它，一个类如果实现一个接口，那么这个类就要把这个借口中的所有方法都实现了。
所以说java接口中的方法都是极度抽象的类型，它比抽象类更加严格的“抽象”。
其实java中的接口是为了解决java中单继承而来的，大家都知道，java中一个类只能有继承一个父类，不像C++中可以多继承，一个孩子可以有多个爸爸。java严格按照我们生活中的人与人的关系，一个孩子只能有一个爸爸，但是可以有多个干爹（现在的干爹都不靠谱啊，原因你懂的。），一个孩子可以继承父亲的所有遗产，但是也可以拥有多个干爹的遗产，前提是他的干爹愿意把遗产给他。（这里指的是别的接口中的方法）。
java 抽象类：
下面是java抽象类的定义语法。
public abstract class Demo01 {

	public abstract void addUser();//抽象方法
	
}
java抽象类必须要以abstract  来进行修饰，抽象类可以继承抽象类。一个类中存在一个抽象方法，那么这个类必须要定义成抽象类。java中抽象类的访问控制修饰符默认是public类型的，抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。因为，抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用synchronized关键字修饰了；native这个东西本身就和abstract冲突，他们都是方法的声明，只是一个把方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
  总之：抽象类是提取具体类的公因式。
java 内部类：
java内部类一般使用不是很多，但是其实也很好理解。就是一个类中再次定义了一个类。可以理解为在一个大的厂房里面又盖了个小的厂房。大厂房有它自己的构造组成。小厂房也是有小厂房的构造组成的。内部类破坏了良好的代码结构，但是我们平时还是需要用到的，因为内部类可以随意使用外部类的属性和方法。
下面是内部类访问外部类的示例及内部类的基本格式：
package test;

public class test {
	private String name = "小熊猫";
	
	
	class in {
		private String name = "丢丢";
		
		public void sal(){
			String name = "小熊猫丢丢";
			
			System.out.println("局部变量name:"+name);
			System.out.println("内部类变量name:"+this.name);
			System.out.println("外部类变量name:"+test.this.name);
			
		}
		
	}
	
	public static class ma {
		public static void main(String[] args) {
			test.in in = new test().new in();
			in.sal();
			
		}
	}

}



其实java内部类也是一个类，与其他类不同的是内部类是类中类，它的作用范围只能在这个类中。



java 匿名内部类：
匿名内部类的定义语法如下：


new 父类构造器（参数列表）|实现接口（）    
    {    
     //匿名内部类的类体部分    
    } 
虽然看上去很简单，但是还有一些注意事项需要我们注意的：
1：使用匿名内部类必须实现一个接口或者继承一个类，但是鱼和熊掌不可兼得，至于是继承类还是实现接口需要根据业务要求去走了。
2：匿名内部类中不可以定义构造函数。
3：匿名内部类中不可以有任何静态方法和静态成员变量(这个是因为静态方法或者静态成员变量在加载的时候会直接加载，而普通的成员变量或方法需要在类加载的时候才会去       加载)

4：匿名内部类也是局部内部类，所以局部内部类的限制对匿名内部类同样有效。
5：匿名内部类不能是抽象的，它必须要实现继承的类或者实现接口中所有的抽象方法。




关于java类的一些类就先写到这了，下面会陆续写一些关于多线程与高并发的一些文档，如有一些不对的地方欢迎大家指出，大家共同学习共同进步。