java第十一章 枚举与泛型

、-11.1 枚举

枚举是一种数据类型，它是一系列具有名称的常量的集合。

11.1.1 使用枚举类型设置常量

定义常量的常用形式：

public interface Contants {
    public static final int Constants_A=1;
    public static final int Constants_B=12;
}

枚举类型的定义常量的语法(其中enum是定义枚举类型的关键字)

public enum Constants {
    Constants_A;
    Constants_B;
    Constants_C;
}

代码

结果

 

11.1.2 深入了解枚举类型

1、操作枚举类型成员的方法

枚举类型具有参数类型检测，它继承于java.lang.Enum类，每个枚举类型都可以看作是枚举类型的实列，可以直接使用枚举类型名称调用枚举类型成成员。

 （1）values()

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

代码

结果

 

（2）valuesOf()与compareTo()

枚举类型中静态方法valuesOf可以将普通字符串转化为枚举类型，而compareTo(0方法主要用于比较两个 枚举类型成员定义是顺序。

代码

结果 

 

（3ordinal(）

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

代码

结果

 

2.枚举类型中的构造方法

public enum hh {
     hh_a("我是枚举成员A"),
     hh_b("我是枚举成员B"),
     hh_c("我是枚举成员C"),
     hh_d(3);
    String description;
    int i;
private hh(String description){
    this.decription = descrption;
}
private hh(int i){
    thid.i = this.i+i;
    }
}

代码da

public class kk{
	enum hh{
     hh_a("我是枚举成员A"),
     hh_b("我是枚举成员B"),
     hh_c("我是枚举成员C"),
     hh_d(3);
    String description;
    int i = 4;
private hh(String description){
    this.description = description;
}
private hh(int i){
    this.i = this.i+i;
    }
public String getDescription() {
	return description;
}
public int getI() {
	return i;
}
	}
public static void main(String[] agrs) {
	hh str[] = hh.values();
	for(int i =0;i<str.length;i++) {
		System.out.println(str[i]+"调用getDescription()方法为:"+str[i].getDescription());
	}
	hh c2 = hh.valueOf("hh_d");
	System.out.println(c2+"调用getI方法为:"+c2.getI());

​}

代码

interface gg{
	public String getDescription();
	public int getI();
}
	public enum kk implements gg{
		ff_a{
			public String getDescription() {
				return("我是枚举成员A");
			}
	public int getI() {
		return i ;
	}
		},
		ff_b{
			public String getDescription() {
				return("我是枚举成员B");
			}
			public int getI() {
				return i;
			}
		},
		ff_c{
			public String getDescription() {
				return("我是枚举成员C");
			}
			public int getI() {
				return i;
			}
		};
		private static int i = 5;
		public static void main(String[] agrs) {
			kk str[] = kk.values();
			for(int i = 0;i<str.length;i++) {
				System.out.println(str[i]+"调用getDescription方法为:"+str[i].getDescription());
			System.out.println(str[i]+"调用getI()方法为:"+str[i].getI());
			}
		}
	}

11.1.3 使用枚举类型的优势 

（1）类型安全

（2)紧凑有效的数据定义

（3）可以和程序其他部分完美交互

（4）运行效率高

11.2  泛型

泛型实质上就是是程序员定义安全的类型。

11.2.1 回顾“向上转型”与“向下转型”

代码

结果

11.2.2 定义泛型 

Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常是传入的值与返回值的值都可以以Object类为主。

语法：类名<T>

代码

 结果

在项目中定义泛型类

overclass<Float>h = new overclass<Float>();
h.setover(12.3f);
Integer i = h2.getB();//不能将Float型赋值给Integer变量

 11.2.3  泛型的常规用法

1、定义泛型类时声明多个类型

MutOverClass<T1,T2>

MutOverClass:泛型类名称

其中T1和T2为可能被定义的类型

MutOverClass<Boolean,Float>=newMutOverClass<Bollean,Float>();

2/定义泛型类时声明数组类型

代码

结果

 

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

代码

 

 结果

代码

 

 结果

11.2.4 泛型的高级用法 

泛型的高级用法主要包括通过参数类型T的继承和通过类型通配符的继承来限制泛型类

1.通过类型参数T的继承限制泛型类型

语法 class 类名称<T extend anyClass>

代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class LimitClass<T extends List>{
    public static void main(String[]agrs){
        LimitClass<ArrayList> ll = new LimitClass<ArrayList>();
        LimitClass<LinkedList> ll = new LimitClass<LinkedList>();
        //LimitClass<HashMap> ll = new LimitClass<HashMap>();//这句是错的，以为HashMap没有实现List()接口

2.通过类型通配符的继承限制泛型类型

语法<? extends List>a=null;

A<? extends List> a= null;
a= new A<ArrayList>();
a=new A<LinkedList>;

如果没有实例化接口的泛型对象，编译器将会报错。

代码

import java.util.ArrayList;
import java.util.LinkedList;
public class tt {
	public static void main(String[]agrs) {
		List<String>a = new ArrayList<String>();
		a.add("成员");
		List<?>12 = a;
		List<?>13 = new LinkedList<Integer>();
			System.out.println("11:"+a.get(0));
			System.out.println("12:"+12.get(0));
			a.set(0, "成员改变");
			12.add("添加");
			12.set(0,"成员改变");
			13.add(1);
			13.add(0,1);
			System.out.println("a:"+a.get(0));
		}
	}
}

3.继承泛型类与实现泛型接口

定义泛型的类和接口也可以被继承与实现。

public class ExtendsClass<T1>{
    }
class SubClass<T1,T2,T3>extends ExtendClass<T1>{
    //泛型可以比父类多，但不可以比父类少
}

定义的泛型接口也可以被实现。

interface TestInterface<T1>{
}
    class SubClass2<T1,T2,T3> implements TestInterface<T1>{
}

11.2.5 泛型总结

使用泛型要遵循以下原则：

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

（2）泛型的类型个数可以是多个。

（3）可以使用extends关键字限制泛型类型。

（4）可以使用通配符限制泛型类型。