Java 内部类

内部类

1.内部类种类：成员内部类、静态内部类、局部(方法)内部类、匿名内部类

2.内部类优点

• 可以有多个独立的实例，对其他外部类对象没有干扰

• 内部类是一个独立的实体

• 内部类提供了更好的封装，只有该类的外部类可以访问

• 内部类的创建不依赖外部类的创建

内部类的使用

• 成员内部类

特点：要使用成员内部类的对象，外部类的对象必须存在

public class Outer{
    private int outerVariable = 10;//外部类独有
    private int commonVariable = 20;//重名变量
    private static int outerStaticVariable = 30;//静态变量
    public Outer(){
        System.out.println("Outer被创建....");
    }
    public void outerMethod(){
        System.out.println("我是外部类的普通成员方法");
    }
    public static void outerStaticMethod(){
        System.out.println("我是外部类的静态成员方法");
    }
    //内部类
    public class Inner{
        priavte int commonVariable = 40;//和外部类重名的属性
        public Inner(){
            System.out.println("Inner被创建...");
        }   
        public void innerShow(){
            System.out.println("内部类自己属性："+commonVariable);
            System.out.println("访问外部类的属性"+outerVariable);
            System.out.println("访问外部类重名的属性"+Outer.this.commonVariable);
            System.out.println("访问外部类静态属性"+outerStaticVariable);
            outerMethod();
            outerStaticMethod();
        }
    }
    //访问内部类信息
    public void outerShow(){
        //首先获取内部类对象
        Inner inner = new Inner();
        inner.innerShow();
    }
}

外部实例化

public class OuterTest{
    public static voidmain(String[] args){
        //1创建外部类对象调用
        Outer outer = new Outer();
        outer.outerShow ();
      System.out.println("-----------------------------");  
        //2通过外部类对象创建内部类对象
        Outer.Inner inner = Outer.new Inner();
        inner.innerShow();
    }
}

总结

1.创建内部类 和类的创建相似，可以继承，可以实现。方法该重写的重写。 2.可以使用任何访问权限控制符。 3.内部类不能存在静态修饰内容（静态代码块、静态属性、静态方法） 4.外部类想访问内部类，需要创建内部类对象进行使用。 5.内部类想访问外部类信息，直接使用，如果存在重名(属性、方法)。外部类类名.this.重名(方法名、属性)

运行结果

 

• 静态内部类

特点：静态内部类，把外部类当作特殊的包使用，所以实例化时new 后面的Demo不需要小括号（和成员内部类区别）。

public class Demo {
    String name;                            //属性
    public void funOuter1() {               //方法
        System.out.println("外部类方法");
    }
//静态内部类
    static class StaticClass{
        
    }
}

外部实例化

public class Client {
    public static void main(String[] args) {
        //静态内部类，把外部类当作特殊的包使用
        Demo.StaticClass staticClass = new Demo.StaticClass();
    }
}

总结 1.静态内部类包含所有类创建信息 2.静态内部类只能访问外部类所有静态信息(属性、方法) 3.利用 外部类名称.内部类名称 变量名 = new 外部类名称.内部类(); 变量名.属性/方法 实例化 4.内部类是独立存在，并不依靠外部类。只有在内部类中调用外部类信息时，外部类才会加载到jvm虚拟机中。

• 局部(方法)内部类

特点：可以在方法中定义，并实例化，但使用地方仅局限在此方法中。

public class MethodOuter {
    private int outerVariable = 10;//外部类独有
    private int commonVariable = 20;//重名变量
    private static int outerStaticVariable = 30;//静态变量
    public MethodOuter(){
        System.out.println("Outer被创建....");
    }
    static{
        System.out.println("我是外部类的静态代码块");
    }
//成员方法
    public void outerMethod(){
        System.out.println("我是外部类的普通成员方法");
    }
//静态成员方法
    public static void outerStaticMethod(){
        System.out.println("我是外部类的静态成员方法");
    }
//成员方法，内部类定义在方法中
    public void outerCreateMethod(int value){
        boolean b = true;
        int a ;
        a = 40;
    /*private 错误，局部内部类中不能使用权限修饰符 */
        class Inner{
            private int innerVariable = 40;
            private int commonVariable = 50;
                //局部内部类方法定义
            public void innerShow(){
                System.out.println("inner内部属性"+innerVariable);
                //访问方法中属性
                System.out.println("方法中参数"+b);
                System.out.println("方法参数中属性"+value);
                System.out.println("方法中为赋值参数"+a);
                //访问外部类信息
                System.out.println("outVariable"+outerVariable);
                System.out.println("内部类中重名"+commonVariable);
                System.out.println("外部类中重                       名"+MethodOuter.this.commonVariable);
                System.out.println("外部类中静态"+outerStaticVariable);
                //方法的访问
                outerMethod();
                outerStaticMethod();
                }
            }
        //局部内部类只能在方法内使用
        Inner inner = new Inner();
            inner.innerShow();
        }
        public static void main(String[] args) {
        //1.创建外部类对象
            MethodOuter outer = new MethodOuter();
        //2.调用包含内部类的方法
            outer.outerCreateMethod(100);
        }
}

总结 1.类前不能有访问修饰符 2.内部类仅能在方法内使用 3.无发创建静态信息 4.可以直接访问方法内的变量及参数，但是有限制(访问的变量或者参数必须赋值，且复制后不能发生改 变。在jdk1.8以前版本，局部内部类 只能访问final修饰的变量) 5.可以随意访问外部类的任何信息。

• 匿名内部类

1.创建一个类(开发中常用于接口的实现)

 public interface Anoymous {
        void sayHello();//根据不同人说您好
    }

2.使用(直接创建接口对象/其父类对象/)

public static void main(String[] args) {
        Anoymous an = new Anoymous(){
            @Override
            public void sayHello() {
                System.out.println("中国人说：Hello");
            }
        };
        an.sayHello();
    }
public static Anoymous getAnoymous(){
    return new Anoymous() /*创建对象阶段 class XXX implements Anoymous*/{
    @Override
    public void sayHello() {
        System.out.println("英国人说：hello");
    }
};//子类对象;
    
public static void main(String[] args) {
    AnonymousClass.getAnoymous().sayHello();
}