kotlin静态内部类和java静态内部类的区别

首先我们看下RecyclerView的ViewHolder的写法，java和kotlin分别用静态内部类进行实现，代码是随意找的：

java静态内部类：

    static class EndViewHolder extends BlocksView.ViewHolder {

        public EndViewHolder(View itemView) {
            super(itemView);
            itemView.setMinimumHeight(ResourceUtil.getDimen(R.dimen.dimen_106dp));
        }
    }

kotlin静态内部类：

    class FeedViewHolder(itemView: View?, context: Context) : RecyclerView.ViewHolder(itemView) {
        var iv_photo: ImageView = itemView?.findViewById(R.id.iv_photo) as ImageView
        var tv_title: TextView = itemView?.findViewById(R.id.tv_title) as TextView
        var tv_time: TextView = itemView?.findViewById(R.id.tv_detail) as TextView
        init {
            tv_title?.typeface = Typeface.createFromAsset(context?.assets, "fonts/FZLanTingHeiS-L-GB-Regular.TTF")

        }
    }

从上面两个代码片段能很明显看出来java的静态内部类需要static关键字修饰，而kotlin直接用class就表示该类为静态内部类。

java普通内部类不用修饰，直接创建即为内部类；而kotlin需要用inner关键字修饰，表示内部类。

详细对比：

java内部类、静态内部类：

/**外部内*/
public class InnerClassJava {

    private int a;

    //静态内部类和非静态内部类的区别
    //非静态内部类,持有外部类的状态的
    public class Inner{
        public void hello(){
            //可以访问到外部类的成员变量
            System.out.println(a);
            System.out.println(InnerClassJava.this.a);
        }
    }
    //静态内部类
    public static class StaticInner{
        public void hello(){
            //不能访问外部类的成员变量
            //System.out.println(a);
        }
    }

    public static void main(String[] args) {
        //如果要实例化非静态内部类Inner
        //Inner inner = new Inner();  //这样肯定是不行的
        //如果是静态内部类就可以随便new了
        //Inner inner = new Inner();


        //首先要实例化外部类
        InnerClassJava innerClassJava = new InnerClassJava();
        //再用外部类的实例去new内部类
        Inner inner = innerClassJava.new Inner();

        //在Java里面写一个匿名内部类
        View view = new View();
        //在java中，匿名内部类就能继承一个类，不能实现接口
        view.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick() {

            }
        });
    }
}

看一下Kotlin中的内部类：

/**外部类*/
open class Outter{

    val a: Int = 0
    //默认静态内部类
    //不能访问外部类的成员变量
    class StaticInner{
        fun hello(){
            //println(a)
        }
    }

    //非静态内部类,关键字inner
    //可以访问外部类的成员变量
    inner class Inner{
        fun hello(){
            println(a)
            println(this@Outter.a)
        }
    }
}

/**定义一个点击监听的接口*/
interface OnClickListener{
    fun onClick()
}

/**定义一个View类*/
class View{
    //可变的
    var onClickListener: OnClickListener ?= null
}
fun main(args: Array) {
    //静态内部类实例化
    val staticInner = Outter.StaticInner()
    //非静态内部类实例化
    val inner = Outter().Inner()

    //注册view
    val view = View()
    //这边涉及到一个匿名内部类，就是没有名字的内部类，继承一下Outter类
    //kotlin中匿名内部类，就和普通的类一样，可以继承一个类，实现多个接口
    view.onClickListener = object: Outter(),OnClickListener{
        override fun onClick() {
            TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
        }
    }
}