java语言中的内部类

java语言中的内部类

什么是内部类？就是在一个类的内部再定义一个完整的类。

内部类分类：

① 成员内部类

② 局部内部类

③ 静态内部类

④ 匿名内部类

（1）成员内部类

概念：在外部类内部直接定义（不在方法内部或代码块内部）的类就是成员内部类，它可以直接使用外部类的所有变量和方法，即使是 private 的。外部类要想访问内部类的成员变量和方法，则需要通过内部类的对象来获取。

代码示例：

//外部类
public class Person {
	//外部类的变量
    private int size = 10;
    //内部类
    public class Inner {
    	//内部类的方法
        public void outter() {
            System.out.println(size);
        }
    }
}

成员内部类的访问：

① 在外部类的方法中实例化内部类的对象，通过内部类的对象调用内部类的方法

public class Main {
    public static void main(String[] args) {
    	//创建外部类的对象
        Person person = new Person();
        //通过外部类的对象调用外部类的方法
        person.testInner();
    }
}

//外部类
class Person {
	//外部类的变量
    private int size = 10;
    //内部类
    public class Inner {
    //内部类的方法
        public void outter() {
            System.out.println(size);
        }
    }
    //外部类的方法
    public void testInner() {
    	//创建内部类的对象
        Inner in = new Inner();
        //通过内部类的对象调用内部类的方法
        in.outter();
    }
}

② 实例化外部类，通过外部类对象调用内部类的实例化，生成内部类对象，类型为外部类.内部类

public class Main {
    public static void main(String[] args) {
    	//创建外部类的对象
        Person person = new Person();
        //通过外部类对象调用内部类的实例化，生成内部类对象
        Person.Inner inner = person.new Inner();
        //通过内部类的对象调用内部类的方法
        inner.outter();
    }
}

class Person {
    private int size = 10;
    public class Inner {
        public void outter() {
            System.out.println(size);
        }
    }
}

（2）静态内部类

概念：static内部类相当于其外部类的 static 成员，它的对象与外部类对象间不存在依赖关系，因此可直接创建。示例如下：

public class Main {
    public static void main(String[] args) {
    	Person.Inner inner = new Person.Inner();
        inner.outter();
    }
}

class Person {
    private static int size = 10;
    //静态内部类
    static class Inner {
        public void outter() {
            System.out.println(++size);
        }
    }
}

（3）局部内部类

概念：局部内部类是定义在方法或代码块中的类，它们只在定义它们的代码块中是可见的。

局部类有几个重要特性：

• 仅在定义了它们的代码块中是可见的；
• 可以使用定义它们的代码块中的任何局部 final 变量；
• 局部类不可以是 static 的，里边也不能定义 static 成员；
• 局部类不可以用 public、private、protected 修饰，只能使用缺省的；
• 局部类可以是 abstract 的。

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        Person.outterTest();
    }
}

class Person {
    //外部类的方法
    public static void outterTest(){
        //局部内部类
        class Inner{
            //局部内部类的方法
            public void innerTest(){
                System.out.println("局部内部类方法");
            }
        }
        //在外部类的方法里创建内部类的对象
        Inner inner = new Inner();
        //通过内部类的对象调用内部类的方法
        inner.innerTest();
    }
}

（4）匿名内部类

概念：匿名内部类是局部内部类的一种特殊形式，也就是没有变量名指向这个类的实例，而且具体的类实现会写在这个内部类里面。

什么时候会用到呢：当需要被重写的方法只使用一次的时候，使用匿名内部类可以减少类的创建。

注意：必须继承一个父类或者实现一个接口。

优点：减少代码量。

缺点：可读性较差。

代码示例：

abstract class Demo{
    public abstract void Demotest();
}

public class Main {
    public static void main(String[] args){
        //继承Demo类
        new Demo() {
        	//重写父类的Demotest方法并调用
            public void Demotest() {
                System.out.println("匿名内部类");
            }
        }.Demotest();
    }
}