java基础<泛型>

时间：2021-08-09 19:39:39

泛型概述

一、概述 泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个安全机制。
二、好处 1.将运行时期出现的问题ClassCastException，转移到了编译时期。 方便与程序员解决问题。让运行时问题减少，更加安全。
2.避免了强制转换的麻烦。
三、代码 
class GenericDemo 
{
public static void main(String[] args) 
{
ArrayList<String> a1=new ArrayList<String>();
a1.add("abc01");
a1.add("abc0991");
a1.add("abc");

Iterator<String> it=al.iterator();
while(it.hasNext())
{
String s=it.next();
}
}
}

泛型类

一、概述泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上，如下一节所示。
二、代码 
class Worker
{

}

class Utils<QQ>
{
private QQ q;
public void set(QQ q)
{
this.q=q;
}
public QQ get()
{
return q;
}
}


class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u=new Utils<Worker>();
u.set(new Worker());
Worker w=u.get();
}
}

泛型方法

一、代码（泛型方法）泛型定义在方法上时放在—— 修饰符的后面，返回值类型的前面泛型方法的使用之前，需要在方法上定义，否则不可以使用。
class Demo
{
public <T> void show(T t)
{
System.out.println(t);
}

public <Q> void print(Q q)
{
System.out.println(q);
}
}


class  GenericDemo4
{
public static void main(String[] args) 
{
Demo d=new Demo();
d.show("haha");
d.show(1);
d.print("hehe");
}
}
二、代码（泛型类中的泛型方法）
class Demo<T>
{
public void show(T t)
{
System.out.println(t);
}

public <Q> void print(Q q)
{
System.out.println(q);
}
}


class  GenericDemo4
{
public static void main(String[] args) 
{
Demo d=new Demo();
d.show("haha");
d.show("hehe");
d.print(1);
}
}

三、代码（泛型类中的静态方法泛型）
class Demo<T>
{
public void show(T t)
{
System.out.println(t);
}

public <Q> void print(Q q)
{
System.out.println(q);
}

public static<W> void method(W w)//静态方法不可以访问类上定义的泛型。只可以在方法上定义泛型。
{
System.out.println("method"+t);
}
}


class  GenericDemo4
{
public static void main(String[] args) 
{
Demo d=new Demo();
d.show("haha");
d.show("hehe");
d.print(1);
Demo.method("hahahah");
}
}

泛型接口

一、代码
interface Inter<T>
{
void show(T t);
}

/*
class InterImpl implements Inter<String>
{
public void show(String t)
{
System.out.println("show:"+t);
}
}
*/

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




class  
{
public static void main(String[] args) 
{
InterImpl<Integer> i=new InterImpl<Integer>();
i.show(1);
}
}

泛型限定

一、通配符（?)
import java.util.*;

class  GenericDemo6
{
public static void main(String[] args) 
{
ArrayList<String> a1=new ArrayList<String>();

a1.add("abc1");
a1.add("abc2");
a1.add("abc3");

ArrayList<Integer> a2=new ArrayList<Integer>();
a2.add(4);
a2.add(5);
a2.add(6);

printColl(a1);
printColl(a2);

printColl1(a1);
printColl1(a2);
}

/*以下两种方法都可以*/
/*①*/public static void printColl(ArrayList<?> al)//ArrayLise<String> a1=new ArrayList<Integer>();是错误的，类型不匹配。
{
Iterator<?> it=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
//System.out.println(it.next().length());//不可以使用，因为不是每个对象都有length()方法。
System.out.println(it.next().toString());//可以使用，因为每个对象都有这个方法。
}
}



/*②*/public static<T> void printColl1(ArrayList<T> al)
{
Iterator<T> it=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}

}
二、泛型限定

1. ？ extends E  限定类型是E或者E的子类。（上限）
import java.util.*;
class GenericDemo7 
{
public static void main(String[] args) 
{
ArrayList<Person> a1=new ArrayList<Person>();
a1.add(new Person("abc"));
a1.add(new Person("abc1"));
a1.add(new Person("abc2"));
printColl(a1);

ArrayList<Student> a2=new ArrayList<Student>();
a2.add(new Student("abc___"));
a2.add(new Student("abc___1"));
a2.add(new Student("abc___2"));
printColl(a2);//ArrayList<Person> a1=new ArrayList<Student>();不可以，必须是相同类型

}


public static void printColl(ArrayList<? extends Person> p)
{
Iterator<? extends Person> it=p.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}

}
}

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


class Student extends Person
{
Student(String name)
{
super(name);
}
}
2. ？ super E     限定类型是E或者E的父类。（下限）
import java.util.*;

class GenericDemo8 
{
public static void main(String[] args) 
{
TreeSet<Student> ts=new TreeSet<Student>(new Com());//根据TreeSet构造方法，可以使用Student的父类的比较器来对Student进行比较。

ts.add(new Student("zhangsan3"));
ts.add(new Student("zhangsan2"));
ts.add(new Student("zhangsan1"));

Iterator<Student> it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}


class Com implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}

}


class Comp implements Comparator<Student>
{
public int compare(Student p1,Student p2)
{
return p1.getName().compareTo(p2.getName());
}

}

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


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

相关文章