JavaSE 内部类

内部类

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。假设需要创建Cow类，Cow类需要组合一个CowLeg对象，CowLeg类只有在Cow类里才有效，离开Cow类之后没有任何意义。在这种情况下，就可以把CowLeg类定义成Cow的内部类，不允许其他类访问CowLeg类。

内部类的访问规则；
1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式是
外部类名.this
代码第十一行
Outer.this.x —– 输出3
this.x ————- 输出4
x ——————- 输出6
2，外部类要访问内部类，必须建立内部类对象。

class Outer{    private int x = 3;    class Inner {  //内部类        int x = 4;        void function(){            int x = 6;            System.out.peintln("inner :"+Outer.this.x);        }    }     void method(){        Inner in = new Inner();        in.function();    }}class InnerClassDemo{    public static void main(String[] args){        outer out = new Outer();        out.method();        /*        直接访问内部类中的成员        Outer.Inner in = new Outer().new Inner();        in.function();        */    }}

访问格式；
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他 类中。可以直接建立内部类对象。

格式
外部类名.内部类名 变量名 = 外部类对象.内部对象；
Outer.Inner in = new Outer().new Inner();

2当内部类在成员位置上.就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
private class Inner{}

静态内部类
static：内部类就具备了static的特性。
static class Inner{} //静态内部类
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中如何直接访问静态内部类的非静态成员呢？

class Demo1_InnerClass {    public static void main(String[] args) {        //外部类名.内部类名 对象名 = 外部类名.内部类对象;        Outer.Inner oi = new Outer.Inner();        oi.method();    }}class Outer {    static class Inner {        public void method() {            System.out.println("method");        }    }}

new Outer.Inner().method();
new一个内部类对象来调用method 方法。

在外部其他类中，如何直接访问静态内部类的静态成员呢？就是将public void method(){} 变为 public static void method(){}.

Outer.Inner.method()；

注意：
当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。

---

局部内部类

局部内部类,只能在其所在的方法中访问

class Demo1_InnerClass {    public static void main(String[] args) {        Outer o = new Outer();        o.method();    }}//局部内部类class Outer {    public void method() {        final int num = 10;        class Inner {            public void print() {                System.out.println(num);            }        }        Inner i = new Inner();        i.print();    }}

• 局部内部类访问局部变量必须用final修饰

  • 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
    因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

    但是jdk1.8取消了这个事情,所以我认为这是个bug
    如果不加final，内存变化如图所示
    

---

匿名内部类

匿名内部类是局部内部类的一种，必须写在方法里。匿名内部类就是内部类的简化写法。
（1）前提：存在一个类或者接口
*这里的类可以是具体类也可以是抽象类。
（2）格式：

new 类名或者接口名(){    重写方法;}

（3）本质是什么呢?
*是一个继承了该类或者实现了该接口的子类匿名对象。

首先演示内部类实现接口

class Demo{    public static void main(String[] args) {        Outer o = new Outer();        o.method();    }}interface Inter {    public void print();}class Outer {    class Inner implements Inter {        public void print() {            System.out.println("print");        }    }    public void method(){          new Inner().print();    }}

匿名内部类实现接口

class Demo {    public static void main(String[] args) {        Outer o = new Outer();        o.method();    }}interface Inter {    public void print();}class Outer {    public void method(){               new Inter() {                       //实现Inter接口            public void print() {           //重写抽象方法                System.out.println("print1");            }        }.print();    }}

匿名内部类只针对重写一个方法时使用

练习

    按照要求，补齐代码    interface Inter { void show(); }    class Outer { //补齐代码 }    class OuterDemo {        public static void main(String[] args) {              Outer.method().show();          }    }        要求在控制台输出”HelloWorld”

outer调用完method方法后还能调用show方法，说明method方法返回的是一个Inter的一个子类对象

class Test2_NoNameInnerClass {    public static void main(String[] args) {        //Outer.method().show();            //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象        Inter i = Outer.method();        i.show();    }}interface Inter {     void show(); }class Outer {     //补齐代码     public static Inter method() {        return new Inter() {               //代表返回Inter的子类对象            public void show() {                System.out.println("show");            }        };    }}