内部类

内部类介绍

一个类里面又有一个类。这种在类中的类被称为内部类

基本语法

//外部类
class text{
    //内部类
    class inner{
    }
}

局部内部类(方法中的类)

局部内部类的语法

//外部类
class text{
    private int count=10;
    //方法
    public void m1(){    
        //内部类
        public class Inner{    
            public void m2(){
                System.out.println(count);
            }
        }
        Inner inner = new Inner();
    }
}

匿名内部类(重要)

Java中的匿名内部类是一种特殊的内部类，它没有显式的类名，只是在创建时定义并实现了一个接口或继承了一个类。使用匿名内部类可以省略创建一个新类的步骤，将定义和实现放在同一个地方，使代码更加简洁。

匿名内部类的语法

new 父类构造器或接口(){
    //匿名内部类的实现
};

其中，父类构造器可以是类或接口，如果是接口则实现的是接口中的方法，如果是类则必须重写类中的抽象方法。
当做实参直接传递，简洁高效

案例

下面的代码使用匿名内部类实现了Runnable接口：

Thread t = new Thread(new Runnable() {
    @Override
    public void run() {
        //线程执行的任务
    }
});
t.start();

在上述代码中，Runnable接口没有显式的类名，但是通过实现run方法实现了线程的执行任务。

创建一个匿名对象调用抽象类的原理

Person抽象类

//人
public abstract class Person {
    //呼吸
    public void breathe(){
        System.out.println("人在呼吸");
    }
    //吃饭
    public abstract void eat();
}

测试类

public class ch {
    public static void main(String[] args){
        Person person = new Person() {
            @Override
            public void eat() {
                System.out.println("人要吃饭");
            }
        };
        person.eat();
    }
}

简单来说：就是在方法中创建了一个没有名字的类，继承抽象类并实现其中的抽象方法，同时实例化对象。
匿名对象相当于创建了一个Person抽象类的匿名子类对象，
可以通过匿名对象去调用Person抽象类的公共属性和方法。
注意：匿名子类对象中需要把Person抽象类（包括他的父类）中的抽象方法进行重写

成员内部类

基本语法

//外部类
class text{
    //内部类
    public class inner{
        public void str(){
            System.out.println("...");
        }
    }
}

外部其他类访问成员内部类的两种方式

案例

import java.lang.*;
public class Ch {
    public static void main(String[] args) {
        Ou ou = new Ou();
        ou.str();
        //1、通过外部类的对象获取
        //ou.new In();相当于把new In()当做是ou成员
        //这就是一个语法，不要特别的纠结，
        Ou.In in1 = ou.new In();
        in1.str();
        //通过外部类的匿名对象获取
        Ou.In in2 = new Ou().new In();
        in2.str();
        //3、通过外部类的方法获取
        Ou.In in3 = ou.getIn();
        in3.str();
    }
}
//外部类
class Ou{
    public class In{
        public void str(){
            System.out.println("In");
        }
    }
    public In getIn(){
        return new In();
    }
    public void str(){
        System.out.println("Ou");
    }
}

静态成员内部类的使用

案例

import java.lang.*;
public class Ch {
    public static void main(String[] args) {
        Ou ou = new Ou();
        ou.str();
        //1、通过外部类的匿名对象获取
        Ou.In in1 = new Ou.In();
        in1.str();
        //2、通过外部类对象的方法获取
        Ou.In in2 = ou.getIn();
        in2.str();
        //2、通过外部类的静态方法获取
        Ou.In in3 = Ou.getIn_();
        in3.str();
    }
}
class Ou{
    public static class In{
        public void str(){
            System.out.println("In");
        }
    }
    public In getIn(){
        return new In();
    }
    public static In getIn_(){
        return new In();
    }
    public void str(){
        System.out.println("Ou");
    }
}