内部类(类里再定义类）--day12

1.方法内部类

在方法内定义类

只能定义非静态信息以及静态常量

可以正常继承和实现

不能被访问权限修饰符修饰可以被final/abstract来修饰

可以获取外部类所有信息

只能获取当前方法中的常量信息

创建对象语句只能在当前方法中使用 

public class InnerDemo1 {
    public static void main(String[] args) {
        new Outer1().m();
    }
}
//外部类
class Outer1{
    //属性
    static int j=1;
    //方法
    //Ctrl+Alt+l---代码格式化
    public void m(){
        int a=3;//在jdk1.8及其以后会默认在底层加上final表示常量
                //在jdk1.8以前需要手动添加final才是常量
        //方法内部类
        //只能定义所有的非静态信息和静态常量
        //可以进行正常的继承和实现
        //不能被访问权限修饰符修饰可以被final/abstract来修饰
        //获取外部类的所有信息
        //方法内部类只能获取当前方法中的常量信息
        class Inner1 extends Object implements Cloneable {
            static final int i = 1;

            public void n() {
                System.out.println(j);
                //System.out.println(a=2);
                x();
            }
        }
        //创建方法内部类对象
        Inner1 inner1=new Inner1();
        inner1.n();
    }
    public static void x(){
        //外部类获取不了内部类信息
        //System.out.println(i);
    }

}

2.成员内部类

在成员位置定义类

只能定义非静态信息以及静态常量

可以正常进行继承和实现

可以被访问权限修饰符修饰以及final/abstract来修饰

可以获取外部类所有的信息

Outer2.Inner2 inner2=new Outer2().new Inner2(); 

public class InnerDemo2 {
    public static void main(String[] args) {
        //创建成员内部类对象
        //数据类型 名称=值；
        //Outer2.Inner2 inner2=new Outer2().inner2;
        Outer2.Inner2 inner2=new Outer2().new Inner2();
        inner2.n();
    }
}


//外部类
class Outer2{
    //属性
    static int k=1;

    //属性
    //Inner2 inner2=new Inner2();

    //成员内部类
    //可以定义所有的非静态信息以及静态常量
    //可以正常的继承和实现
    //可以被访问权限修饰符修饰也可以被final/abstract来修饰
    //可以获取外部类所有信息
    class Inner2 extends Object implements Cloneable{
        static final int i=2;
        public void n(){
            System.out.println(k);
            m();
        }
    }

    //方法
    public void m(){}
}

3.静态内部类

static修饰成员内部类

可以所有的信息以及静态常量

可以正常继承和实现

可以被访问权限修饰符修饰以及final/abstract

只能获取外部类的静态信息

Outer3.Inner3 inner3=new Outer3.Inner3(); 

public class InnerDemo3 {
    public static void main(String[] args) {
        //创建静态内部类对象
        Outer3.Inner3 inner3=new Outer3.Inner3();
        inner3.n();
    }
}


//外部类
//饰static修的类一定是内部类
class Outer3{
    //属性
    static int k=1;

    //静态内部类
    //可以定义所有的信息以及静态常量
    //可以正常继承和实现
    //可以被访问权限修饰符来修饰也可以被final/abstract来修饰
    //只能获取外部类的静态信息
    static class Inner3 extends Object implements Cloneable{
        static final int i=2;
        public void n(){
            System.out.println(k);
            m();
        }
    }

    //方法
    public static void m(){}
}

4.匿名内部类

默认继承类/实现接口，重写抽象方法不是最终类以及接口都可以具有匿名内部类的形式匿名

内部类只能使用一次常用于参数传递

public class InnerDemo {
    public static void main(String[] args) {
        //{}---匿名内部类
        //匿名内部类默认继承类/实现接口去重写抽象方法
        //抽象类、普通类（只要不是最终类）、接口都可以具有匿名内部类形式
        //b对象匿名内部类的对象
        B b = new B() {
            @Override
            public void m() {

            }
        };
        //普通类也具有匿名内部类的形式
        D d=new D(){};
        //接口也具有匿名内部类的形式
        A a=new A() {
            @Override
            public void n() {

            }
        };

        //匿名内部类当作参数传递（针对参数类型是接口/抽象类）
        mn(new A() {
            @Override
            public void n() {

            }
        });
    }

    //
    public static void mn(A a){//可以接收实现类对象

    }
}



//接口
interface A{
    void n();
}
//抽象类
abstract class B{
    public abstract void m();
}
class D{}
/*
class C extends B{
    @Override
    public void m() {

    }
}*/

 接口里定义类默认被static修饰以及内部接口默认被static修饰

public class InnerDemo2 {
    public static void main(String[] args) {
        System.out.println(Outer2.Inner2.i);
        System.out.println(Outer2.Inner3.j);
        System.out.println(Outer2.Inner2.Inner4.x);
    }
}




interface Outer2{
    //默认被static修饰
    static class Inner2{
        static int i=1;
        //默认被static修饰
        static interface Inner4{
            int x=1;
        }
    }
    //默认被static修饰
    static interface Inner3{
        int j=1;
    }
}