java之15天 泛型 (二)

泛型类
泛型方法
静态泛型

/**
 * 泛型类定义的泛型,在整个类中有效
 * 如果被方法使用.那么泛型类的对象明确要要操作的具体类型后,所有方法要操作的类型就已经固定了
 *  
 *  为了让不同方法可以操作不同类型,而且类型还不确定
 *  那么可以将泛型定义在方法上.
 *  
 *  特殊之处
 *  静态方法不可以访问类上定义的泛型,因为  泛型 都是在创建对象的时候才制定,如果静态会编译失败
 *  如果静态方法操作的引用数据类型不确定,可以将泛型定义在方法上.
 *  泛型定义在静态上 放在返回值前面, 修饰符后面 
 *  
 */

class Demo<T>{ 
	public void show(T t){
		System.out.println("show:"+t);
	}
	public void print(T t){
		System.out.println("print"+t);
	}
	
}

//变形1
class Demo1{
	public <T> void show(T t){ //在方法上定义泛型 只需要加入<T> 就行了 而且 T的作用范围只在这个方法中
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q){//在方法上定义泛型 只需要加入<Q> 就行了
		System.out.println("print"+q);
	}
}

//变形2  泛型类和泛型方法一起使用  
class Demo2<T>{
	public void show(T t){ //沿用 泛型类 中的T
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q){//在方法上定义泛型 只需要加入<Q> 就行了
		System.out.println("print"+q);
	}
	
/*	编译报错
 *  public static void method(T t){
		System.out.println("method"+t);
	}
	*/
	//静态泛型   
	public static <W> void method(W t){ //泛型定义在静态上 放在返回值前面, 修饰符后面 
			System.out.println("method"+t);
	}
}


public class GenericDemo4 {
	public static void main(String[] args) {
		/*
		Demo<Integer> d=new Demo<Integer>();
		d.show(new Integer(4));
		d.print(9);
		//d.print("haha"); //编译失败 new Demo对象的时候  T 就表示 Integer对象了,所以打印字符串,就会有问题
		Demo<String> d1=new Demo<String>();
		d1.show("haha");
		//d1.print(9); 也编译失败 
		
		*/
		Demo1 d1=new Demo1();
		d1.show(new Integer(4));
		d1.print(9);
		
		Demo2<String> d2=new Demo2<String>();
		d2.show("hahh");
		//d2.show(5); 编译报错 
		d2.print(4);
		
	}

}

泛型接口

/**
 * 泛型定义在 接口上
 *
 */
interface Inter<T>{
	void show(T t);
}

//实现的额时候知道了什么类型
class InterImpl implements Inter<String>{

	@Override
	public void show(String t) {
		System.out.println("show:"+t);
	}
}

//实现的时候不知道类型
class InterImpl1<T> implements Inter<T>{
	
	public void show(T t){
		System.out.println("show:"+t);
	}
}

public class GenericDemo5 {

	public static void main(String[] args) {
		Inter i=new InterImpl();
		i.show("hah");
		//i.show(1); //编译通过  运行失败  
		
		Inter<Integer> i1=new InterImpl1<Integer>();
		i1.show(9);
	}

}

泛型限定

/**
 *  ? : 通配符  也可以理解为占位符 ,没办法定义 ,不知道 不明确
 *  
 * 泛型的限定 上限 和 下限
 *  ? extends E: 可以接受 E类 或者 E 的子类型   上限(父类被限制了,子类没有限制)
 *  ? super E:   可以接受 E类 或者 E 的父类型   下限(子类被限制了,父类没有限制)
 *
 */
class Person{
	private String name;
	
	Person(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
}

class Student1 extends Person{
	Student1(String name){
		super(name);
	}
}
//下限
class Student2 extends Person implements Comparable<Person>{//? super E
	
	Student2(String name){
		super(name);
	}

	@Override
	public int compareTo(Person o) {
		return this.getName().compareTo(o.getName());
	}
}

class myCom implements Comparator<Person>{ // ? super E

	@Override
	public int compare(Person o1, Person o2) {
		// TODO Auto-generated method stub
		return o1.getName().compareTo(o2.getName());
	}
	
}


public class GenericDemo6 {

	public static void main(String[] args) {
		
		method();
		System.out.println("======================");
		method_1();
		System.out.println("======================");
		method_2();
	}
	
	public static void method_2(){
		TreeSet<Student2> ts=new TreeSet<Student2>(new myCom());
		ts.add(new Student2("abcd1"));
		ts.add(new Student2("abcd2"));
		ts.add(new Student2("abcd3"));
		ts.add(new Student2("abcd4"));
		Iterator<Student2> it=ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
		
	}
	
	
	//操作自定义类型  上限
	public static void method_1(){
		ArrayList<Person> al=new ArrayList<Person>();
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));
		
		printCollection3(al);
		
		ArrayList<Student1> al1=new ArrayList<Student1>();
		al1.add(new Student1("abc-----1"));
		al1.add(new Student1("abc-----2"));
		al1.add(new Student1("abc-----3"));
		
		//printCollection3(al1);  //编译报错  error  
		//类似于  	ArrayList<Person> al1=new ArrayList<Student1>();
		
		//采用泛型限定后 就可以这样使用了
		printCollection4(al1);  // ?  extends Person  
		
	}
	
	//操作 应用数据类型 
	public static void method(){
		ArrayList<String> al=new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		
		ArrayList<Integer> all=new ArrayList<Integer>();
		all.add(1);
		all.add(2);
		all.add(3);
		
		//printCollection(al);
		//printCollection(all);//报错 类型不匹配
		
		printCollection1(al);
		printCollection1(all);
		
		printCollection2(al);
		printCollection2(all);
	}
	
	
	public static void printCollection(ArrayList<String> al){
		Iterator<String> it=al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
	
	//变形1 //这里 ? 不明确类型,表示占位符 可以大勇
	public static void printCollection1(ArrayList<?> al){
		Iterator<?> it=al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

	//变形2 可以打印 任何类型
	public static <T> void printCollection2(ArrayList<T> al){
		Iterator<T> it=al.iterator();
		while(it.hasNext()){
			T t=it.next();
			System.out.println(t);
		}
	}
	
	// 只能打印一种类型 
	public static void printCollection3(ArrayList<Person> al){
		Iterator<Person> it=al.iterator();
		while(it.hasNext()){
			Person p=it.next();
			System.out.println(p.getName());
		}
	}
	
	//泛型限定:   只想打印  Person 和 Person 的子类  
	//  ?  extends Person  :表示   Person 和  他的子类  
	public static void printCollection4(ArrayList<? extends Person> al){
		Iterator<? extends Person> it=al.iterator();
		while(it.hasNext()){
			Person p=it.next();
			System.out.println(p.getName());
		}
	}
	
	
}

泛型限定:下限

package com.itheima.day15.p5;

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

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

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

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

class StuComparator implements Comparator<Student>{
	public int compare(Student t1,Student t2){
		return t1.getName().compareTo(t2.getName());
	}
}

class WorComparator implements Comparator<Worker>{
	@Override
	public int compare(Worker o1, Worker o2) {
		// TODO Auto-generated method stub
		return o1.getName().compareTo(o2.getName());
	}
}

//使用 泛型限定: 下限后  就可以这样解决问题了
class PerComparator implements Comparator<Person>{
	@Override
	public int compare(Person o1, Person o2) {
		// TODO Auto-generated method stub
		return o1.getName().compareTo(o2.getName());
	}
}


public class GenericeDemo7 {
	public static void main(String[] args) {
		method();
	}
	
	public static void method(){
		

		TreeSet<Student> ts=new TreeSet<Student>(/*new StuComparator()*/ new PerComparator());
		ts.add(new Student("admin1"));
		ts.add(new Student("admin2"));
		ts.add(new Student("admin3"));
		Iterator<Student> it=ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
		
		TreeSet<Worker> ts1=new TreeSet<Worker>(/*new WorComparator()*/ new PerComparator());
		ts1.add(new Worker("wwwwadmin1"));
		ts1.add(new Worker("wwwwadmin2"));
		ts1.add(new Worker("wwwwadmin3"));
		Iterator<Worker> it1=ts1.iterator();
		while(it1.hasNext()){
			System.out.println(it1.next().getName());
		}
		
	}

}