3.28日java学习总结

3.28日java学习总结

枚举类型

1，枚举类型的定义包括枚举声明和枚举体格式如下：

enum 枚举名{
	枚举体(常量列表)
}

2，可以将枚举类型看作是一个类，它继承于java.lang.Enum类，当定义一个枚举类型时，每一个枚举类型成员都可以看作是枚举类型的一个实例，这些枚举类型成员都默认被final，public，static修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可
3，枚举类型中的常用方法

方法名称	具体含义	使用方法
values()	该方法可以将枚举类型成员以数组形式返回	枚举类型名称.values()
valueOf()	该方法可以实现将普通字符串转换为枚举实例	枚举类型名称。valueOf()
compareTo()	该方法用于比较两个枚举对象在定义时的顺序	枚举对象.compareTo()
ordinal	该方法用于得到枚举成员的位置索引	枚举对象.ordinal()

4，枚举类型中的构造方法

enum 枚举类型名称{
	Constants_A("我是枚举成员A"),
	Constants_B("我是枚举成员B"),
	Constants_c(3);
	private String description;
	private Constants2(){//定义默认的构造方法
	}
	//定义带参数的构造方法
	private Constants2(String description){
	this.description=description;
	}
	private COnstants2(int i){
	this i=i;
	}
}

从上面的例子可以看出，无论是无参构造方法还是有参构造方法，修饰权限都为private。

5，使用枚举类型的优势
（1）类型安全
（2）紧凑有效的数据定义
（3）可以和程序其它部分完美交互
（4）运行效率高

泛型

1，泛型是JDK1.5以后增加的，它可以帮助我们建立类型安全的集合。在使用了泛型的集合中，遍历时不必进行强制类型转换。JDK提供了支持泛型的编译器，将运行时的类型检查提前到了编译时执行，提高了代码可读性和安全性。 泛型的本质就是“数据类型的参数化”。 我们可以把“泛型”理解为数据类型的一个占位符(形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。也可以把它理解为是一个函数里的形参
2，泛型的常规用法
（1）定义泛型类时声明多个类型
语法如下

MutiOverClass<T1,T2>
MutiOverClass：泛型类名称

（2）定义泛型类时声明数组类型

public class ArrayClass<T> {
	private T[] array;
	public void SetT(T[] array) {
		this.array=array;
	}
	public T[] getT() {
		return array;
	}
	public static void main(String[] args) {
		ArrayClass<String>a=new ArrayClass<>();
		String[] array= {"chengy1","chengy2","chengy3"};
		a.SetT(array);
		for(int i=0;i<a.getT().length;i++) {
			System.out.println(a.getT()[i]);
		}
	}
}

注意不可以使用泛型来建立数组的实例
（3）集合类声明容器的元素

集合类	泛型定义
ArrayList	ArrayList
HashMap	HashMap
HashSet	HashSet
Vector	Vector

3，泛型的高级用法
（1）限制泛型可用类型

class 类名称<T extends anyClass>

其中anyClass指某个接口或类，在泛型限制后，泛型类的类型必须实现或继承anyClass这个接口或类。例如：

import java.util.ArrayList;
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 l3=new LimitClass();
	}
}

（2）使用类型通配符
在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时限制这个泛型类的类型实现或继承某个接口或类的子类。语法如下
泛型类名称a=null;
除了可以实例化一个限制泛型类型的实例外，还可以将该实例放置在方法的参数中

public void dosomething（A<?extends List>a）{}

如果使用A这种形式实例化泛型类对象，则默认表示可以将A指定为实例化Object及以下的子类类型。下面是例子

List<String>l1=new ArrayList<String>();
l1.add("dsad");
List<?>l2=l1;
List<?>l3=new LinkedList<Integer>();

在上面这个例子中List类型的对象可以接受String类型的ArrayList集合。Listl2=l1与List l2=l1的区别在于，使用通配符声明的名称实例化对象不能对其加入新的信息，只能获取或删除
。
泛型类型限制除了可以向下限制之外，还可以向上限制，只要在定义时使用super关键字

4，泛型总结
（1）泛型的类型参数只能是类类型，不可以是简单的类型
（2）泛型的类型个数可以是多个
（3）可以使用extends关键字限制泛型的类型
（4）可以使用通配符限制泛型的类型

代码

public class ShowEnum {
	enum Constants2{
		Constants_A,Constants_B,Constants_C
	}
	public static void compare(Constants2 c) {
		for(int i=0;i<Constants2.values().length;i++) {
			System.out.println(c+"与"+Constants2.values()[i]+"的比较结果为:"+c.compareTo(Constants2.values()[i]));
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<Constants2.values().length;i++) {
			System.out.println("枚举类型成员变量："+Constants2.values()[i]);
		}
		System.out.println("------------------------------------");
		compare(Constants2.valueOf("Constants_B"));
		System.out.println("------------------------------------");
		for(int i=0;i<Constants2.values().length;i++) {
			System.out.println(Constants2.values()[i]+"位置是"+Constants2.values()[i].ordinal());
		}
	}
}

枚举类型成员变量：Constants_A
枚举类型成员变量：Constants_B
枚举类型成员变量：Constants_C
------------------------------------
Constants_B与Constants_A的比较结果为:1
Constants_B与Constants_B的比较结果为:0
Constants_B与Constants_C的比较结果为:-1
------------------------------------
Constants_A位置是0
Constants_B位置是1
Constants_C位置是2

public class EnumIndexTest {
	enum Constants2{
		Constants_A("我是枚举成员A"),
		Constants_B("我是枚举成员B"),
		Constants_C("我是枚举成员C"),
		Constants_D(3);
		private String description;
		private int i=4;
		private Constants2() {
		}
		private Constants2(String description) {
			this.description=description;
		}
		private Constants2(int i) {
			this.i=i;
		}
		private String getDescription() {
			return description;
		}
		private int geti() {
			return i;
		}
	}
	public static void main(String[] args) {
		for(int i=0;i<Constants2.values().length;i++) {
			System.out.println(Constants2.values()[i]+"调用方法为"+Constants2.values()[i].getDescription());
		}
		System.out.println(Constants2.valueOf("Constants_D")+"pa"+Constants2.valueOf("Constants_D").geti());
	}
}

Constants_A调用方法为我是枚举成员A
Constants_B调用方法为我是枚举成员B
Constants_C调用方法为我是枚举成员C
Constants_D调用方法为null
Constants_Dpa3