java泛型

package com.qianfeng.test;

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

/*

• 泛型：通过<数据类型>接收一种数据类型，
• 在编译的时候会使用这种类型检测集合中的元素，
• 如果不是<>中规定的类型，就不允许添加到集合当中（编译不通过）。
• 作用：1.使用了泛型不再需要进行强制类型转换，容错处理，向下转型。----简化代码
• 2.将运行阶段的问题提前到了编译阶段检查，提高了代码的整体安全性和编程效率。
• 泛型的擦除：泛型只是在编译阶段检查元素的类型，一到运行阶段，泛型就消失了。
• 泛型的使用场景：
• 1.类上 2.接口上 3.方法上

*/
public class Demo2 {

public static void main(String[] args) {
	
	//当list指定了具体的String泛型之后，里面的元素只能是String
	ArrayList<String> list = new ArrayList<>();
	list.add("java1");
	list.add("java2");
	list.add("java5");
	list.add("java7");
	//list.add(3);
	System.out.println(list);
	
	//获取迭代器
	//当集合的泛型确定之后，让迭代器的泛型与之一直即可。
	Iterator<String> iterator = list.iterator();
	
	//使用泛型前
	//遍历

// while (iterator.hasNext()) {
// Object object = (Object) iterator.next();
//
// //容错处理
// if(!(object instanceof String)){
// throw new ClassCastException(“数据类型转换异常”);
// }
//
// //向下转型
// String string = (String)object;
//
// System.out.println(string.length());
// }

	//使用泛型后
	while (iterator.hasNext()) {
		String string = (String) iterator.next();
		System.out.println(string);
	}
	
}

}

---

package com.qianfeng.test;
/*
*泛型在类上的使用
*/
public class Demo3 {

public static void main(String[] args) {
	
	Student student = new Student();
	Computer computer = new Computer("苹果");
	Phone phone = new Phone("苹果");

// //使用泛型前
// //将工具交给学生
// student.setObj(computer);//多态
// //获取工具
// Object object = student.getObj();
// //向下转型
// Computer computer2 = (Computer)object;//computer2=object=new Computer(“苹果”)
// Phone phone2 = (Phone)object;//phone2=object=new Computer(“苹果”)

	//使用泛型后
	//这里通过使用泛型：保证了Student1类的使用灵活性而且可以简化代码，提高代码效率。
	Student1<Computer> student1 = new Student1<>();
	student1.setObj(computer);
	
	Computer computer3 = student1.getObj();
	
}

}

//使用泛型前
class Student{
private Object obj;

public Object getObj() {
	return obj;
}

public void setObj(Object obj) {
	this.obj = obj;
}

}

//使用泛型后
/*
E代表任意一种数据类型，但是<>不一定是E，可以是任意字符。
*在类的后面加<>就是在给类使用泛型。
*在类上确定的泛型可以在成员上直接使用
*/
class Student1{
private E obj;

public E getObj() {
	return obj;
}

public void setObj(E obj) {
	this.obj = obj;
}

}

class Tool{
String name;

public Tool() {
}

public Tool(String name) {
	super();
	this.name = name;
}

}

class Phone extends Tool{

public Phone(String name) {
	super(name);
}

}

class Computer extends Tool{

public Computer(String name) {
	super(name);
}

}

---

package com.qianfeng.test;

import java.util.ArrayList;

/*
*泛型在方法上的使用
*/
public class Demo4 {

public static void main(String[] args) {
	
	Teacher<String> teacher = new Teacher<>();
	
	//1.方法上的泛型与类上的泛型一致
	teacher.play("hah");
	//2.方法上独立使用泛型
	teacher.show(2);
	//3.静态方法上使用泛型
	Teacher.run(5);
}

}

class Teacher{

//1.方法上的泛型与类上的泛型一致
public E play(E e){
	return e;
}

//2.方法上独立使用泛型
/*
 * 泛型在使用之前一定要先声明
 * 声明的方式：在方法的最前面加<符号>
 * 作用：让方法内与方法的泛型保持一致
 */
public <F> void show(F f){
	ArrayList<F> list = null;
}

//3.静态方法上使用泛型
/*
 * 静态方法上无法使用类的泛型，类上的泛型必须通过创建对象才能使用。
 * 静态方法的调用不需要对象，所以静态方法如果想使用泛型，必须自己单独使用。
 */
public static<W> void run(W w){
	
}

}

---

package com.qianfeng.test;
/*
*接口上使用泛型
*/
public class Demo5 {

public static void main(String[] args) {
	
	Dog dog = new Dog();//Dog没有泛型，所以此处指定不了，所以必须在Dog类定义时给接口指定一个具体的泛型类型。
	dog.play("hah");
	
	Cat<String> cat = new Cat<String>();
	cat.play("hh");
}

}

//接口上使用泛型
interface Inter{

public void play(E e);

}

//子类使用泛型的情况
/*
*第一种：接口有泛型，子类没有遵守对应的泛型
注意：必须给接口指定一个具体的泛型类型
*/
class Dog implements Inter{

//重写的方法的泛型与接口一致
public void play(String e) {
	
}

//自定义的方法可以使用接口的泛型，也可以自定义泛型
public <F> void show(F f){
	
}

}

/*
*第二种：接口有泛型，子类与与接口一致，子类遵守了对应的泛型
*类上的泛型确定了，接口上的泛型就确定了，重写方法上的泛型也确定了。
*/
class Cat implements Inter{

public void play(E e) {
	
}

}

---

package com.qianfeng.test;

import java.util.ArrayList;
import java.util.Collection;

/*
?:通配符,表示一种或几种数据类型
限制上限:<? extends E>:限制的是整个<>中可以取的泛型类型是E类及E类的子类
*限制下限:<? super E>:限制的是整个<>中可以取的泛型类型是E类及E类的父类
*
*注意点:在取类型的时候,类型之间一定有继承关系.
*
这里讲的是限制上限:<? extends E>
*/
public class Demo6 {

public static void main(String[] args) {
	//
	ArrayList<Student2> list1 = new ArrayList<>();
	list1.add(new Student2("bingbing", 1));
	//可以传参:因为Student2是Person1的子类,可以实现遍历
	bianli(list1);
	
	ArrayList<Teacher8> list2 = new ArrayList<>();
	list2.add(new Teacher8("bingbing", 1));
	//可以传参:因为Teacher1是Person1的子类,可以实现遍历
	bianli(list2);
	
	ArrayList<Person1> list3 = new ArrayList<>();
	list3.add(new Person1("bingbing", 1));
	//可以传参
	bianli(list3);
	
	ArrayList<Object> list4 = new ArrayList<>();
	list4.add(new Object());
	//可以传参:因为Object是Person1的父类,不可以实现遍历
	//bianli(list4);
}


public static void bianli(Collection<? extends Person1>  e){
	System.out.println("遍历了");
}

}

class Person1{

String name;
int age;
public Person1() {
	super();
}
public Person1(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
public String toString() {
	return "Person1 [name=" + name + ", age=" + age + "]";
}

}

class Teacher8 extends Person1{

public  Teacher8(String name, int age) {
	super(name, age);
}

}

class Student2 extends Person1{

public  Student2(String name, int age) {
	super(name, age);
}

}

---

package com.qianfeng.test;

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

public class Demo7 {

public static void main(String[] args) {
	
	//限制下限 <? super E>
	//TreeSet(Comparator<? super E> comparator) :这里的E跟TreeSet后面的泛型类型一致,所以现在E应该表示的Student3
	
	//创建Student3类的比较器对象
	ComWithStu comWithStu = new ComWithStu();
	//创建Teacher1类的比较器对象
	ComWithTea comWithTea = new ComWithTea();
	//创建Person1类的比较器对象
	ComWithPerson comWithPerson = new ComWithPerson();
	//创建GoodStudent类的比较器对象
	ComWithGood comWithGood = new ComWithGood();
	
	TreeSet<Student3> set = new TreeSet<>(comWithStu);//因为这里限制的是Student3及他的父类
	//TreeSet<Student3> set = new TreeSet<>(comWithTea);//不可以使用,因为Teacher2类与Student3类没有关系
	//TreeSet<Student3> set = new TreeSet<>(comWithPerson);//可以  ,因为Person2类是Student3类的父类
	//TreeSet<Student3> set = new TreeSet<>(comWithGood);//不可以,因为GoodStudent类是Student3类的子类
	set.add(new Student3("bingbing"));
	set.add(new Student3("bingbing1"));
	set.add(new Student3("bingbing2"));
}

}
//创建Student3类的比较器
class ComWithStu implements Comparator{

public int compare(Student3 o1, Student3 o2) {
	
	return o1.name.compareTo(o2.name);
}

}
//创建Teacher2类的比较器
class ComWithTea implements Comparator{

public int compare(Teacher2 o1, Teacher2 o2) {
	
	return 0;
}

}
//创建Person2类的比较器
class ComWithPerson implements Comparator{

public int compare(Person2 o1, Person2 o2) {
    return 0;
}

}

//创建GoodStudent类的比较器
class ComWithGood implements Comparator{

public int compare(GoodStudent o1, GoodStudent o2) {
	return 0;
}

}

class Person2{

 String name;

public Person2(String name) {
	super();
	this.name = name;
}

public String toString() {
	return "Person2 [name=" + name + "]";
}

}

class Teacher2 extends Person2{

public Teacher2(String name) {
	super(name);
}

}
class Student3 extends Person2{

public Student3(String name) {
	super(name);
}

}

class GoodStudent extends Student3{

public GoodStudent(String name) {
	super(name);
}

}

---