Java学习笔记之内部类全面简析

一 . 概念：
定义在内部的类
二 . 分类：
1. 成员内部类
定义在类的内部 方法外
可以看做外部类的一个成员
2 . 方法内部类（局部内部类）
定义在方法中
3 . 静态内部类
static修饰的内部类
4 . 匿名内部类

三 . 成员内部类
调用格式：
外部类名.内部类名 对象名 = 外部类对象.内部类对象();
对象名.属性或者方法
Outer.Inner inner = new Outer().new Inner();
inner.method();
注意：
1、内部类可以直接使用外部类的成员变量、成员方法，用private修饰也可以直接使用
2、外部类如果想访问内部类的成员变量和成员方法，则需要创建内部类的对象来调用；方法或者变量通过private来修饰，则只能外部类访问，其他类无法访问；提高了安全性

public class InnerDemo {
    public static void main(String[] args) {
        new Outer().methodOut();
        Outer.Inner inner = new Outer().new Inner();
    }
}

class Outer {
    private int age;
    class Inner {
        int i = 0;
        private void method() {
            System.out.println("Inner method " + age);
        }
    }

    public void methodOut(){
        new Inner().method();
        InnerS.method();
        System.out.println("Outer method ");
    }

    static class InnerS{
        int s = 4;
        static void method(){
            System.out.println("static inner method");
        }
    }
}

静态内部类：
static修饰的内部类
1、静态内部类中可以定义静态方法
调用格式：
1、在外部类中可以通过内部类名.静态方法();
2、外部类.静态内部类.静态方法();
3、先创建内部类的对象 通过对象名.调用静态方法()–不推荐
2、静态内部类中可以定义非静态方法
调用格式：
1、在外部类中可以先创建内部类的对象 通过对象调用方法
2、在其他类中调用需要先创建内部类的对象.通过对象调用方法
外部类.内部类 对象名 = new 外部类.内部类();
Outer1.Inner1 inner1 = new Outer1.Inner1();
3、静态内部类只能访问外部类的静态属性 和静态方法

public class InnerDemo2 {
    public static void main(String[] args) {
        new Outer1().method();
        Outer1.Inner inner = new Outer1.Inner();
        Outer1.Inner.m();
        inner.m();
        inner.m1();
    }
}

class Outer1{
    static int age = 10;
    public static void method(){
        class InnerM{
            int i = 5;
            void method(){
                System.out.println(i + age);
            }
        }
        new InnerM().method();
        new Inner().m1();
    }

    static class Inner{
        public static void m(){
            System.out.println("static class m");
        }

        void m1(){
            System.out.println(age);
        }
    }
}

方法内部类：
1、方法内部类可以直接访问外部类的属性以及方法的局部变量
2、内部类和外部类没有继承关系
3、只能在方法内部通过创建类的对象来调用方法

public class InnerMethod {
    int num = 10;
    public void method(){
        int num = 20;
        class Inner{
            int num = 30;
            public void m(int num){
                System.out.println(this.num);
                System.out.println(num);
                System.out.println(InnerMethod.this.num);
                System.out.println("Inner Method");
            }
        }
        new Inner().m(num);
    }

    public static void main(String[] args) {
        new InnerMethod().method();
    }
}

匿名内部类：
格式：
new 接口名或类名(){
重写方法;
}
new Interf() {
@Override
public void method() { }
}
匿名内部类本质上某个类的子类对象或者是接口的实现类的对象

public class InnerNo {
    public static void main(String[] args) {
        new InnerF() {
            @Override
            public void m() {
                System.out.println("匿名内部类");
            }
        }.m();

        new Demo().me(new InnerF() {
            @Override
            public void m() {
                System.out.println("匿名对象中匿名内部类");
            }
        });
    }
}

interface InnerF{
    void m();
}

class Demo{
    void me(InnerF i){
        i.m();
    }
}