java类基础之枚举和内部类

package rejava2.内部类和枚举;

//内部类可以在任何类中
public class TestClass_5 {
    public static void main(String[] args){
        InnerClass.A innerDemo=new InnerClass().new A();          //或import InnerClass.A
        innerDemo.innerClassMethod();
        face fa=new face(){                     //{}里是匿名内部类(类名和类可省略，省略的类默认实现接口)
            public final String a="fa";
            public void innterfaceInnerMethod(){
                System.out.println("接口匿名类 "+this.a);
            }
        };
        fa.innterfaceInnerMethod();
        InnerClass.D niming=new InnerClass.D(); //静态内部类a.b
        niming.d();
        System.out.println("/");
        TestEume e=TestEume.B;         //直接创建引用对象
        System.out.println(e.compareTo(TestEume.E));       //返回结果类似于e的序号减去C的序号
        System.out.println(TestEume.valueOf("B"));         //通过"A"定位对象,打印时调用toString()打印对象
        System.out.println(e.name+e.ordinal);
    }
}

interface face{
    public void innterfaceInnerMethod();
}
//class son implements face{                 可省略
//    public String a="fa";
//    public void innterfaceInnerMethod() {
//        System.out.println("接口匿名类");
//    }
//}

class InnerClass{//成员内部类，局部内部类，匿名内部类，静态内部类
    private final String name="外部类属性";
    public static void commmonStaticMethod(){
        System.out.println("外部类静态方法");
    }
    public void commmonMethod(){
        System.out.println("外部类方法");
    }

    public class A{     //成员内部类，不能直接调用创建对象,文件为InnerClass$A
        public void innerClassMethod(){
            System.out.println("内部类方法 "+InnerClass.this.name);  //大类.this.  才是外部类的属性
            commmonStaticMethod();                   //可以直接访问外部类的东西
        }
    }

    public void innerMethodClass(){ //局部内部类
        int age=0;
        class B{                        //和局部变量一样，不能修饰,只能final和abstract
            public void testFi(){
                System.out.println(age);   //字节码已编译，不能改变，所以只能用不可变的变量
            }
        }
    }
    {                  //初始化块内部类
        class C{}
    }

    public static class D{  //静态元素类，不能访问类成员
        public void d(){
            System.out.println("静态内部类");
        }
    }
}

enum TestEume{           //默认继承Enum，所以不能继承其他的，Enum里有[返回TestEnum型对象]valueOf(),[TestEnum[]]values(),[int]compareTo()。Object的toString(){唯一可以重写的，其他都在Enum里面重写为final了}和其他方法
    A,B(99,"BBB"),C,D,E;            //直接列出来，一个就代表默认被创建的对象,public static TestEnum A;且对象里有name(默认为罗列时取的名字),name()方法{返回name}.有ordinal(索引0,1,2...),ordinal()方法{返回序号}

    public int ordinal;         //重新定义继承过来的属性，若这样此时ordinal则为子类属性
    public String name;
    private TestEume(){} //必须要private，因为枚举里不能让外面用构造方法，如果写了这个罗列时加分号
    private TestEume(int ordinal,String name){  //可省略
        this.ordinal=ordinal;
        this.name=name;
    }
    public String toString(){              //重写toString()
        return this.name;
    }
}