内部类

概念

在一个类的内部再定义一个完整的类

特点

编译之后可以生成独立的字节码文件

可以访问外部类的私有成员、而不直接破坏封装

可以为外部类提供一些必要的内部功能组件

成员内部类

与实例变量、实例方法相同级别的类

成员内部类不能定义静态成员，但是可以包含静态常量

是外部类的一个实例部分，创建内部类对象时必须依赖外部类对象

如果内部类与外部类属性重名，优先访问内部类的属性，此时访问外部类 类名.this.属性名

代码

public class MemberInner {
    public static void main(String[] args) {
        //在使用时先定义外部类对象，再通过外部类对象定义内部类
        //第一种写法
       /* Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();*/
        //第二种写法
        Outer.Inner inner = new Outer().new Inner();
        //访问内部类的方法
        inner.innerPrint();
    }
}

//Outer类
class Outer{
    //定义在外部类的属性
    private String outer = "Outer";
	private int id = 1111;
    
    //Inner类
    class Inner{
        // 定义在内部类的属性
        private String innerName = "Inner";
		private int id = 2222;
        
        //在内部类中定义一个方法访问 Outer 和Innner 的属性
        public void innerPrint(){
            System.out.println("outer==>" + outer);
            System.out.println("Inner==>" + innerName);
            
           //当重名时访问内部类属性和外部类属性
            System.out.println("内部类==>" + id);
            System.out.println("外部类==>" + Outer.this.id);
        }
    }
}

结果：

outer>Outer
Inner>Inner
内部类>2222
外部类>1111

静态内部类

和外部类同一级别

不依赖外部对象

可以直接创建或通过类名访问

可声明静态成员

代码

public class StaticInner {
    public static void main(String[] args) {
        //直接创建静态内部类类名
        Outer.Inner inner = new Outer.Inner();
        inner.innerPrint();
    }
}

class Outer {
    //定义在外部类的属性
    private String outerName = "Outer";

    //Inner类   ------ 在成员内部类的基础上用static修饰
    static class Inner {
        // 定义在内部类的属性
        private String innerName = "Inner";
        private static int count = 1000;


        //在内部类中定义一个方法访问 Outer 和Innner 的属性
        public void innerPrint() {

            //访问外部类属性
            Outer outer = new Outer();
            System.out.println("outerName==>" + outer.outerName);

            System.out.println("innerName==>" + innerName);
        }
    }
}

局部内部类

定义在外部类的方法当中，作用范围和创建对象范围仅限于当前方法

在JDK1.7以前，局部内部类要想访问外部类的局部变量，因为无法保证变量的生命周期和自身相同，所以该变量必须加final变为常量，JDK1.8以后可以不用加，默认是final

代码

public class LocalInner {
    public static void main(String[] args) {
        //先创建外部类对象并调用方法
        Outer outer = new Outer();
        outer.show();
    }
}

class Outer{
    private String name1 = "张三";

    public void show(){
        int age = 20; //局部变量

        //定义局部内部类
        class Inner{

            //局部内部类中的属性
            private String name2 = "李四";

            public void show2(){
                //访问外部类的属性
                System.out.println(name1);

                 //访问内部类的属性
                System.out.println(name2);
            }
        }

        //在外部类Outer的方法内部创建局部内部类Inner的对象
        Inner inner = new Inner();
        inner.show2();
    }
}

匿名内部类

即没有类名的局部内部类(一切特征都与局部内部类相同)

必须继承一个父类或者一个接口

只能创建一个该类的对象

代码

//创建了一个接口
public interface TranslateImp {
    String tranlate(String word);
}

public class AnonymityInner {
    public static void main(String[] args) {

      /*  //局部内部类  ----- 在main类中创建了一个内部类
       class Dict implements TranslateImp{

           @Override
           public String tranlate(String word) {
               return "你好";
           }
       }

        Dict dict = new Dict();
        String hello = dict.tranlate("hello");
        System.out.println(hello);
*/

        //匿名内部类
        TranslateImp translateImp = new TranslateImp() {
            @Override
            public String tranlate(String word) {
                return "你好";
            }
        };

        // 调用
        String hello = translateImp.tranlate("hello");
        System.out.println(hello);

    }
}

内部类