Java第十一章总结

11.1 枚举

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

11.1.1 使用枚举类型设置常量

在项目中创建Constants接口，在接口中定义常量的常规方式。

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

使用枚举类型定义常量的语法

public enum Constants{
        Constants_A,
        Constants_B,
        Constants_C
}

package summary;



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


public class ConstantsTest {

	enum Constants2{
		Constants_A, Constants_B
	}
	
	
	public static void doit(int c){
		switch (c){
		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);
	}

}

doit() Constants_A
doit2() Constants_A
doit2() Constants_B

11.1.2  深入了解枚举类型

枚举类型较传统定义常量的方式，除了具有参数类型检测的优势之外，还具有其他方面的优势。

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

package summary;


public class ShowEnum{

	enum Constants{
		Constants_A,
		Constants_B,
		Constants_C,
		Constants_D
	}
	
	
	
	public static void main(String[] args) {
		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

从枚举类型构造方法的语法中可以看出，无论是无参构造方法还是有参构造方法，修饰权限都为private。

定义一个构造方法后，需要对枚举类型成员相应的使用该构造方法

package summary;

public class EnumConTest {
	
	enum Constants2 {
		Constants_A("我是枚举成员A"),
		Constants_B("我是枚举成员B"),
		Constants_C("我是枚举成员C"),
		Constants_D(3);
		
		private String description;
		private int i = 4;
		private Constants2(String decription){
			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) {
		
		
		Constants2 array[] = Constants2.values();
		for(int i = 0; i < array.length; i++){
			System.out.println(array[i] + "调用getDescription（）方法为：" + array[i].getDescription());
		}
		
		
		Constants2 c2 = Constants2.valueOf("Constants_D");
		System.out.println(c2 + "调用getI（）方法为：" + c2.getI());
		
	}

}

Constants_A调用getDescription（）方法为：null
Constants_B调用getDescription（）方法为：null
Constants_C调用getDescription（）方法为：null
Constants_D调用getDescription（）方法为：null
Constants_D调用getI（）方法为：7

 

package summary;



public enum AnyEnum implements EnumInterface{
	
	
	Constants_A{
		public String getDescription(){
			return ("我是枚举成员A");
		}
		
		public int getI(){
			return i;
		}
		
	},
	
	
	Constants_B{
		
		public String getDescription(){
			return ("我是枚举成员B");
		}
		
		public int getI(){
			return i;
		}
	
	},
	

	Constants_C{
		
		public String getDescription(){
			return ("我是枚举成员C");
		}
		
		public int getI(){
			return i;
		}
	
	},
	

	Constants_D{
		
		public String getDescription(){
			return ("我是枚举成员D");
		}
		
		public int getI(){
			return i;
		}
	
	};
	
	private static int i = 5;
	
	
	public static void main(String[] args){
		AnyEnum array[] = AnyEnum.values();
		for(int i = 0; i < array.length; i++){
			System.out.println(array[i] + "调用getDescription（）方法" + array[i].getDescription());
			System.out.println(array[i] + "getI（）方法" + array[i].getDescription());
		}
	}
	
}

package summary;

public interface EnumInterface {

	public String getDescription();
	public int getI();
}

Constants_A调用getDescription（）方法我是枚举成员A
Constants_AgetI（）方法我是枚举成员A
Constants_B调用getDescription（）方法我是枚举成员B
Constants_BgetI（）方法我是枚举成员B
Constants_C调用getDescription（）方法我是枚举成员C
Constants_CgetI（）方法我是枚举成员C
Constants_D调用getDescription（）方法我是枚举成员D
Constants_DgetI（）方法我是枚举成员D

11.1.3 使用枚举类型的优势

一、提高代码维护性，确保变量合法。

如果利用int类型表示星期一到星期日的话，就要判断输入int变量不在1-7的范围内的情况

用枚举的方式就没有上述问题

public enum Week

{

Monday,

Tuesday,

Wednesday,

Thursday,

Friday,
 

Saturday,
 

Sunday

}

二、提高代码可读性。

使用的时候直接Week.Monday即可

三、提高代码键入。

故该使用枚举类型的场合请使用枚举类型，不要使用无意义的字符表示一些有具体意义的类别
 

11.2 泛型

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

package summary;

public class Test {
	
	private Object b;
	public Object getB(){
		return b;
	}
	
	public void setB(Object b){
		this.b = b;
	}

	public static void main(String[] args) {
		
		Test t = new Test();
		t.setB(new Boolean(true));
		System.out.println(t.getB());
		t.setB(new Float(12.3));
		Float f = (Float) (t.getB());
		System.out.println(f);

	}

}

true
12.3

11.2.2 定义泛型类

Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值与返回值都以Object类型为主。当要使用这些实例时，必须正确地将该实例转换为原来的类型

泛型语法

类名

其中T代表一个类型的名称

package summary;

public class OverClass {
	
	private T over;
	
	public T getOver(){
		return over;
	}
	
	public void setOver(T over){
		this.over = over;
	}
	
	
	public static void main(String[] args){
		OverClass over1 = new OverClass();
		OverClass over2 = new OverClass();
		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

使用泛型定义的类在声明该类对象时可以根据不同的需求2指定真正的类型，而在使用类中的方法传递或返回数据类型时将不再进行类型转换 *** 作。

11.2.3 泛型的常规用法

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

MutiOverClass

MutiOverClass;

其中T1，T2 为可能定义的类型。这样在实例化指定类型的对象时就可以指定多个类型

MutiOverClass=new MutiOverClass();

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

package summary;

public class ArrayClass {

	private T[] array;
	
	public T[] getArray(){
		return array;
	}
	
	public void setArrar(T[] array){
		this.array = array;
	}
	
	public static void main(String[] args) {
		ArrayClass a = new ArrayClass();
		String[] array = {"成员1","成员2","成员3","成员4","成员5"};
		a.setArrar(array);
		for(int i = 0; i < a.getArray().length; i++){
			System.out.println(a.getArray()[i]);
		}
	}

}

成员1
成员2
成员3
成员4
成员5

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

通过在集合类中应用泛型可以使集合类中的元素类型保证唯一性。

package summary;

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

public class MutiOverClass {

	public Map m = new HashMap();
	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) {
		MutiOverClass mu = new MutiOverClass();
		
		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

* 常用的被泛型化的集合类
 * 集合类                                           泛型定义
 * ArrayList        ArrayList
 * HashMap            HashMap
 * HashSet            HashSet
 * Vector            Vector
 

package summary;

import java.util.*;

public class ListClass {

	public static void main(String[] args) {
		

		List a = new ArrayList();
		a.add(1);
		for(int i = 0; i < a.size(); i++){
			System.out.println("获取ArrayList容器的值:" + a.get(i));
		}
		
		
		Map m = new HashMap();
		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));
		}
		
		Set set = new HashSet<>();
		set.add('一');
		set.add('二');
		for(Character c:set){
			System.out.println("获取Set容器的值:" + c);
		}
		
	}

}

获取ArrayList容器的值:1
获取Map容器的值:成员0
获取Map容器的值:成员1
获取Map容器的值:成员2
获取Map容器的值:成员3
获取Map容器的值:成员4
获取Set容器的值:一
获取Set容器的值:二

11.2.4 泛型的高级用法

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

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

class 类名称

 使用泛型限制后，泛型类的类型必须实现或继承了aqnyClass这个接口或类。无论anyClass是接口还是类，在进行泛型限制时必须使用extends关键字

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

在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时，限制这个泛型类的类型。

使用泛型类型通配符语法

泛型类名称 a = null;

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

除了可以实例化一个限制泛型类型的实例外，还可以将该实例放置在方法的参数中。

 

package summary;

import java.util.*;

public class WildClass {

	public static void main(String[] args) {
		List l1 = new ArrayList();
		l1.add("成员");
		List l2 = l1;
		List l3 = new LinkedList();
		System.out.println("l1" + l1.get(0));
		System.out.println("l2" + l2.get(0));
		l1.set(0, "成员改变");
		System.out.println("l1:" + l1.get(0));

	}

}

l1成员
l2成员
l1:成员改变

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

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

public class ExtendClass{
    
}

class SubClass extends ExtendClass{
}

11.2.5 泛型总结

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 这个 类型参数 将在 使用时 （例如继承或实现这个接口，用这个类型声明变量、创建对象时） 确定 （即传入实际的类型参数，也称为类型实参）。