卑微内部类，在线自夸（非静态、静态、局部、匿名）

什么是内部类

将一个类的定义放在另一个类的定义内部（嵌套类），这就是内部类。

 

内部类有什么用

内部类允许你将一些逻辑相关的类组织在一起，内部类了解外部类并能与之通信。

在某个角度来讲，内部类实现了多重继承。（每个内部类都可以独立继承（接口的）实现，无论外部类有没有继承实现。）

 

怎么用内部类

public class out{//外部类

    class in{//内部类
        int i=0;
        public int test(){}
    }


    //比较典型的情况是，外部类有一个可以返回内部类对象的方法
    public in to(){
        return new in(); //创建并初始化一个内部类对象
    }



    public static void main(String[] args){
        out o = new out();
        //如果想要在外部类的非静态方法中创建内部类对象
        //那么必须具体指明对象的类型：OuterClassName.InnerClassName
        out.in  i =o.to(); 
    }

}

当我们在外部类方法中使用内部类的时候，与使用普通类是没有区别的。

 

内部类了解外部类并能与之通信，这是怎么做到的呢？

当生成一个内部类对象时，此对象就和外部类对象产生了联系：创建内部类对象会悄咪咪的捕获一个外部类对象引用！当你用内部类对象访问外部类成员时，这个秘密引用就派上用场了。这就是内部类能够使用外部类的原因！所以内部类对象可以无条件的访问外部类对象的所有成员！

 

咱们再来看看这句话“创建内部类对象会悄咪咪的捕获一个外部类对象引用！”在暗示什么？同学们！！

暗示创建内部类对象前，外部类对象就已经存在咯~

所以这句话也是创建内部类对象需要用外部类对象来创建的原因（静态内部类除外，读者大人自己想想为什么吧~）

//所以当你想直接创建内部类对象时，你不能像下面这样
in i =new in();

//你得使用外部类对象来创建内部类对象
out.in i = out.new in();
//完美（绕晕）~

 

读者OS：哇，你说了一堆，我感觉内部类又麻烦又没啥用。。。

作者：我也觉得。。。。

内部类：“慢！我可以秀！！”

卑微内部类，在线自夸

你们知道，作为一个有尊严的类，我们是可以设置自己的访问权限的，如果我把自己设置为private，那么如下

class out{
    private class in_1{
        //private内部类:只有外部类看得到我能访问我，其他类不能访问。
    }
       
    protected class in_2{
        //protected内部类：只有外部类+与外部类同一个包的类+我的子类可以才可以访问我
    }

}

这样有什么好处咧，通过这种方式可以完全阻止任何依赖于类型的编码，并且完全隐藏了实现的细节。

 

内部类：等等，我是不是，把自己。。。给秀没了（完全隐藏）。。。。

内部类：别着急别着急...（我开始慌了）对于金主爸爸们的各种需求，我还能分化出各种内部类。。。

 

非静态内部类

非静态内部类其实就是上面的例子，咱们再加几个知识点下去。

public class out{//外部类
    int num = 30;
    class in{//内部类
        int num=20;
        public int test(){
            int num = 10;
            System.out.println("局部变量num："+age);
            //10 局部变量，直接变量名

            System.out.println("内部类成员变量num："+this.age);
            //20 内部类成员变量:this.变量名

            System.out.println("外部类成员变量num："+out.this.age);
            //30 外部类成员变量：外部类名.this.变量名
        }
    }

    public static void main(String[] args){
        out.in  i = new out().new in();//创建内部类对象
    }

}

非静态内部类里不允许有静态方法、静态变量和静态初始化块。

Why？

1、非静态内部类是类实例的一部分，而不是类的一部分（静态变量是类的一部分，与实例无关），两者冲突。

2、人家都叫非静态内部类了，就别弄静态去抢静态内部类的饭碗了。

 

外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类变量、创建实例。

 

那想要内部类里有静态方法咋整咧？咱们就来到了静态内部类啦，

静态内部类

class out{
    static class in{

    }
}

创建静态内部类对象
out.in  i = new out.in();//注意：没有创建外部类对象哟~

静态内部类是个独立boy，它不再需要依托外部类了。它可以看作是外部类的一个静态成员。

 

静态内部类和非静态内部类的区别：

1、静态内部类不依托外部类，也就没有对外部类的引用了。

2、非静态内部类不能声明static。

 

 

 

 

局部内部类

在一个方法的任意位置内定义内部类，这种内部类叫做局部内部类。

局部内部类有什么用呢？

1、实现了某类型的接口，可以创建并返回对其的引用。

2、需要解决一个复杂问题时，打算创建一个类来辅助解决问题，但不希望这个类是公共可用的。（啊，我闻到了一丝private内部类的味道）

//代码出自《Java编程思想》（是的，我顶不住了，小小的脑袋放弃了思考）

public class Parcel5{
   
    public Destination destination(String s){
        class PDestination{
            
        }
    }
    //PDestination类是Destination方法的一部分，而不是Parcel5类的一部分
    //除了Destination方法可以访问PDestination类外，其他均不能访问。
    //即：方法外不能访问局部内部类。
}

方法外不能访问局部内部类！

与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

这不还是把自己秀没了么。。。

 

匿名内部类

不仅能把自己藏起来，连名字都可以秀没。。

没有名字的内部类就是匿名内部类，它适合那些只需要用一个的类，比如键盘监听。

public class Parcel7{
    public Contents contents(){
        return new Contents(){    //“不配”拥有姓名
            private int i=0;
            public int value(){return i;}
        }
    }
}

//它相当于

public class Parcel7{
    class myContents implements Contents{
        private int i=0;
        public int value(){return i;}
    }
    
    public Contents contents(){return new myContents();}

}

当你想要匿名内部类使用在外部定义的对象时，编译器希望它的参数引用是final

public class Parcel9{
    public Destination destination(final String dest){  //final 警告
        return new Destination(){
            private String label = dest;   //用到了外部类的对象
        }
    }
}

匿名内部类的特点：

1、只能有一个实例。

2、不能有构造方法。

3、不能定义static