Lesson_for_java_day14--java中的泛型、Comparator、Comparable

最新推荐文章于 2022-01-26 11:43:48 发布

记得要幸福56

最新推荐文章于 2022-01-26 11:43:48 发布

阅读量1.1k

点赞数

分类专栏： lessonForJava 文章标签：泛型 java

本文链接：https://blog.csdn.net/u013233075/article/details/24383313

版权

lessonForJava 专栏收录该内容

40 篇文章 1 订阅

订阅专栏

泛型：

Demo1：

package generic;

import java.util.ArrayList;
import java.util.Iterator;
/*
	泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
		好处：1、将运行时期出现的问题classCastException，转移到编译时期，方便于程序员解决问题。
				让运行事情问题减少，安全。
			  2、避免了强制类型转换的麻烦。
			  
	泛型格式：通过<>来定义要操作的的引用数据类型。
	在使用java提供的对象时，什么时候写泛型呢？
		通常在集合框架中很常见，只要定义到<>就要定义泛型。
		
	其实<>就是用来接收类型的。
	
	当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
 */
public class GenericDemo {
	public static void main(String[] args) {
		
		//<String>泛型，解决数据存储时的数据类型，防止出错
		ArrayList<String> al = new ArrayList<String>();
		al.add("abd01");
		al.add("a01");
		al.add("abd02");
		al.add("ab81");
		al.add("abd0174");
		
		for(Iterator<String> it = al.iterator();it.hasNext();){
			String s = it.next();           //不需要再强制类型转换了
			System.out.println(s + ":" + s.length());
		}		
	}
}

Demo2：

package generic;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo2 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeSet<String> ts = new TreeSet<String>(new LenComparetor());
		ts.add("abd01");
		ts.add("a01");
		ts.add("abd02");
		ts.add("ab81");
		ts.add("abd0174");
		
		for(Iterator<String> it = ts.iterator();it.hasNext();){
			String s = it.next();           //不需要再强制类型转换了
			System.out.println(s);
		}		
	}
}

class LenComparetor implements Comparator<String>{//使用泛型
	public int compare(String o1,String o2){//无需再强制类型转换
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num == 0)
			return o1.compareTo(o2);
		return num;
	}
}

Demo3：

package generic;

public class GenericDemo3 {
	public static void main(String[] args) {
		//采用泛型机制，当类型输入异常时，编译时直接出错，提醒修改程序，提高安全性
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject();
		
		/*
		//当类型转换异常时，编译时不会出错，运行时才会抛出ClassCastException，这就降低了程序的安全性。
		Tool t = new Tool();
		t.setObject(new Student01());
		Worker w1 = (Worker)t.getObject();
		*/
	}
}

//类1
class Worker{
	
}

//类2
class Student01{
	
}

/*泛型类
	什么时候需要定义泛型类？
		当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
*/	
class Utils<QQ>{
	private QQ q;
	public void setObject(QQ q){
		this.q = q;
	}
	public QQ getObject(){
		return q;
	}
}

//泛型出现之前操作
class Tool{
	private Object o;//向上转型，可复用性好，但是需要人为强制类型转换，容易出错

	public Object getObject() {
		return o;
	}
	public void setObject(Object o) {
		this.o = o;
	}	
}

/*

class Tool{
	private Worker w;//可复用性差

	public Worker getWorker() {
		return w;
	}

	public void setWorker(Worker w) {
		this.w = w;
	}	
}
*/

Demo4：

package generic;
/*
	泛型类定义的泛型，在整个类中有效，如果被方法使用，那么，泛型类的对象明确要操作的
		具体类型后，所以要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且
		类型还不确定，那么可以将类型定义在方法上。
		
	特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，
		可以将泛型定义在方法上。
	
	泛型位置：定义在类中，泛型在类名后面；定义在方法中，泛型在返回值前面。(书写格式)
 */

//泛型定义在类上和方法上
public class GenericDemo4 {
	public static void main(String[] args) {
		
		/*方式一：
		Demo<Integer> d = new Demo<Integer>();
		d.show(4);
		d.print(new Integer(5));
		
		Demo<String> d1 = new Demo<String>();
		d1.show("hahaha");
		d1.print("hehehe");
		*/
		
		/*方式二：
		Demo d = new Demo();
		d.show("hahah");
		d.show(new Integer(4));
		d.print("heihei");
		d.print(5);
		*/
		
		//方式三：
		Demo<String> d = new Demo<String>();
		d.show("haha");
		d.print("heihei");
		d.print(9);
		Demo.method("lalalal");
	}
}

//方式三：类上定义泛型，方法上也可以另外定义泛型。
class Demo<T>{
	public void show(T t){
		System.out.println("show:" + t);
	}
	public <Q>void print(Q q){
		System.out.println("print:" + q);
	}
	public static<W> void method(W w){
		System.out.println("method:" + w);
	}
	
	//静态方法不可以访问类上定义的泛型，可以将泛型定义在方法上
//	public static void method(T t){
//		System.out.println("method:" + t);
//	}
}


/*方式二：泛型只定义在方法上
class Demo{
	public <T>void show(T t){
		System.out.println("show:" + t);
	}
	public <Q>void print(Q q){
		System.out.println("print:" + q);
	}
}
*/

/*方式一：方法与类的类型一致
class Demo<T>{
	public void show(T t){
		System.out.println("show:" + t);
	}
	public void print(T t){
		System.out.println("print:" + t);
	}
}
*/

Demo5：

package generic;
/*
	泛型定义在接口上：
 */
public class GenericDemo5 {
	public static void main(String[] args) {
		
		/*方式一：调用者无需再指定类型
		InterImpl i = new InterImpl();
		i.show("hahaha");
		*/
		
		//方式二：由调用者来指定泛型类型
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(5);
		
	}
}

//方式二：实现接口时也不知道泛型类型，保持与接口类型一致
class InterImpl<T> implements Inter<T>{
	public void show(T t){
		System.out.println("show:" + t);
	}
}


/*方式一：实现接口时就指定类型
class InterImpl implements Inter<String>{
	public void show(String t){
		System.out.println("show:" + t);
	}
}
*/

interface Inter<T>{
	void show(T t);
}

Demo6：

package generic;

/*
	泛型：?为通配符。也可以理解为占位符。
	泛型的限定：
		? extends E: 可以接收E类型或者E的子类型。上限。
		? super E: 可以接收E类型或者E的父类型。下限。
 */

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

public class GenericDemo6 {
	public static void main(String[] args) {

/*方式一：方式二：
		ArrayList<String> al = new ArrayList<String>();
		
		al.add("abd1");
		al.add("abd1");
		al.add("abd1");

		ArrayList<Integer> all = new ArrayList<Integer>();
		
		all.add(4);
		all.add(7);
		all.add(1);
*/
		
		//方式一：不通用，printColl(all);不能操作
		//printColl(al);
		
		//方式二：使用?或T，定义通用泛型
		//printColl(al);
		//printColl(all);
		
		//方式三：限定泛型的类型为某一父类及其子类对象
		ArrayList<Student> al = new ArrayList<Student>();	
		al.add(new Student("abc---1"));
		al.add(new Student("abc---2"));
		al.add(new Student("abc---3"));
		printColl(al);
	}
	
	//方式三：限定泛型的类型为Person及其子类
	public static void printColl(ArrayList<? extends Person> al){
		for(Iterator<? extends Person> it = al.iterator();it.hasNext();){
			System.out.println(it.next().getName());
		}
	}
/*
	//方式二：定义泛型，可通用
	public static void printColl(ArrayList<?> al){
		for(Iterator<?> it = al.iterator();it.hasNext();){
			System.out.println(it.next());
			//不能使用对象特有的方法，如下例：
			//it.next().length();
		}
	}
	//用?和用T的区别：
//	public static <T>void printColl(ArrayList<T> al){
//		for(Iterator<T> it = al.iterator();it.hasNext();){
//			T t = it.next();            //使用T可以接收对象，而使用?不可以接收对象。
//			System.out.println(it.next());
//		}
//	}
*/	
	
	
	/*方式一：定义泛型，但是不能通用
	public static void printColl(ArrayList<String> al){
		for(Iterator<String> it = al.iterator();it.hasNext();){
			System.out.println(it.next());
		}
	}
	*/
	
}

class Student extends Person{
	Student(){
		
	}
	Student(String name){
		super(name);
	}
}


class Person{
	private String name;
	Person(){
		
	}
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}

Demo7：

package generic;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo7 {
	public static void main(String[] args) {
		TreeSet<Student1> ts = new TreeSet<Student1>(new Comp());
		ts.add(new Student1("abc01"));
		ts.add(new Student1("abc02"));
		ts.add(new Student1("abc03"));
		ts.add(new Student1("abc04"));
		
		Iterator<Student1> it = ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
		
		TreeSet<Worker1> ts1 = new TreeSet<Worker1>(new Comp());
		ts1.add(new Worker1("abc----01"));
		ts1.add(new Worker1("abc----02"));
		ts1.add(new Worker1("abc----03"));
		ts1.add(new Worker1("abc----04"));
		
		Iterator<Worker1> it1 = ts1.iterator();
		while(it1.hasNext()){
			System.out.println(it1.next().getName());
		}		
	}
}

//泛型定义父类
class Comp implements Comparator<Person1>{
	public int compare(Person1 s1,Person1 s2){
		return s1.getName().compareTo(s2.getName());
	}
}

class Student1 extends Person1{
	Student1(String name){
		super(name);
	}
}

class Worker1 extends Person1{
	Worker1(String name){
		super(name);
	}
}


class Person1{
	private String name;
	
	Person1(){
		
	}
	Person1(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}

	public String toString(){
		return "Person:" + name;
	}
}