Java学习笔记（30）-java泛型机制与新循环

泛型：

    泛型可以在我们使用某个 类的时候向传递参数一样来向这类中某些内容传递一个类型。动态的决定这个被创建出来的类的实例的方法参数和返回值，属性的类型，从而提高程序的灵活性。需要注意的是，泛型是在java1.5以后提供的新特性。泛型仅支持引用类型。

java1.5的另一个特性：新循环（增强for循环）新循环的作用是专为遍历数组和集合使用的。

    元素类型        元素             数组或集合

for(ElementType element:ArrayOrCollection）{....}

遍历数组或集合（ArrayOfCollection),将每一个元素依此赋值给element后进入循环体。直到所有元素均被迭代完毕后退出循环。

package day03;
/**
 * 泛型
 * @author Administrator
 *
 */

import java.util.ArrayList;
import java.util.Iterator;

public class DemoList {
	public static void main(String[] args) {
		/*
		List list = new ArrayList();
		list.add(new Point(1, 2));
		list.add(new Point(2, 3));
		list.add(new Point(3, 4));
		list.add("");
		for(int i=0;i<list.size();i++){
			Point p = (Point)list.get(i);
			System.out.println(p.getX());
		}*/
		/**
		 * ArrayList支持泛型
		 * public class ArrayList<E>{
		 * public boolean add(E e){};
		 * public E get(int index){};
		 * }
		 */
		ArrayList<Point> list = new ArrayList<Point>();
		list.add(new Point(1, 2));
		list.add(new Point(2, 3));
		list.add(new Point(3, 4));
		for(int i=0;i<list.size();i++){
			Point p = list.get(i);
			System.out.println(p.getX());
		}
		/**
		 * 迭代器也支持泛型，但是迭代器使用的泛型应该和他
		 * 所迭代的集合的泛型类型一致!
		 */
		Iterator<Point> it = list.iterator();
		while(it.hasNext()){
			Point p = it.next();
		}
	}
}

package day03;

public class Point<E,Z> {
	private E x;
	private Z y;
	public Point(E x, Z y){
		this.x = x;
		this.y = y;
	}
	
	public E getX() {
		return x;
	}

	public void setX(E x) {
		this.x = x;
	}

	public Z getY() {
		return y;
	}

	public void setY(Z y) {
		this.y = y;
	}

	public String toString(){
		/*
		 * 重写toString方法，返回的字符串用于描述当前对象
		 * 这个对象保存的 是一个点的信息，所有告知外接x,y的坐标
		 */
		return "x="+x+",y="+y;
	}
	/*
	 * 重写Object继承过来的该方法，用于定义对象内容比较规则
	 */
	public boolean equals(Object obj){
		/*
		 * 若给定的对象obj的地址和当前对象地址一致，那么他们是
		 * 同一个对象，equals肯定要返回true！自己一定像自己！
		 * 当我们在equals方法中有大量的内容比较逻辑时，加上这个判断
		 * 会节省性能的开销!
		 * 
		 */
		/*
		 * equals比较前要进行安全验证，确保给定的对象不是null!
		 * obj若是null，说明该引用变量没有指向任何对象。那么就不能
		 * 引用obj所指向的对象（因为对象不存在）的属性或方法！
		 * 若这么做就会引发NullPointerException，空指针异常！
		 */
		if(obj==null){
			return false;
		}
		/*
		 * 直接将Object转为子类是存在风险的！
		 * 我们不能保证Object和我们要比较的对象是同一个类型的
		 * 这会引发ClassCastException！我们称为类造型异常
		 */
		//重写equals时第一件要做的事情就是判断给定的对象是否和当前
		//对象为同一个类型。不是同类型直接返回false，不具备可比性。
		if(!(obj instanceof Point)){//不是这个类型的实例
			return false;
		}
		Point p = (Point)obj;
		/*
		 * 内容比较逻辑定义。
		 */
		return this.x==p.x && this.y == p.y;
	}
	public static void main(String[] args) {
		/*
		 * main方法是静态方法
		 * 不能直接使用toString()方法，因为该方法不是静态的
		 * java语法规定：
		 * 静态方法中不能直接引用非静态的属性和方法！
		 * 非静态方法中可以直接引用静态属性和方法
		 */
//		System.out.println(toString);//不行！编译错误！
		Point p = new Point(6,6);
		System.out.println(p);//输出p对象的toString方法返回值
	}
}

package day03;
/*
 * 自定义泛型
 */
public class DemoPoint {
	public static void main(String[] args) {
		Point<Double,Long> p = new Point<Double,Long>(1.5,2l);
		System.out.println(p);
	}
}

package day03;
/**
 * 新循环
 * @author Administrator
 *
 */
public class DemoNewFor {
	public static void main(String[] args) {
		/**
		 * 对比新老循环在遍历数组上的差异
		 */
		int[] array = new int[]{1,2,3,4,5,6,7};
		/**
		 * 老循环：
		 * 	自己维护循环次数
		 * 	循环体中自行维护获取元素的方式
		 */
		for(int i=0;i<array.length;i++){//维护循环次数
			int element = array[i];//获取数组元素
			System.out.println(element);
		}
		/**
		 * 新循环：
		 * 	自动维护循环次数（由遍历的数组或集合的长度决定）
		 * 	自动获取每次迭代的元素
		 * 新循环执行流程：
		 * 	遍历数组array中的每个元素，将元素依次赋值给element
		 * 	后进入循环体。直到所有元素均被迭代完毕后退出循环
		 * 注意事项：
		 * 	使用新循环，element的类型应与循环迭代的数组或集合中的元素类型一致！
		 * 	至少要是兼容类型。
		 * 新循环的内部实现是使用迭代器完成的Iterator。
		 */
		int index = 0;
		for(int element: array){
			System.out.println(element+"在"+(index++)+"位");
		}
	}
}

package day03;

import java.util.ArrayList;

/**
 * 使用新循环迭代集合
 * @author Administrator
 *
 */
public class NewFor {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();//泛型
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("赵六");
		/**
		 * 使用新循环来遍历集合
		 * 注意：
		 * 	集合若使用新循环，应该为其定义泛型，否则我们只能
		 * 	使用Object作为接收元素时的类型。
		 * 	通常情况下，集合都要加泛型。
		 */
		for(String str : list){
			System.out.println(str);
		}
	}
}

package day03;

public class Demo {
	public static void main(String[] args) {
		Person person = new Person();
		person.age = 16;
		System.out.println(person.age);
		
		/**
		 * 为什么persons[0].age = 16这句话会报空指针异常
		 * 数组初始化：
		 * 	引用类型数组初始化时，每个元素的默认值为null!
		 * 	基本类型数组的初始化，每个元素的默认值为基本类型
		 * 	数据的默认值，例如int为0 boolean为false
		 */
		Person[] persons = new Person[5];
//		persons[0] = new Person();
		persons[0].age = 16;//NullPointerException
		System.out.println(persons[0].age);
		
//		int[] array = new int[5];
//		array[0] = 1;
//		System.out.println(array[0]);
	}
}

class Person{
	int age;
	String name;
}