Java-内部类

内部类分类

1.内部类
2.静态内部类
3.局部内部类
4.匿名内部类

---

1.1内部类

内部类： 把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。

内部类的访问特点：
1.内部类可以直接访问外部类的成员，包括私有
2.外部类访问内部类。必须通过创建对象

class Outer1{
    private String name ="英语";
    private int a =13;
    private void fun1(){
        System.out.println("我是外部类的私有方法");
    }
    class Inner{
        String address ="南京雨花台";
        int a = 100;
        void fun(){
            System.out.println(a);
            fun1();
        }
    }
    public void show(){
        Inner inner = new Inner();
        inner.fun();

    }
}
public class NeiBuLie {
    public static void main(String[] args) {
        //如何访问内部类的方法呢？？？
        //       方式一：先创建内部类的对象，在创建内部类的对象，然后再调用方法
        Outer1 outer1 = new Outer1();
        outer1.show();

        //       方式二：两步合成一步
        //       正确创建成员内部类的格式：
        //       外部类名.内部类名 对象名 = new 外部类名（）.new 内部类名（）
        Outer1.Inner oi = new Outer1().new Inner();
        oi.fun();
        //       方法三：链式调用方法
        new Outer1().new Inner().fun();
        System.out.println(new Outer1().new Inner().a);
    }
}

1.2静态内部类

静态类中想要访问非静态的，必须先创建对象

成员内部类的常见修饰符
private 为了保证数据的安全性
static 为了让数据访问更方便
注意：被静态修饰的成员内部类所访问的也应该是被static修饰的

在测试类中想用调用内部类注意事项:

外部类名。内部类名 对象名 = new 外部类名（）。内部类名（）

如果内部类被static 修饰时，创建对象方法如下：
外部类名。内部类名 对象名 = new 外部类名。内部类名
如果静态类中还有静态的方法时可以这么调用：
外部类名。内部类名。方法名{}

---

1.3局部内部类

表现形式：内部类定义在方法中。而方法又定义在外部类中

注意事项：

• 在内部类访问外部类属性时通过 外部对象名.this.属性。调用

class Outer{
     int a = 10;
     private String name ="阿花";
    void  show() {
        int a = 20;
        class Inner{
            //int a = 30;
            void show() {
                System.out.println(Outer.this.a);    //
                System.out.println(name); //省略了Outer.this.name
            }
        }
        //现在方法内部创建对象。才能获取内部的参数；
        Inner in = new Inner();
        in.show();
    }
}
public class JuBuNeiBulei {
    public static void main(String[] args) {
        //创建外部类，用外部类的对象来调用Show方法
        Outer oi = new Outer();
        oi.show();
    }
}

*****匿名内部类（开发中最常见）

简单理解：他其实就是内部类的简化写法。

前提和格式语句

前提：要存在一个接口或者是一个类，类也可以是抽象类
格式：new类名/接口名（）{重写方法
}

    void run();
    void run1();
}
class Son1{
     void show(){
         //new 抽象类/接口（）{重写}
        Father1 f =   new Father1() {
             @Override
             public void run() {
                 System.out.println("真的牛逼");
             }

             @Override
             public void run1() {
                 System.out.println("阿涛。好厉害！");
             }
        };
         f.run();
         f.run1();
     }
}

public class NiMingNeiBuLei {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.show();
    }
}

案例二：

    abstract void run();
    abstract void run2();
}

class Son {
//    @Override
//    void run() {
//        System.out.println("重写之后的方法");
//    }
    void show(){

//        class Son1 extends Father{
//            @Override
//            void run() {
//
//            }
//
//            @Override
//            void run2() {
//
//            }
//        }
        Father f = new Father() {
            @Override
            void run() {
                System.out.println("记得加逗号呦");
            }

            @Override
            void run2() {
                System.out.println("奥利给！");
            }

        };
        f.run();
        f.run2();
        }
    }




public class NiMimgInOut {
    public static void main(String[] args) {
//        Father father = new Son();
//        father.run();

        Son son = new Son();
        son.show();

    }
}

重写时也可以在main 方法里面重写然后作为一个对象作为一个形式参数放进方法里面————匿名内部类的使用场景只用一次