枚举与泛型
枚举
使用枚举类型设置常量
interface Constants{ //将常量放置在接口中
public static final int Constants_A=1;
public static final int Constants_B=11;
}
public class ConstantsTest {
enum Constants2{ //将常量放置在枚举类型中
Constants_A,Constants_B; //enum是定义枚举类型的关键字,
}
public static void doit(int i){
switch(i){
case Constants.Constants_A:
System.out.println("doit() Constants_A");
break;
case Constants.Constants_B:
System.out.println("doit() Constants_B");
break;
}
}
public static void doit2(Constants2 c){
switch(c){
case Constants_A:
System.out.println("doit2() Constants_A");
break;
case Constants_B:
System.out.println("doit2() Constants_B");
break;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
ConstantsTest.doit(Constants.Constants_A);
ConstantsTest.doit2(Constants2.Constants_A);
ConstantsTest.doit2(Constants2.Constants_B);
ConstantsTest.doit(3);
//ConstantsTest.doit2(3);
}
}
/*
在以上代码中,当用户调用doit()方法时,即使编译器不接受在接口中定义的常量参数,也不会报错;但调用doit2()方法,任意传递参数,编译器就会报错,因为这个方法只能接收枚举类型的常量作为其参数。·
*/
操作枚举类型成员的方法
方法名称 | 具体含义 | 使用方法 |
---|---|---|
values() | 该方法可以将枚举类型成员以数组的形式返回 | 枚举类型名称.values() |
valueOf() | 该方法可以实现将普通字符串转换为枚举实例 | 枚举类型名称.valueOf(“abc”) |
compareTo() | 该方法用于比较两个枚举对象在定义时的顺序 | 枚举对象.compareTo() |
ordinal() | 该方法用于得到枚举成员的位置索引 | 枚举对象.ordinal() |
public class ShowEnum {
enum Constants{
Constants_A,Constants_B,Constants_C,Constants_D
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Constants[] enumArray=Constants.values();
for(int i=0;i<enumArray.length;i++){
System.out.println("枚举类型成员变量: "+enumArray[i]);
}
}
}
/*输出结果:
枚举类型成员变量: Constants_A
枚举类型成员变量: Constants_B
枚举类型成员变量: Constants_C
枚举类型成员变量: Constants_D
*/
public class EnumMethodTest {
enum Constants {
Constants_A, Constants_B, Constants_C, Constants_D
}
public static void compare(Constants c) {
Constants[] array = Constants.values();
for (int i = 0; i < array.length; i++) {
System.out.println(c + "与" + array[i] + "的比较结果为:" + c.compareTo(array[i]));
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
compare(Constants.valueOf("Constants_B"));
}
}
/*输出结果
Constants_B与Constants_A的比较结果为:1
Constants_B与Constants_B的比较结果为:0
Constants_B与Constants_C的比较结果为:-1
Constants_B与Constants_D的比较结果为:-2
*/
注:调用compareTo()方法时,如果方法中参数在调用该方法的枚举对象位置之前,则返回正整数,;如果两个互相比较的枚举成员的位置相同,则返回0;如果方法中参数在调用该方法的枚举对象之后,则返回负整数。
public class EnumIndexTest {
enum Constants2{
Constans_A,Constans_B,Constans_C
}
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=0;i<Constants2.values().length;i++){
System.out.println(Constants2.values()[i]+"在枚举类型中位置索引值"+Constants2.values()[i].ordinal());
}
}
}
/*输出结果
Constans_A在枚举类型中位置索引值0
Constans_B在枚举类型中位置索引值1
Constans_C在枚举类型中位置索引值2
*/
枚举类型中的构造方法
public class EnumConTest {
enum Constants2{
Constants_A("我是枚举成员A"),
Constants_B("我是枚举成员B"),
Constants_C("我是枚举成员C"),
Constants_D(3);
private String description;
private int i=4;
//定义参数为String型的构造方法
private Constants2(String description){
this.description=description;
}
private Constants2(int i){
this.i=this.i+i;
}
public String getDescription(){
return description;
}
public int getI(){
return i;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Constants2[] array=Constants2.values();
for(int i=0;i<array.length;i++){
System.out.println(array[i]+"调用getDscription()方法为:"+array[i].getDescription());
}
Constants2 c2=Constants2.valueOf("Constants_D");
System.out.println(c2+"调用getI()方法为:"+c2.getI());
}
}
/*输出结果
Constants_A调用getDscription()方法为:我是枚举成员A
Constants_B调用getDscription()方法为:我是枚举成员B
Constants_C调用getDscription()方法为:我是枚举成员C
Constants_D调用getDscription()方法为:null
Constants_D调用getI()方法为:7
*/
泛型
定义泛型类
语法:类名 其中T代表一个类型的名称
public class OverClass<T> {
private T over;
public T getOver(){
return over;
}
public void setOver(T over){
this.over=over;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
//实例化一个Boolean型的对象
OverClass<Boolean> over1=new OverClass<Boolean>();
OverClass<Float> over2=new OverClass<Float>();
over1.setOver(true);
over2.setOver(12.3f);
Boolean b=over1.getOver();
Float f=over2.getOver();
System.out.println(b);
System.out.println(f);
}
}
/*输出结果
true
12.3
*/
泛型的常规用法
定义泛型类时声明多个类型
//MutiOverClass<T1,T2>
//MutiOverClass:泛型类名称
MutiOverClass<Boolean,Float>=new MutiOverClass<Boolean,Float>();
定义泛型类时声明数组类型
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> a=new ArrayClass<String>();
String[] array={"成员a","成员b","成员c","成员d"};
a.setArray(array);
for(int i=0;i<a.getArray().length;i++){
System.out.println(a.getArray()[i]);
}
}
}
集合类声明容器的元素
import java.util.HashMap;
import java.util.Map;
public class MutiOverClass<K, V> {
public Map<K,V> m=new HashMap<K,V>();
public void put(K k,V v){
m.put(k, v);
}
public V get(K k){
return m.get(k);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
MutiOverClass<Integer, String> mu =new MutiOverClass<Integer,String>();
for(int i=0;i<5;i++){
mu.put(i,"我是集合成员"+i);
}
for(int i=0;i<mu.m.size();i++){
System.out.println(mu.get(i));
}
}
}
/*输出结果
我是集合成员0
我是集合成员1
我是集合成员2
我是集合成员3
我是集合成员4
*/