泛型:是JDK5中引入的新特性,可以在编译阶段约束操作的数据类型,并进行检查。
泛型的格式:<数据类型>
注意:泛型只能支持引用的数据类型
import java.util.ArrayList;
import java.util.Iterator;
public class a01genercisdemo01 {
public static void main(String[] args) {
//没有泛型的时候如何存储数据
//结论:
//如果我们没有给集合指定类型,默认认为所有的数据类型都是Object类型
//此时可以往集合中添加各种数据
//带来一个坏处:我们在获取数据的时候,无法使用它特有的行为
//此时我们推出了泛型,可以在添加数据的时候把类型进行统一
//而且我们在获取数据的时候也省的强转,非常的方便
//1.创建集合的对象
ArrayList list=new ArrayList();
//2.添加数据
list.add("aaa");
list.add(123);
list.add(new Student("karry",24));
//3.遍历集合
Iterator it = list.iterator();
while(it.hasNext()){
Object next = it.next();
System.out.println(next);
}
}
}
泛型的好处:
统一数据类型
把运行事情时期的问题提前到了编译期间,避免了强制类型转换可能出现的异常,因为在编译阶段类型就能确定下来。
泛型类
当一个类中,某个变量的数据类型不确定时,就可以定义带有泛型的类。
package mygenercis;
import java.util.Arrays;
public class MyArrayList <E>{
Object[] obj=new Object[10];
int size;
public boolean add(E e){
obj[size]=e;
size++;
return true;
}
public E get(int index){
return (E)obj[index];
}
@Override
public String toString() {
return Arrays.toString(obj) ;
}
}
package mygenercis;
public class genercisdemo02 {
public static void main(String[] args) {
MyArrayList<String> list=new MyArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
System.out.println(list);
}
}
泛型方法
方法中形参类型不确定时,可以使用类名后面定义的泛型。
package mygenercis;
import java.util.ArrayList;
public class ListUtil {
private ListUtil(){}
public static<E> void addAll(ArrayList<E> list,E e1,E e2,E e3,E e4){
list.add(e1);
list.add(e2);
list.add(e3);
list.add(e4);
}
}
package mygenercis;
import java.util.ArrayList;
public class genercisDemo03 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>() ;
ListUtil.addAll(list,"aaa","bbb","ccc","ddd");
System.out.println(list);
}
}
泛型接口
package mygenercis;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class MyArrayList2 implements List<String> {
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean contains(Object o) {
return false;
}
@Override
public Iterator<String> iterator() {
return null;
}
@Override
public Object[] toArray() {
return new Object[0];
}
@Override
public <T> T[] toArray(T[] a) {
return null;
}
@Override
public boolean add(String s) {
return false;
}
@Override
public boolean remove(Object o) {
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
return false;
}
@Override
public boolean addAll(Collection<? extends String> c) {
return false;
}
@Override
public boolean addAll(int index, Collection<? extends String> c) {
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
return false;
}
@Override
public boolean retainAll(Collection<?> c) {
return false;
}
@Override
public void clear() {
}
@Override
public String get(int index) {
return null;
}
@Override
public String set(int index, String element) {
return null;
}
@Override
public void add(int index, String element) {
}
@Override
public String remove(int index) {
return null;
}
@Override
public int indexOf(Object o) {
return 0;
}
@Override
public int lastIndexOf(Object o) {
return 0;
}
@Override
public ListIterator<String> listIterator() {
return null;
}
@Override
public ListIterator<String> listIterator(int index) {
return null;
}
@Override
public List<String> subList(int fromIndex, int toIndex) {
return null;
}
}
package mygenercis;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class MyArrayList3<E> implements List<E> {
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean contains(Object o) {
return false;
}
@Override
public Iterator<E> iterator() {
return null;
}
@Override
public Object[] toArray() {
return new Object[0];
}
@Override
public <T> T[] toArray(T[] a) {
return null;
}
@Override
public boolean add(E e) {
return false;
}
@Override
public boolean remove(Object o) {
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
return false;
}
@Override
public boolean addAll(Collection<? extends E> c) {
return false;
}
@Override
public boolean addAll(int index, Collection<? extends E> c) {
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
return false;
}
@Override
public boolean retainAll(Collection<?> c) {
return false;
}
@Override
public void clear() {
}
@Override
public E get(int index) {
return null;
}
@Override
public E set(int index, E element) {
return null;
}
@Override
public void add(int index, E element) {
}
@Override
public E remove(int index) {
return null;
}
@Override
public int indexOf(Object o) {
return 0;
}
@Override
public int lastIndexOf(Object o) {
return 0;
}
@Override
public ListIterator<E> listIterator() {
return null;
}
@Override
public ListIterator<E> listIterator(int index) {
return null;
}
@Override
public List<E> subList(int fromIndex, int toIndex) {
return null;
}
}
package mygenercis;
public class genercisDemo04 {
public static void main(String[] args) {
MyArrayList2 list=new MyArrayList2();
list.add("aaa");
MyArrayList3<String> list3=new MyArrayList3<>();
list3.add("aaa");
}
}
泛型的继承和通配符
泛型不具备继承性,但是数据具备继承性。
通配符:
?表示不确定的类型,它可以进行类型的限定
?entends E:表示可以传递E或者E所有的子类类型、
?super E:表示可以传递E或者E所有的父类类型
应用场景:
1.如果我们在定义类、方法、接口的时候,如果类型不确定,就可以定义泛型类、泛型方法、泛型接口。
2.如果类型不确定,但是知道以后只能传递某个继承体系中的,就可以使用泛型的通配符。
package mygenercis;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
@Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package mygenercis;
public abstract class Dog extends Animal{
}
package mygenercis;
public class LiHuaCat extends cat{
@Override
public void eat() {
System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的狸花猫,正在吃鱼");
}
}
package mygenercis;
public class PersianCat extends cat{
@Override
public void eat() {
System.out.println("一只叫做"+getName()+"的,"+getAge()+"岁的波斯猫,正在吃小饼干");
}
}
package mygenercis;
public abstract class Dog extends Animal{
}
package mygenercis;
public class TeddyDog extends Dog{
@Override
public void eat() {
System.out.println("一只叫"+getName()+"的,"+getAge()+"岁的泰迪,正在吃骨头,边吃边蹭");
}
}
package mygenercis;
import java.util.ArrayList;
public class HuskyDog extends Dog{
@Override
public void eat() {
System.out.println("一只叫"+getName()+"的,"+getAge()+"岁的哈士奇,正在吃骨头,边吃边拆家");
}
public static void keepPet(ArrayList<? extends cat> list){
}
public static void keepPet2(ArrayList<? extends Dog> list){
}
public static void keepPet3(ArrayList<? extends Animal> list){
}
}