Java四种内部类

内部类

一个类的内部里面又完整的嵌套了另一个类的内部结构，被嵌套的类称为内部类
内部类最大的特点就是：可以直接访问私有属性，并且可以体现类与类之间的包含关系

基本语法

class outer{ //外部类
   private int n1 = 100;
   public outer(int n1) {
       this.n1 = n1;
   }
   public void m1(){
       System.out.println("m1方法");
   }
   {
       System.out.println("代码块");
   }
   //内部类
   class Inner{
   }
}

局部内部类

特点：

1.局内内部类是定义在外部类的局部位置，通常是定义在方法中，也可以定义在代码块内

2.局部内部类可以直接访问外部类的所有成员，包括私有的

3.局部内部类不可以有访问修饰符，但是可以使用final进行修饰

4.作用域：仅仅在他定义的方法或者代码块中

5.外部类在方法中，可以创建Inner02对象，然后直接调用方法即可

6.外部其他类不能访问局部内部类，因为局部内部类是成员变量

7.如果外部类和局部内部类成员重名时，默认遵守就进原则，如果想访问外部类的成员可以使用 this.外部成员进行访问

public class LocalInnerClass {
    public static void main(String[] args) {
        //6.外部其他类不能访问局部内部类，因为局部内部类是成员变量
        outer2 outer2 = new outer2();
        outer2.m1();
    }
}
class outer2{ //外部类
    private int n1 = 100;
    private void m2(){
        System.out.println("m2方法");
    }
    public void m1(){
        //1.局内内部类是定义在外部类的局部位置，通常是定义在方法中，也可以定义在代码块内
        //3.局部内部类不可以有访问修饰符，但是可以使用final进行修饰
        //4.作用域：仅仅在他定义的方法或者代码块中
        //final class Inner02{
        class Inner02{//局部内部类 本质仍然是一个类
            private int n1 = 80;
            //2.局部内部类可以直接访问外部类的所有成员，包括私有的
            public void f1(){
                System.out.println(n1);
                System.out.println(outer2.this.n1);
                System.out.println(this.n1);
                m2();
                //7.如果外部类和局部内部类成员重名时，默认遵守就进原则，如果想访问外部类的成员可以使用 外部类名.this.外部成员进行访问
            }
        }
        //5.外部类在方法中，可以创建Inner02对象，然后直接调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
        class Inner03 extends Inner02{
        }
    }
    //代码块中定义内部类
    //{
    //    class Inner02{
    //        //2.局部内部类可以直接访问外部类的所有成员，包括私有的
    //        public void f1(){
    //            System.out.println(n1);
    //        }
    //    }
    //}
}

2.匿名内部类

 匿名内部类也是一个类的定义，同时它本身也是一个对象，因此从语法上看。它既有定义类的特征，也有创建
 对象对的特征

可以直接访问外部类的所有成员，包含私有的

不能添加访问修饰符，它的本质其实是一个局部变量

不能添加访问修饰符，它的本质其实是一个局部变量

作用域：仅仅在它定义的代码块中
外部其他类不能访问匿名内部类，因为匿名内部类是成员变量
如果外部类和匿名内部类成员重名时，默认遵守就进原则，如果想访问外部类的成员可以使用 this.外部成员进行访问

public class AnonymousClass {
    public static void main(String[] args) {
        outer03 outer03 = new outer03();
        outer03.m1();
    }
}

class outer03{
    private int n1 = 100;

    public void m1(){
        //基于接口的匿名内部类
        //使用IAn接口创建对象 在开发中我们只使用一次这个对象 所以创建对象有点浪费
        //Tiger tiger = new Tiger();
        //tiger.cry();
        //解决方法：使用匿名内部类创建对象
        // tiger 的编译类型 ? IA
        // tiger 的运行类型 ? 就是匿名内部类 Outer04$1
        // jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址返回给tiger
        // 匿名内部类只能使用一次，就不能在使用
        IAn tiger = new IAn(){
            @Override
            public void cry() {
                System.out.println("tiger的cry方法");
            }
        };

        tiger.cry();
        System.out.println("tiger的运行类型"+ tiger.getClass());

        //基于类的匿名内部类
        Father father = new Father(){
            @Override
            public void test() {
                System.out.println("重写了father的test方法");
            }
        };

        father.test();

        //基于抽象类的匿名内部类
        Animal animal = new Animal(){

            @Override
            void test() {
                System.out.println("重写了animal的test方法");
            }
        };

        animal.test();
    }
}
//接口
interface IAn{
    //cry方法
    void cry();
}

//class Tiger implements IAn{
//
//    @Override
//    public void cry() {
//
//    }
//}

class Father{
    private int n1 = 100;

    public void test(){

    }
}

abstract class Animal{
    private int n1 = 100;

    abstract void test();
}

3.成员内部类

特点：

可以直接访问外部类得成员，包括私有得

成员内部类可以添加访问你修饰符（private,default,protected,public）

作用域：在外部类得类体中

如果外部类和成员内部类成员重名时，默认遵守就进原则，如果想访问外部类的成员可以使用 this.外部成员进行访问

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();

        //外部类访问成员内部类
        Outer.Inner03 inner03 = outer.new Inner03();
        inner03.say();
    }
}


class Outer{
    private int n = 100;

    //成员内部类可以访问所有的成员 包括私有的
    //成员内部类可以添加访问你修饰符（private,default,protected,public）
    //作用域：在外部类得类体中
    class Inner03{
        public void say(){
            System.out.println(n);
            System.out.println("成员内部类方法");
        }
    }

    public void test(){
        Inner03 inner03 = new Inner03();
        inner03.say();
    }
}

4.静态内部类

特点：

可以直接访问外部类得非静态成员，包括私有的
可以添加任意的修饰符（private等等）
作用域：同其他成员，为整个类体

如果外部类和静态内部类成员重名时，默认遵守就进原则，如果想访问外部类的成员可以使用 外部类名.成员进行访问

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
    }
}


class Outer10 {
    private int n1 = 10;
    private static String name = "张三";

    private static void cry() {
    }

    //Inner10 就是静态内部类
    // 1. 放在外部类的成员位置
    // 2. 使用 static 修饰
    // 3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    // 4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    // 5. 作用域 ：同其他的成员，为整个类体

    static class Inner10 {
        private static String name = "1111";

        public void say() {
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            // 默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类 name= " + Outer10.name); cry();
        }
    }
}