Java内部类

内部类

一个类内部包含另一个类，就是套娃
在定义一个类的时候，可以在这个类里面在套一个类，这样在外部类中就可以实例化这个内部类，使用这个内部类的方法
分两种：成员内部类，局部内部类

成员内部类

就是在外部类里直接定义作为这个类的成员的类
格式:

1
2
3
4
修饰符 class 外部类名称 {
    修饰符 class 内部类名称{
    }
}

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Car { //外部类
    public class Engine { //内部类
        public void run(){ //内部类方法
            System.out.println("I am running");
        }
    }

    public void go() { //外部类方法
        System.out.println("I am going");

        Engine engine = new Engine(); //实例化一个内部类对象
        engine.run();
    }
}
  • 内部类用外部类的方法随意使用
  • 外部类用内部类需要实例化内部类对象

使用成员内部类方法
1.间接方法: 在外部类的方法中，使用内部类，然后只调用外部类的方法
2.直接方法: 外部类名称.内部类名称 对象名称 = new 外部类名称().new 内部类名称();

1
2
3
4
5
6
7
8
9
10
public class demo {
    public static void main(String[] args){
        Car car = new Car(); //实例化一个车对象
        car.go(); //间接方法

        //直接方法
        Car.Engine engine = new Car().new Engine(); //实例化一个车里面的引擎对象
        engine.run();//调用内部类的方法
    }
}

如果内外部重名了，内部类使用外部类的方法是 外部类名称.this.外部类成员变量名

局部内部类

如果一个类是定义在方法内部的，那么这是一个局部内部类
局部: 只有当前所属的方法才能使用它，出了这个方法就不能用了
格式:

1
2
3
4
5
6
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称{
        }
    }
}
  • 就是一个方法里面定义了一个类，方便在这个方法内使用，别的地方都不能使用这个类
    例子:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class Outer {
        public void methodOuter(){ //这是一个外部类方法
            class Inner{ //在方法里面定义的类
                int num = 10;
                public void methodInner(){
                    System.out.println(num);
                }
            }
            Inner inner = new Inner(); //在方法里面实例这个类
            inner.methodInner(); //使用对象的方法
        }
    }
    用起来和普通的类的方法没区别，只是这个方法在允许的时候会创建一个类，并且使用这个类的方法
    1
    2
    3
    4
    5
    6
    public class demo{
        public static void main(String[] args){
            Outer outer = new Outer(); //实例化一个外部类
            outer.methodOuter(); //使用这个类的方法
        }
    }

匿名内部类

如果接口的实现类(或是父类的子类)只需要使用唯一的一次，那么这种情况就可以省略该类的定义，改为使用匿名内部类
格式:

1
2
3
接口名称 对象名 = new 接口名称(){
    //覆盖重写所有抽象方法
};

匿名内部类在创建对象的时候，只能使用唯一一次
这样就可以在使用接口的时候不用特意定义一个接口的实现类
例子:

1
2
3
public interface myInterface{
    public abstract void myMethod();
}
1
2
3
4
5
6
7
8
9
10
11
public class demo{
    public static void main(String[] args){
        myInterface obj = new myInterface(){
            @Override
            public void myMethod(){
                System.out.println("重写了方法");
            }
        };
        obj.meMethod(); //使用这个对象的方法
    }
}

不难，在脑子里想了一下，在做了个总结后，清晰许多了