第九章_Java中的内部类

第九章_Java中的内部类

内部类

​ 内部类就是在一个类中定义另一个类。如在类A的内部中定义类B，那么类B就是一个内部类。

1.内部类的分类

​ 1.在类的成员位置：成员内部类

​ 2.在类的局部位置：局部内部类

​ 3.定义在方法内部（特殊的局部内部类）：匿名内部类

2.内部类的基本使用

内部类定义格式

/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

public class Outer {
    public class Inner {
        
    }
}

3.内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，不能直接访问，必须创建对象访问

代码演示：

public class Outer {
    private int num = 10;
    //创建内部类
    public  class Inner{
        public void show() {
            //内部类可以直接访问外部类的成员，包括私有
            System.out.println("内部类中的show方法执行了"+num);
        }
    }
    public void method(){
        //外部类调用内部类需要创建对象
        //创建内部类的对象，并访问内部类中的show方法
        Inner i = new Inner();
        i.show();
    }
}
class Test{
    public static void main(String[] args) {
        //创建外部类对象，调用method方法
        Outer outer = new Outer();
        outer.method();
    }
}

执行效果：

4.成员内部类

• 成员内部类的定义位置
  • 在类中方法，跟成员变量是一个位置
• 外界创建成员内部类格式
  • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
  • 举例：Outer.Inner oi = new Outer().new Inner();

代码演示：

public class Test {
    public static void main(String[] args) {
        //创建成员内部类对象
        //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inner inner = new Outer().new Inner();
        System.out.println(inner.a);
            inner.show();
    }
}
class Outer{
    int a = 20;

    class Inner {
        int a = 10;

        public void show() {
            int a =30;
            System.out.println("Inner...show");
            System.out.println("Outer...a:" + new Outer().a);
            System.out.println("Inner...a"+new Outer().new Inner().a);
            System.out.println("Inner...a"+this.a);
            System.out.println("show...a"+a);
        }
    }
}

执行效果：

私有成员内部类

​ 私有成员内部类，外界不能创建内部类的对象，只能通过外部类提供的方法访问

​ 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

代码演示：

public class Test2 {
    public static void main(String[] args) {
        //私有内部类不能创建内部类的对象
//        Out.In in = new Out().new In();
        Out out = new Out();
        out.method();
    }
}
class Out{
    private class In{
        public void show() {
            System.out.println("in...show");
        }
    }
    
    public void method(){
        In in = new In();
        in.show();
    }
}

执行效果

静态成员内部类

• 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
• 静态成员内部类中的静态方法：外部类名.内部类名.方法名();

public class Test3 {
    public static void main(String[] args) {
        //创建静态内部类对象
        Outer3.Inner3 inner3 = new Outer3.Inner3();
        //调用方法方式1
        inner3.show();
        //调用方法方式2
        Outer3.Inner3.show();
    }
}
class Outer3{
    static class Inner3{
        public static void show(){
            System.out.println("Inner3...show");
        }
    }
}

执行效果：

5.局部内部类

• 局部内部类定义位置
  • 局部内部类是在方法中定义的类
• 局部内部类调用方式
  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

代码演示：

public class Test1 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

class Outer{
    int a = 10;

    public void method(){
        int c = 50;
        class Inner{
            int b = 20;
            public void show(){
                System.out.println("Inner...show");
                System.out.println(a);
                System.out.println(b);
                System.out.println(c);
            }
        }

        Inner inner = new Inner();
        inner.show();
    }
}

执行效果：

6.匿名内部类

• 匿名内部类的前提

  • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 匿名内部类的格式

  • 格式：new 类名 ( ) { 重写方法 }

    ​ new 接口名 ( ) { 重写方法 }

  • 举例：

    new Inter(){
        @Override
        public void method(){}
    } 
    

• 匿名内部类的本质

  • 本质：是一个继承了该类或者实现了该接口的子类匿名对象

• 匿名内部类的细节

  • 匿名内部类可以通过多态的形式接收

    Inter i = new Inter(){
      @Override
        public void method(){
            
        }
    }
    

匿名内部类调用方法的形式

代码演示：

public class Test {
    public static void main(String[] args) {
        //传统：先创建实现类对象再调用方法
        InterImpl inter = new InterImpl();
        inter.show();

        //匿名内部类直接调用方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类重写");
            }
        }.show();

        //传统创建对象起名后再调用方法
        Inter2 inter2 = new Inter2(){
            @Override
            public void show1() {
                System.out.println("重写show1");
            }
            @Override
            public void show2() {
                System.out.println("重写show2");
            }
        };
        inter2.show1();
        inter2.show2();
    }
}

interface Inter{
    void show();
}

interface Inter2{
    void show1();
    void show2();
}

class  InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("实现类重写show方法");
    }
}

执行效果：

具体使用场景

代码演示：

public class Test {
    public static void main(String[] args) {
        new Animal(){
            @Override
            public void eat() {
                System.out.println("动物都吃饭");
            }
        }.eat();
    }
}
interface Animal{
    void eat();
}

执行效果：