四种内部类

内部类的基本介绍：

一个类的内部又完整的嵌套了另一个类的结构。被嵌套的类称为内部类（inter class）,嵌套其他类的类称为外部类（outer class）,是我们类的第五大成员。内部类的最大特点是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

基本语法：

class Outer{    //外部类

class inner{//内部类

}

}

class other{}//外部其他类

内部类的分类：

定义在外部类的局部位置上（比如方法中，代码块中，构造器）

（1）局部内部类

（2）匿名内部类（没有类名）

定义在外部类的成员位置上：

（1）成员内部类

（2）静态内部类（使用static修饰）

局部内部类的使用：

1.局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。可以访问到所有的成员，包括私有。

2.不能添加访问修饰符，因为他的地位就是个局部变量，但是可以用final修饰。

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

4.局部内部类访问外部类中的成员——直接访问

5.外部类访问局部内部类的成员——创建对象，在访问（必须在作用域中）

6.外部其他类不能访问局部内部类

7.如果外部类和局部内部类成员重名时，默认遵守就近原则，如果想访问外部成员，则可以使用（外部类名+this.成员）去访问

匿名内部类的使用：

（1）匿名内部类本质是个类

（2）该类没有名字

说明：匿名内部类是定义在外部类的局部位置，比如在方法中，并且没有类名。

1.匿名内部类的基本语法：

new 类或接口（参数列表）{

类体

}

实现一个接口的抽象方法，常规方法：建立一个对象并实现 implements该接口，重写抽象方法即可
匿名内部类新需求：现在不想要实现该接口的类创建的对象，因为它只能使用一次，后面将不在使用
可以使用匿名对象简化开发

匿名内部类的名是在底层分配好的，通常是类名+$1

public class noNameClass02 {
    public static void main(String[] args) {
        out02 out02=new out02();
        out02.f1();


    }
}
class out02 {
    private int n1 = 100;

    public void f1() {
        stu a = new stu() {
            @Override
            public void hi() {
                super.hi();
                System.out.println(" aaa");
            }
        };
        a.hi();

        new stu() {
            @Override
            public void hi() {
                System.out.println("叼毛，搭车吗");
            }

        }.hi();//直接调用


    }


    class stu {
        public void hi() {
            System.out.println("person hi");
        }

    }
}

匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，t对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。

 注意事项：

1.匿名内部类可以访问外部类的所有成员，包括私有的。

2.不能添加访问修饰符，因为地位是一个局部变量。

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

4.局部内部类访问外部类中的成员——直接访问

/**使用匿名内部类的场景
 *基于接口A的演示
 *要实现一个接口的抽象方法，常规方法：建立一个对象并实现 implements该接口，重写抽象方法即可
 * 匿名内部类新需求：现在不想要实现该接口的类创建的对象，因为它只能使用一次，后面将不在使用
 * 可以使用匿名对象简化开发
 */
public class noNameClass {
    public static void main(String[] args) {
       Outer outer =new Outer();
       outer.method();//调用了Outer的方法method
    }
}
class Outer{
    private int n1=10;
    public void method() {
        //      A tiger=new tiger();//
        //    tiger.cry();//
    A a= new A() {//匿名内部类,a的编译类型是接口A,运行类型其实就是匿名内部类


            @Override//实现了接口的方法，基于类的匿名内部类
            public void cry() {
                System.out.println("老虎交换");
            }
        };

       a.cry();
        System.out.println(a.getClass());

        Father father = new Father("张") {//基于类所创建的匿名内部类，和基于接口的匿名内部类相比，有了形参列表。是继承关系
            //father接收该匿名内部类的值
            @Override
            public void test() {
                super.test();
            }
        };
        father.test();
        Father father1 = new Father("") {
            @Override
            public void test() {
                super.test();
            }
        };



    }
}
interface A{
    public void cry();
}
//class tiger implements A{//实现该接口，不需要一个类去实现该接口
  //  @Override
    //public void cry() {
      //  System.out.println("老虎狗叫");
    //}
//}
class Father{
    public Father(String name) {
    }
public void test(){
    System.out.println("你好，Java");
}

}

成员内部类：

说明：成员内部类是定义在内部类的成员位置，并且没有static修饰。

1.可以访问访问外部类的所有成员，包括私有。

2.可以添加任意访问修饰符，因为他的地位是个成员。

3.作用域：和其他成员一样，为整个类体。调用该内部类的方法和属性方法是在成员的方法中创建内部类对象，然后再调用方法和属性。

4.可以直接访问外部类成员

5.外部类访问成员内部类的方法，创建对象，再访问。

6.外部类和内部类的方法和属性名重复，内部类访问的话，遵守就近原则。访问外部类的方法。外部类名.this.成员。

静态内部类：

静态内部类是定义在内部类的成员位置，并且由static修饰。

1.可以直接访问外部类的所有成员，但不能访问非静态的成员。

2.可以添加任意访问修饰符。

3.用其他成员，为整个类体。

4.静态内部类访问所有成员，直接访问所有静态成员。

5.外部类访问静态内部类，创建对象，并访问

6.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近

原则，如果想访问外部类的成员，则可以使用(外部类名。成员)去访问