第十三章枚举与泛型

最新推荐文章于 2024-07-10 21:37:49 发布

有点蕉绿.

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量28

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_76545698/article/details/134296540

版权

13.1枚举类型
13.1.1 使用枚举类型设置常
设置常量时，通常将常量放置在接口中，这样在程序中直接使用。该常量不能被修改，因为在接口定义常量时，该常量的修饰符为final与static。常规定义常量的代码如下：

public interface Constants{

public static final int Constants_A=1;

public static final int Constants_B=12;

}

枚举类型出现后，逐渐取代了上述常量定义方式。使用枚举类型定义常量的语法如下：

public enum Constants{

Constants_A,

Constants_B,

}

其中，enum是定义枚举类型的关键字。当需要在程序中使用该常量时，可以是使用Constants.Constants_A来表示

例题13.1

package shisanzhang; //例题13.1
interface SeasonInterface{           //四季接口
   int SPRING=1,SUMMER=2,AUTUMN=3,WINTER=4;
}
enum SeasonEnum{                   //四季枚举
   SPRING,SUMMER,AUTUMN,WINTER
}
public class SeasonDemo {

   public static void printSeason1(int season) {
       switch(season) {
       case SeasonInterface.SPRING:
           System.out.println("这是春季");break;
       case SeasonInterface.SUMMER:
           System.out.println("这是夏季");break;
       case SeasonInterface.AUTUMN:
           System.out.println("这是秋季");break;
       case SeasonInterface.WINTER:
           System.out.println("这是冬季");break;
       default:
       System.out.println("这不是四季的常量值");
       }

   }
   public static void printSeason2(SeasonEnum season) {
       switch(season) {
       case SPRING:
           System.out.println("这是春季");break;
       case SUMMER:
           System.out.println("这是夏季");break;
       case AUTUMN:
           System.out.println("这是秋季");break;
       case WINTER:
           System.out.println("这是冬季");break;
       }
}
   public static void main(String[] args) {
       printSeason1(SeasonInterface.SPRING);       //使用接口常量做参数
       printSeason1(3);                           //可以使用数字做出参数
       printSeason1(-1);                           //使用接口常量值意外的数字“冒充”常量
       printSeason2(SeasonEnum.WINTER);           //使用枚举做参数，只能用枚举中有的值，无法“冒充”
   }
   }

运行结果如下：

13.1.2 深入了解枚举类型

枚举类型的常用方法如下：

1.values()方法
枚举类型实例包含一个values()方法，该方法可以将枚举类型成员以数组的形式返回

例题13.2

package shisanzhang; //例题13.2
enum SeasonEnum{ //四季枚举
SPRING,SUMMER,AUTUMN,WINTER
}
public class ShowEnum {

public static void main(String[] args) {
// TODO Auto-generated method stub
SeasonEnum es[]=SeasonEnum.values();
for(int i=0;i<es.length;i++) {
System.out.println("枚举常量："+es[i]);
}
}

}

运行结果如下：

2. valueOf()方法与compareTo()方法
枚举类型中静态方法valueOf()方法可以将普通字符串转换为枚举类型，而compareTo()方法用于比较两个枚举类型对象定义时的顺序。

例题13.3

package shisanzhang;               //例题13.3
enum SeasonEnum{                   //四季枚举
   SPRING,SUMMER,AUTUMN,WINTER
}
public class EnumMethodTest {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       SeasonEnum tmp=SeasonEnum.valueOf("SUMMER");   //根据字符串创建一个枚举值
       SeasonEnum es[]=SeasonEnum.values();           //获取所有枚举值
       for(int i=0;i<es.length;i++) {
           String message="";                           //待输出的消息
           int result=tmp.compareTo(es[i]);           //记录两个枚举的比较结果
           if (result<0) {
               message=tmp+"在"+es[i]+"的前"+(-result)+"个位置";
           }else if(result>0) {
               message=tmp+"在"+es[i]+"的后"+result+"个位置";
           }else if(result==0) {
               message=tmp+"与"+es[i]+"是同一个值";
           }
           System.out.println(message);
       }

   }

}

运行结果如下：

3.ordinal()方法
枚举类型中的ordinal()方法用于获取某个枚举对象的位置索引值

例题13.4

package shisanzhang;       //例题13.4

enum SeasonEnum{           //四季枚举
   SPRING,SUMMER,AUTUMN,WINTER
}

public class EnumIndexTest {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       SeasonEnum es[]=SeasonEnum.values();
       for(int i=0;i<es.length;i++) {
           System.out.println(es[i]+"在枚举类型中位置索引值"+es[i].ordinal());
       }
   }

}

运行结果如下：

4.枚举类型中的构造方法
枚举类型定义的构造方法语法如下：

enum 枚举类型名称{
Constants_A("我是枚举成员A"),
Constants_B("我是枚举成员B"),
Constants_C("我是枚举成员C"),
Constants_D("3"),
private String description;
private Constants2(){ //定义默认构造方法
}
private Constants2(String description){ //定义带参数的构造方法，参数类型为字符串类型
this.description = description;
}
private Constants2(int i){ //定义带参数的构造方法，参数类型为整型
this.i=this.i+i;
}
}

无论是有无参构造方法还是有参构造方法，修饰权限都为private.

例题13.5

//例题13.5
enum SeasonEnum{           //四季枚举
   SPRING("万物复苏"),
   SUMMER("烈日炎炎"),
   AUTUMN("秋草枯黄"),
   WINTER("白雪皑皑");

   private String remarks;                       //枚举的备注
   private SeasonEnum(String remarks) {       //构造方法
       this.remarks="我是"+this.toString()+",我来之后"+remarks+"。";
   }
   String getRemarks() {               //获取备注
       return remarks;
   }
}
public class EnumConstructTest {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       SeasonEnum es[]=SeasonEnum.values();
       for(int i=0;i<es.length;i++) {
           System.out.println(es[i].getRemarks());
       }
   }
}

运行结果如下：

13.1.3 使用枚举类型的优势

特点：

类型安全。
紧凑有效的数据定义。
可以和程序其他部分完美交互。
运行效率高。

泛型

泛型实质上就是使程序员定义安全的类型。在没有出现泛型之前，Java也提供了对object类型的引用“任意化” 操作，这种“任意化”操作就是对object类型引用进行向下转型及向下转型操作，但某些强制类型转换的错误也许不会被编译器捕捉，而在运行后出现异常，可见强制类型转换存在安全隐患，所以在此提供了泛型机制

回顾向上转型与向下转型
在介绍泛型之前，先来看一个例子，在项目中创建Test类，在该类中使基本类型向上转型为object类型

public class Test {
   private Object b; //定义object类型成员变量
   public Object getB() { //设置相应的getXXX（）方法
   return b;
   }
   public void setB(Object b) { //设置相应的setXXX（）方法
       this.b = b;
   }

   public static void main(String[] args) {
       Test t = new Test();
       t.setB(Boolean.valueOf(true)); //向上转型操作
       System.out.println(t.getB());
       t.setB(Float.valueOf("12.3")); //向下转型操作
       Float f = (Float)t.getB();
       System.out.println(f);
   }
}

运行结果如下：

在本实例中，Test类中定义了私有的成员变量b，它的类型为Object类型，同时为其定义了相应的setXXX（）与getXXX()方法。在类的主方法中，将Boolean.valueOf(true)作为setB（）方法的参数，向下转型会出现错误，语法错误没有出现编译器会接受此段代码，，但执行时会出现ClassCastException异常，而泛型机制就有效解决了这一问题。

例如以下代码：

t.setB(Float.valuesOf("12.3"));
Integer f = (Integer)t.getB();
System.out.println(f);

定义泛型类
Object类为最上层的父类，为了提前预防发生异常，Java提供了泛型机制其语法如下

类名<T>

例题13.6

public class Book<T> { //定义带泛型的Book<T>类
   private T bookInfo; //类型形参：书籍信息
   public Book(T bookInfo) { //参数为类型形参的构造方法
       this.bookInfo = bookInfo; //为书记信息赋值
   }
   public T getBookInfo() { //获取书籍信息的值
       return bookInfo;
   }
   public static void main(String[] args) {
       // TODO Auto-generated method stub
       //创建参数为String类型的书名对象
       Book<String>bookName =new Book<String>("《Java从入门到精通》");
       //创建参数为String类型的作者对象
       Book<String>bookAuthor =new Book<String>("明日科技");
       //创建参数为String类型的价格对象
       Book<String>bookPrice =new Book<String>("69.8");
       //创建参数为Boolean类型的附赠源码
       Book<Boolean>hasSource =new Book<Boolean>(true);
       //控制台输出书名、作者、价格和是否附赠光盘
       System.out.println("书名："+bookName.getBookInfo());
       System.out.println("作者："+bookAuthor.getBookInfo());
       System.out.println("价格："+bookPrice.getBookInfo());
       System.out.println("是否附赠源代码？"+hasSource.getBookInfo());
   }

}

运行结果如下：

泛型的常规用法
1.定义泛型类时声明多个类型。语法如下：

class MyClass<T1,T2>{ }

T1,T2为可能被定义的类型

在实例化指定类型的对象时就可以指定多个类型，例如：

MyClass<Boolean,Float> m = new MyClass <Boolean,Float>();

2.定义类型类时声明数组类型

定义泛型类时也可以声明数组类型。

例题13.7定义泛型数组

package b;

public class ArrayClass<T> {
   private T[] array; //定义泛型数组
   public T[] getArray() {
       return array;
   }
   public void setArray(T[] array) {
       this.array =array;
   }
   public static void main(String[] args) {
       // TODO Auto-generated method stub
       ArrayClass<String>demo =new ArrayClass<String>();
       String value[] = {"成员1","成员2","成员3","成员4","成员5"};
       demo.setArray(value);
       String array[]=demo.getArray();
       for (int i =0;i<array.length;i++) {
           System.out.println(array[i]);
       }
   }

}

运行结果如下：

可以在使用泛型机制时声明一个数组，但是不可以使用泛型来建立数组的实例

3.集合类声明容器的元素

JDK中的集合接口、集合类都被定义了泛型，其中List<E>的泛型E实际上就是element元素的首字母，Map<K,V>的泛型K和V就是key键和value值的首字母。常用的被泛型化的集合类如下表：

例题13.8

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class AnyClass {
   public static void main(String[] args) {
       // 定义ArrayList容器，设置容器内的值类型为Integer
       ArrayList<Integer> a = new ArrayList<Integer>(); // 为容器添加新值
       a.add(1);
       for (int i = 0; i < a.size(); i++) {
           // 根据容器的长度，循环显示容器内的值
           System.out.println("获取ArrayList容器的值：" + a.get(i));
       }
       // 定义HashMap容器，设置容器的键名与键值类型分别为Integer与String型
       Map<Integer, String> m = new HashMap<Integer, String>();
       for (int i = 0; i < 5; i++) { // 为容器填充键名与键值
           m.put(i, "成员" + i);
       }
       for (int i = 0; i < m.size(); i++) {

           System.out.println("获取Map容器的值" + m.get(i)); // 根据键名获取键值
       }
   }
}
//例题13.8

运行结果如下：

13.2.4 泛型的高级用法

泛型的高级用法包括限制泛型可用类型和使用类型通配符等。

1.限制泛型可用类型

默认可以使用任何类型来实例化一个泛型类对象，但Java中也对泛型类实例的类型做了限制，语法如下：

class 类名称<T extends anyClass>

例题13.9

import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.LinkedList;
   import java.util.List;


       public class LimitClass <T extends List>{
           public static void main(String[]args) {
               // 可以实例化已经实现List接口的类
               LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
               LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
               // 这句是错误的，因为HashMap没有实现List()接口
               LimitClass<HashMap> l3 = new LimitClass<HashMap>();

           }

}

运行结果如下：

出现异常：异常为Hasamap不能·被实例化

如果我们想它不报错的话就将hash map改为导入类中的list。但仍然无法运行，只是不报错。如下

   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.LinkedList;
   import java.util.List;


       public class LimitClass <T extends List>{
           public static void main(String[]args) {
               // 可以实例化已经实现List接口的类
               LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
               LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
               // 这句是错误的，因为HashMap没有实现List()接口
               LimitClass<List> l3 = new LimitClass<List>();

           }

}

2.使用类型通配符

在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时，限制这个泛型类的类型，实现或继承某个接口或类的子类。要声明这样一个对象可以使用“？”通配符来表示，同时使用extends。关键字来对泛型加以限制使用泛型类型通配符的语法，如下：

泛型类名称<？extends List> a=null;

其中，<? extends List>表示类型未知，当需要使用该泛型对象时，可以单独实例化，例如：

A <？extends List> a=null;//定了上界和下界

a=new A<ArraryList>();

a=new A<ArraryLinkList>();

像上述例子的HashMap类没有实现List接口,那编译器就会报错.除了可以实例化一个限制泛型类型的实例,还可以将该实例放置在方法的参数

public void do Something(A<? extendsList>a){}

在上述代码中，定义方式有效地限制了传入do Something()方法的参数类型。如果使用A<？>这种形式实例化泛型类对象，则默认表示可以将a指定为实例化Object及以下的子类类型，例如:

List <String>l1 = new ArraryList<String>(); //实例化一个对象

l1.add("成员")； //在集合中添加内容

List<?>l2=l1;

List<?>l3 = new LinkkedList<integer>();

System.out.println(2.get(0)); //获取集合中第一个值

在上面的例子中list类型的对象可以接受时君类型的和ArraryList集合也可以接受Integer类型的LLinkedList集合。

注意：List<?>12=11和List12=11有区别
使用通配符声明的名称实例化的对象不能对其加入新的信息，只能获取或删除。例如：

.set(0,"成员改变")； //没有使用通配符的对象调用set（）方法

//l2.set（0,"成员改变"）；//使用通配符的对象调用set（）方法，不能被调用。

//l3.set（0，1）；

l2.get（0）； //可以使用l2的获取集合中的值

l2.remove（0）；//根据键名删除集合中的值

3.继承泛型类与接口

定义为泛型的类和接口也可以被继承与实现。例如让Subclass类继承Extendclass类的泛型，代码入下：

class Extend Class <T1>{}

Class Sub Class <T1,T2,T3>extends Extend Class <T1>{}

如果在Sub Class类继承Extend Class类时保留父类的泛型类型，需要在继承时期指明。如果没有指明，直接使用extends Extends Class语句进行继承操作，则SubClass类中的 T1T2和T3都会自动变为object类型，所以在一般情况下都将父类的泛型类型保留。

定义为泛型的接口也可以被实现，例如让Sub Class类实现Some Interface接口，并继承接口的泛型。代码如下：

interface SomeInterface<T1>{}

class SubClass<T1,T2,T3>implements SomeInterface<T1>{}

13.2.5 泛型总结
总结一下泛型的使用方法。

1泛型类型参数只能是类类型，不可以是简单类型，比如A< int>这种泛型定义就是错误的。

2.泛型的类型个数可以是多个

3.可以使用extends关键字限制泛型的类型

4.可以使用通配符限制泛型的类型

有点蕉绿.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十三章枚举与泛型

13.1枚举类型13.1.1 使用枚举类型设置常设置常量时，通常将常量放置在接口中，这样在程序中直接使用。该常量不能被修改，因为在接口定义常量时，该常量的修饰符为final与static。常规定义常量的代码如下：枚举类型出现后，逐渐取代了上述常量定义方式。使用枚举类型定义常量的语法如下：其中，enum是定义枚举类型的关键字。当需要在程序中使用该常量时，可以是使用Constants.Constants_A来表示例题13.1//例题13.1。
复制链接

扫一扫