面向对象——枚举

2301_80708315

已于 2024-08-31 10:02:36 修改

阅读量142

点赞数 2

文章标签： java 前端开发语言

于 2024-07-30 09:59:39 首次发布

本文链接：https://blog.csdn.net/2301_80708315/article/details/140741360

版权

1 什么是枚举

最关键：使用枚举实现入参限制

Java 枚举（Enum）是一种特殊的数据类型，它是一组预定义的常量，每个常量都有一个名称和一个值。

枚举类型在 Java 中被广泛使用，它可以用来代替常量、标志位、状态码等，使代码更加清晰、易读和易维护。

枚举的构造器只能私有，不能创建对象。

A[] as = A.values(); 是获取枚举类型 A 中所有枚举常量的一种简便方法，将它们存储在一个数组中以便后续处理或遍历。

在 Java 中，Arrays 是一个类，它提供了一系列静态方法来操作数组。其中，toString() 方法用于返回指定数组的字符串表示形式，以便于输出或打印。这里，Arrays.toString(as) 将枚举常量数组 as 转换为字符串形式，方便查看和输出。

import java.lang.reflect.Array;
import java.util.Arrays;

//认识枚举
public class Test {
    public static void main(String[] args) {
                    A a1 = A.X;
       // A.X =null;因为xyz为static final修饰不能赋值
        System.out.println(a1);

        //枚举类的构造器是私有的，不能对外创建对象
       // A  a= new  A();

        //枚举类是第一行都是常量，记住的是枚举类的对象
        A a2 = A.Y;


       //3，枚举类提供一个一些额外的API
        A[]as = A.values();//拿到全部对象
        //利用方法打印
        System.out.println(Arrays.toString(as));
        A a3 =   A.valueOf("Z");
        System.out.println(a3.name());//Z
        System.out.println("------------------------");
        //ordinal()方法打印的是枚举项的索引的位置
        System.out.println(A.X.ordinal());
        System.out.println(A.Y.ordinal());
        System.out.println(A.Z.ordinal());
        System.out.println("--------------------------");
        System.out.println(a3.ordinal());//索引
        System.out.println("------------------------------");
        B y = B.Y;
        y.go();
        System.out.println("-----------------------------------");
       //四种打印枚举变量的方法
        A  [] w =A.values();
        //1
        for (int i = 0; i < w.length; i++) {
            System.out.println(w[i]);
        }
        //2
        System.out.println(Arrays.toString(w));
        //3
        for (A e:w)
        {
            System.out.println(e);
        }

    }
}

x,y,z都是被static final修饰的。可以直接用类名.x；调用

public enum A {
    //枚举的第一行必须为罗列枚举对象的名称
    X,Y,Z;
    private  String name;

    private A() {
   }//构造器必须私有

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
            //成员方法
    public void show(){}

}

抽象枚举

抽象枚举相比与普通的枚举，就是在枚举内部有抽象方法，需要重写抽象方法，才能够在枚举里面创建对象。

因为枚举不能创建对象。所以当我在枚举创建一个抽象方法必须在枚举变量中去重新实现方法

//抽象枚举
public enum B {
   X(){
       @Override
       public void go() {

       }
   }, Y("张三")
   {
       @Override
       public void go() {
           System.out.println(getName()+"在跑-----");
   }
   };


   private  String name;

   private B() {
    }

  private   B(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }




    public  abstract   void go();

}

四种打印枚举的方式

enum A {
    X, Y, Z
}

public class Main {
    public static void main(String[] args) {
        A[] as = A.values();
        System.out.println(Arrays.toString(as));
    }
}

enum A {
    X, Y, Z
}

public class Main {
    public static void main(String[] args) {
        A[] as = A.values();
        for (A a : as) {
            System.out.println(a);
        }
    }
}

enum A {
    X, Y, Z
}

public class Main {
    public static void main(String[] args) {
        A[] as = A.values();
        for (int i = 0; i < as.length; i++) {
            System.out.println(as[i]);
        }
    }
}

流操作来打印枚举常量

这段代码利用了流操作 Arrays.stream(A.values()) 来将枚举常量转换为流，然后使用 forEach(System.out::println) 打印每个枚举常量。

import java.util.Arrays;

enum A {
    X, Y, Z
}

public class Main {
    public static void main(String[] args) {
        Arrays.stream(A.values())
              .forEach(System.out::println);
    }
}

利用枚举设计单例设计模式

public enum C {
    X;//单例
}

枚举的作用（重点）

//枚举的应用
public class Test {
public static void main(String[] args) {
//常规方法
Check(Constant.BOY);//常量入参不受约束
Check(21);//常量入参不受约束
System.out.println("----------------------");
//利用枚举
check(Constant2.BOY);//使用枚举实现入参限制

枚举的案例

常量入参不受约束，使用枚举实现入参限制使得参数只有女生跟男生

//枚举的应用
public class Test {
    public static void main(String[] args) {
        //常规方法
        Check(Constant.BOY);//常量入参不受约束
        Check(21);//常量入参不受约束
        System.out.println("----------------------");
        //利用枚举
            check(Constant2.BOY);//使用枚举实现入参限制


    }
     //利用枚举
    public  static  void  check(Constant2 sex){
        switch (sex)
        {
            case BOY:
                System.out.println("展示游戏");
                break;
            case GIRL:
                System.out.println("展示衣服");
                break;
        }
    }
    //常量方法
    public  static  void  Check( int sex)
    {
        switch (sex)
        {
            case Constant.BOY:
                System.out.println("展示游戏");
                break;
            case Constant.GIRL:
                System.out.println("展示衣服");
                break;
        }
    }
}

//常量
public class Constant {
    public  static  final  int BOY =0;
    public  static  final  int GIRL =1;
}

//枚举       使得只有女生跟男生
public enum Constant2 {
    BOY,GIRL;
}

实例练习

// 定义枚举类型 CoffeeSize
enum CoffeeSize {
    SMALL, MEDIUM, LARGE
}

// 定义咖啡类 Coffee
class Coffee {
    private CoffeeSize size;
    private double price;

    // 构造方法根据咖啡大小设置价格
    public Coffee(CoffeeSize size) {
        this.size = size;
        switch (size) {
            case SMALL:
                this.price = 2.0;
                break;
            case MEDIUM:
                this.price = 3.0;
                break;
            case LARGE:
                this.price = 4.0;
                break;
        }
    }

    // 获取咖啡大小
    public CoffeeSize getSize() {
        return size;
    }

    // 获取咖啡价格
    public double getPrice() {
        return price;
    }
}

// 测试类 CoffeeShop
public class CoffeeShop {
    public static void main(String[] args) {
        // 创建不同大小的咖啡
        Coffee smallCoffee = new Coffee(CoffeeSize.SMALL);
        Coffee mediumCoffee = new Coffee(CoffeeSize.MEDIUM);
        Coffee largeCoffee = new Coffee(CoffeeSize.LARGE);

        // 输出咖啡的大小和价格
        System.out.println("Small Coffee - Size: " + smallCoffee.getSize() + ", Price: $" + smallCoffee.getPrice());
        System.out.println("Medium Coffee - Size: " + mediumCoffee.getSize() + ", Price: $" + mediumCoffee.getPrice());
        System.out.println("Large Coffee - Size: " + largeCoffee.getSize() + ", Price: $" + largeCoffee.getPrice());
    }
}

关于输出形式上的问题

为什么报错

  System.out.println(s.getSize()+s.getSize());

1.使用Sting.format格式化输出

public class CoffeeShop {
    public static void main(String[] args) {
        Coffee s = new Coffee(CoffeeSize.SMALL);
        Coffee m = new Coffee(CoffeeSize.MEDIUM);
        Coffee l = new Coffee(CoffeeSize.LARGE);

        // 使用 String.format 格式化输出
        String output = String.format("Small Coffee - Size: %s, Price: $%.2f\n", s.getSize(), s.getPrice());
        output += String.format("Medium Coffee - Size: %s, Price: $%.2f\n", m.getSize(), m.getPrice());
        output += String.format("Large Coffee - Size: %s, Price: $%.2f\n", l.getSize(), l.getPrice());

        System.out.println(output);
    }
}