Java内部类简单理解

1 什么是Java的内部类

• 定义在类内部的类称为内部类，外层的类称为外部类

2 Java内部类分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

3 成员内部类

3.1特点：

1、内部类可以直接访问外类的元素（成员变量、成员方法，私有的也可以访问），外部类访问内部类的元素（成员变量、成员方法）必须实例内部类的对象进行访问。
2、外部类和内部类同名的调用方式：

• • 外部类的成员变量和内部类成员变量同名时，内部类的成员方法调用同名的变量，优先调用内部类的成员方法，也可以通过this.成员变量名，this代表的内部类本类对象。
• • 访问外部类的对象可以通过外部类的类名.this.外部变量名
    3、可以实现多继承，内部类可以继承外部类。
    4、内部类的地位就相当于是成员变量。

3.1.1 内部类调用外部类的变量和方法

//内部类调用外部类的变量和方法
public class Test5 {
    public static void main(String[] args) {
        //实例化内类的对象
        //第一种方式
        outer outer=new outer();//实例化外部类的对象
        outer.inner inner1=outer.new inner();

        //第二种方式
        outer.inner inner=new outer().new inner();
        inner.show();
    }
}
class outer{
    private int a=10;//外部类的成员变量
    private int b=20;//外部类的成员变量
    public  class inner{
        int a=11;//内部类的成员变量
        int b=30;//内部类的成员变量
        public void show(){
            System.out.println(a);//打印外部类的成员变量
            System.out.println(b);//就近原则打印内部类的成员变量
            System.out.println(this.a);//打印内部类的成员变量
            System.out.println(outer.this.b);//打印外部类的成员变量

        }
    }
}

3.1.2 外部类调用内部类的方法和变量

public class Test6 {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.outshow();
    }
}
class Outer{
    private int a=10;//外部类的成员变量
    private int b=20;//外部类的成员变量

    //外部类的成员方法(内部类的成员变量a和b相加)
    public void outshow(){
        //实例化内部类的对象
        Inner inner=new Inner();
        int c=inner.a+inner.b;
        System.out.println(c);
        inner.show();

    }
    public class Inner{
        int a=11;//内部类的成员变量
        int b=30;//内部类的成员变量
        public void show(){
            System.out.println("这个内部类的成员方法");

        }
    }
}

4 静态内部类

• 在一般情况static是不会修饰类的，只修饰构造代码块，成员方法
  、成员变量，修饰类只有一种情况就是静态内部类

4.1 特点

• 静态内部类不能直接访问外部普通方法，可以通过对象进行访问，可以直接访问外部类静态方法和静态变量；
• 静态类里面有普通的成员方法和成员变量，普通的内部类中不能有静态的成员方法和变量；

4.1外部类访问静态内部类变量和方法

package com.xiaozeng;

public class Test7 {
    public static void main(String[] args) {
        //调用静态内部类的方法
        outer.inner inner=new outer.inner();
        String abc = inner.abc;
        System.out.println(abc);
        inner.show();
    }
}
class outer{

    public static class inner{
        String abc="我是静态的成员变量";
        public void show(){
            System.out.println("我是静态内部类的方法");
        }
    }
}

4.2 静态内部类访问外部变量和方法

package com.xiaozeng;

public class Test7 {
    public static void main(String[] args) {
        //调用静态内部类的方式
        Outer.inner staticinner=new Outer.inner();
        staticinner.show();
    }
}
class Outer{
    public static String abc="我是外部类的静态变量";

    public String cde="我是外部类的普通变量";

    public static void abc1(){
        System.out.println("我是外部类的静态方法");
    }
    public  void  cde1(){
        System.out.println("我是外部类的普通方法");
    }
    public static class inner{

        public void show(){
            //调用外部类的静态方法/变量
            System.out.println(Outer.abc);
            Outer.abc1();
            //调用外部类的普通方法/变量
            Outer outer=new Outer();
            System.out.println(outer.cde);
            outer.cde1();
        }
    }
}

4.3 静态内部类使用

• bulider设计模式在我的另外一篇博文里面，有兴趣，可以看看

5、局部内部类

• 定义在方法内部的类

5.1 局部内部类的特点

• 不能被访问修饰符（public protect default private）和static修饰，作用域在方法内部；
• 可以访问外部类的成员变量、成员方法。如果局部；内部类是static是静态类，则只能访问外部类的静态的方法；
• 可以被final、abstract修饰，局部内部类只能访问final修饰的变量(JDK8以后局部内部类可以访问最终变量，即没有被final修饰只被赋值过一次的变量)；
• 如果调用的同名的外部类变量可以通过外部类.this.方法名；
• 内部类也会生成一个编译文件Outer$1Inner.class；

package com.xiaozeng;

public class Test8 {

    public static void main(String[] args) {
        OuterOne outerOne=new OuterOne();
        outerOne.inner();
    }

}
class  OuterOne {
    private String a="外部类的成员变量";
    private void outshow(){
        System.out.println("外部类的成员方法");
    }
    //定义一个方法并在里面定义一个内部类并打印
    public  void  inner(){
        //定义外部类的局部变量
        String bc="方法中的局部变量";
        bc="方法中的局部变量2";
        //被final修饰的局部变量
        final String c="外部类的局部变量";
        final String a="方法中的局部变量";
        //内部类
         class Inner{
             //打印变量
             public void print(){
                 //打印外部的类的成员方法和变量
                 System.out.println(a);
                 System.out.println(OuterOne.this.a);
                 outshow();
                 //打印方法内部的成员变量
//                 System.out.println(bc);//编译错误，因为bc被修饰过2次所以，不能被访问
                 System.out.println(c);
             }
        }
        new Inner().print();


    }

}

6 匿名内部类

6.1 什么是匿名内部类

• 是内部类的简写，实际上是父接口和父类的实现子类的对象

6.2 匿名内部类的特点

• 必须是继承一个父类或者实现一个接口；
• 当程序中只使用一次对象，可以使用匿名内部类；
• 匿名内部类是对类名的省略，匿名对象是对象名的省略；

package com.xiaozeng;

public interface Test9 {
    void show();
}

class inner{
    public static void main(String[] args) {
        Test9 test9 =new Test9(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        test9.show();
    }
}