枚举类补充

nt呆

已于 2023-07-25 01:09:34 修改

阅读量77

点赞数

分类专栏：领航文章标签： java 开发语言

于 2023-04-15 23:43:07 首次发布

本文链接：https://blog.csdn.net/qq_73651672/article/details/130164172

版权

领航专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章介绍了Java中的枚举类型两种不同的实现方式，比较了它们在利用对象属性和方法上的差异。同时，详细阐述了内部类的概念，包括非静态内部类、静态内部类和私有内部类的创建、访问和使用规则，强调了内部类在对象实例化和访问外部类字段的特点。

摘要由CSDN通过智能技术生成

很高兴加入学校的领航俱乐部学习，我会尽力多写博客来记录学习叭~;

争取每周五更新(^ _ ^)

1.关于枚举类的理解

如下是关于枚举的一种实现(不能够充分的利用对象的属性）

package work;

enum State1 {
    success,
    unSuccess;
    public void getString(State1 now) {
        switch (now){
            case success :System.out.println(1+" "+"操作成功^_^");break;
            case unSuccess:System.out.println(0+" "+"操作失败T_T");break;
        }
    }
}

public class workOne {
    public static void main(String[] args) {
        System.out.println(State1.success);
        System.out.println(State1.unSuccess);
        State1.success.getString(State1.success);
        State1.unSuccess.getString(State1.unSuccess);
        //枚举类实现方式实际是内部实现，枚举元素
        //枚举类可以直接通过类名进行对象访问，注意枚举类不能实例化
        /*可以直接打印枚举元素
        但是如果想要打印对元素的扩展应该增加方法封装
        通过swtich对需要的元素进行匹配，从而输出
        这里将swtich放进类中，是为了做到主类的简洁
         */
    }
}

如下是另一种实现方式(可以充分返回对象属性

package work;

enum State2{
    success(1,"操作成功！"),
    unSuccess(0,"操作失败。");
    private int state;
    private String tips;
    private State2(int state,String tips){
        this.state=state;
        this.tips=tips;
    }
    public int getState(){
        return this.state;
    }
    public String getTips(){
        return this.tips;
    }
}
public class workTwo {
    public static void main(String[] args) {
        int state = State2.success.getState();
        String tips = State2.success.getTips();
        System.out.println(state+" "+tips);
        /*
        此种方法为第二种实现扩展方式，更加贴合OO编程，可以将枚举对象通过get函数返回私有字段
        此时的构造函数不再是创建新的实例化，而是将枚举对象实例化，
         */
    }
}

关于枚举的几个API：

2.关于内部类的理解

1.非静态内部类

通过外部类创建内部类，必须实例化内部类，才能访问内部类属性

此外实例化内部类可以访问内部类的私有字段

注意在main函数创建内部类的方式

如下测试代码

package work;
class OuterClass1{
    private int x=1;
     class InterClass1{
        int y=10;
        private int z=20;
        public void show(){
            System.out.println("InterClass:x="+y);
            System.out.println("OuterClass:y="+x);
        }
    }
    public void show(){
        //内部类依旧是类，必须实例化才能在外部类中访问里面的字段
        InterClass1 one=new InterClass1();
        System.out.println("InterClass:z="+one.z);
        System.out.println("InterClass:y="+one.y);
        System.out.println("OuterClass:x="+x);
    }
}

2 . 静态内部类

class OuterClass2{
    int a=1;
    static class InterCalss2{
        int b=10;
        static int c=100;
        public void show(){
            System.out.println("InterCalss2:b="+b+"c="+c);
            //报错  System.out.println("OuterCalss2:a="+a);
        }
    }
    public void show(){
        //静态不可调用非静态
        //非静态可以调用静态
        InterCalss2 one=new InterCalss2();
        System.out.println("OuterClass2:a="+a+"b="+one.b+"c="+InterCalss2.c);
        //注意a，b，c的实现方式
    }
}

3.私有内部类

class OuterClass3{
    int A=1;
    private class InterClass3{
        int B=10;
        static int C=100;
        public void show(){
            System.out.println("InterClass3:B="+B+"C="+C);
            System.out.println("OuterClass3:A="+A);
        }
    }
    public void show(){
        OuterClass3.InterClass3 one3=new InterClass3();
        System.out.println("OuterClass3:A="+A+"B="+one3.B+"C="+InterClass3.C);
    }
}

注意一点就是私有内部类在main中无法访问，就是无法实例化

测试代码：

public class interClassTest {
    public static void main(String[] args) {
        //测试非静态内部类
        OuterClass1 outer1 = new OuterClass1();
        OuterClass1.InterClass1 inter1 = new OuterClass1().new InterClass1();
        //OuterClass1.InterClass1 inter1 = outer1.new InterClass1();此方式创建也可以
        outer1.show();
        inter1.show();
        //测试静态内部类
        OuterClass2 outer2=new OuterClass2();
        OuterClass2.InterCalss2 inter2=new OuterClass2.InterCalss2();
        outer2.show();
        inter2.show();
        //测试私有内部类
        OuterClass3 outer3=new OuterClass3();
        // 报错，此类为内部类OuterClass3.InterClass3 inter3=new ;
        outer3.show();
    }
}

over；