泛型
@SuppressWarnings({"all"})
public static void main(String[] args) {
ArrayList<Dog> arrayList = new ArrayList<Dog>();
arrayList.add(new Dog("hj", 7));
arrayList.add(new Dog("hyf", 8));
//1.当我们ArrayL ist<Dog> 表示存放到ArrayList 集合中的元素是Dog类型
//2.如果编译器发现添加的类型，不满足要求，就会报错
//3. 在遍历的时候，可以直接取出Dog类型而不是0bject
//4. public cLass ArrayList<E> {}日你为泛型，那么Dog->E
for (Dog dog : arrayList) {
System.out.println(dog.getAge() + dog.getName());
}
}
泛型应用实例，使用细节
package Arraylist;
import java.util.ArrayList;
public class NN {
public static void main(String[] args) {
//特别强调：E表示s的数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型!!!
//这里E是一种表示数据类型的数据类型
Dog<Integer> integerDog = new Dog<Integer>(65);
/*
class Dog<Integer> {
Integer s;//Integer表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定Integer是什么类型
public Dog(Integer s) {//Integer也可以是参数类型
this.s = s;
}
public Integer f(){//返回类型使用Integer
return s;
}
}
*/
//在给泛型指定具体类型后，可以传入该类型或者其子类类型
Dog<A> aDog = new Dog<A>(new A());//因为E指定了A类型，构造器传入了new A()
Dog<A> aDog1 = new Dog<A>(new B());//B继承了A，这里才对 因为前面E指定的是A类型
//泛型的使用形式
ArrayList<Integer> list1 = new ArrayList<Integer>();
ArrayList<Integer> list2 = new ArrayList<Integer>();
//往往简写 默认泛型是object 只是看不到而已
ArrayList objects = new ArrayList();
ArrayList<Object> objects1 = new ArrayList<>();//等价于ArrayList<Object> objects1 = new ArrayList<>();
}
}
class A { }
class B extends A { }
//泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，
//或者是某个方法的返回值的类型，或者是参数类型
class Dog<E> {
//这里E是一种表示数据类型的数据类型
E s;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型!!!!!
public Dog(E s) {//E也可以是参数类型
this.s = s;
}
public E f() {//返回类型使用E
return s;
}
}
public static void main(String[] args) {
//定义HashSet
HashSet<Student> set = new HashSet<Student>();
set.add(new Student("hj", 5));
set.add(new Student("yf", 23));
set.add(new Student("yf", 23));
//迭代器
Iterator<Student> iterator = set.iterator();
while (iterator.hasNext()) {
Student student = iterator.next();
System.out.println(student);
}
//增强for set集合里面取出来的就是Student 没有报错是因为上面HashSet<Student>()这里给他指定了具体类型就是Student
for (Student student : set) {
System.out.println(student);
}
//定义HashMap
//所有的k->String v->创建的学生对象
HashMap<String, Student> hashMap = new HashMap<String, Student>();
hashMap.put("yuhu-", new Student("yuhu", 123));
Set<String> strings = hashMap.keySet();
//增强for
for (Object key : hashMap.keySet()) {
System.out.println(key);
}
//迭代器
while (iterator.hasNext()) {
Student key = iterator.next();
System.out.println(key);
}
//entrySet
//这里一直都是<String, Student>是因为在上面定义HashMap的时候已经把k,v指定了
Set<java.util.Map.Entry<String, Student>> entries = hashMap.entrySet();////所有的k->String v->创建的学生对象
Iterator<java.util.Map.Entry<String, Student>> iterator1 = entries.iterator();
while (iterator1.hasNext()) {
System.out.println("==============================");
java.util.Map.Entry<String, Student> next = iterator1.next();//iterator1.next()取出来的就是Iterator<java.util.Map.Entry<String, Student>>
System.out.println(next.getKey() + next.getValue());
}
}
练习题
public class kkkk {
@SuppressWarnings({"all"})
public static void main(String[] args) {
ArrayList<EE> ee = new ArrayList<EE>();//定义泛型
//创建对象
ee.add(new EE("jhbjkh",13,new MyDate(1234,24,4)));
ee.add(new EE("jhb",13,new MyDate(12,24,4)));
ee.add(new EE("jhb",13,new MyDate(123,24,4)));
System.out.println(ee);
//进行排序
ee.sort(new Comparator<EE>() {
@Override
public int compare(EE o1, EE o2) {
//先按照name排序 name相同 则按生日排序
//先对传入的参数进行验证
if(!(o1 instanceof EE && o2 instanceof EE)){
System.out.println("类型不正确");
return 0;
}
//比较name
int i = o1.getName().compareTo(o2.getName());
if(i != 0){
return i;
}
//下面是对birthday的比较 放在MyDate类里面完成 封装
return o1.getBirthday().compareTo(o2.getBirthday());
}
});
System.out.println("==================排序后==================");
System.out.println(ee);
}
}
MyDate类
@Override
public int compareTo(MyDate o) {//将birthday的比较封装在这
//如果name相同 比较year
int yearMinus = year - o.getYear();
if(yearMinus != 0){
return yearMinus;
}
//如果year相同 比较month
int monthMinus = month - o.getMonth();
if(monthMinus != 0){
return monthMinus;
}
//都相同 比较day
return day - o.getDay();
}
//1. Tiger 后面泛型， 所以我们把Tiger就称为自定义泛型类 //2, T, R，M泛型的标识符，一般是单个大写字母 //3.泛型标识符可以有多个。 //4. 普通成员可以使用泛型(属性、方法) //5.使用泛型的数组，不能初始化 //6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
String name;
R r;//属性使用到泛型
M m;
T t;
public Tiger(String name, R r, M m, T t) {//构造器使用泛型
this.name = name;
this.r = r;
this.m = m;
this.t = t;
}
//方法使用泛型...
1.接口中，静态成员也不能使用泛型 2.泛型接[ 7的类型， 在继承接[ 7或者实现接[ 7时确定
//在继承接口 指定泛型接口的类型
interface IA extends aa<String, Double>{
}
//当我们去实现IA接口时，因为IA在继承IUsu接口时，指定了U为String R为DoubLe
//，在实现IUsu接口的方法时，使用String替换U，是Double替换R
class AA implements IA{
@Override
public Double get(String s) {
return null;
}
@Override
public void hi(Double aDouble) {
}
@Override
public void run(Double r1, Double r2, String u1, String u2) {
}
}
//实现接口时，直接指定泛型接口的类型
//给U指定Integer 给R指定了FLoat
//所以，当我们实现IUsb方法时， 会使用Integer替换U，使用FLoat替换R
class BB implements aa<Integer , Float>{
@Override
public Float get(Integer integer) {
return null;
}
@Override
public void hi(Float aFloat) {
}
@Override
public void run(Float r1, Float r2, Integer u1, Integer u2) {
}
}
interface aa<U,R>{
//普通方法中可 以使用泛型接口
R get(U u);
void hi(R r);
void run(R r1,R r2,U u1,U u2);
//在jdk8中，可以在接口中，使用默认方法，也是可以使用泛型
default R method(U u){
return null;
}
}
自定义泛型方法
就到这了，心累。
