泛型
1.新特性
1.1. 可变参数
JDK1.5之后追加可变参数的概念 定义方法
public [static] [final] 返回值 方法名称（[参数类型...参数名称] []）
范例：方法的可变参数
package Test.zyj.com;
/**
* @Name：
* @Author：ZYJ
* @Date：2019-05-31-17:24
* @Description:
*/
public class TestDemo {
public static void main(String[] args) {
System.out.println(add(1,2,3,4));
int[] a = new int[]{1,2,3};
System.out.println(add(a));
}
public static int add(int...data){
int result=0;
for(int i=0;i<data.length;i++){
result+=data[i];
}
return result;
}
}
//打印结果
// 10
//6
1.将可变参数变成一个数组，通过数组访问可变参数。
2.int[] value 与 int… values 不是重载关系，等价关系。
3.可变参数必须定义在参数列表的最后的一个位置。一个方法中最多有一个可变参数。
public static int add(String msg,)
4.main方法中不建议写可变参数
1.2 静态导入(实际开发过程中很少使用)
静态属性 通过类名来访问
1.静态导入类的静态方法；
2.静态导入类的静态属性；
3.静态批量导入 ：通过类名.*;
4.采用静态导入时，如果类中存在使用的类的静态属性和方法，优先使用类中自己的（就近原则）;
5.集成开发工具关于类的导入比较智能，通常开发中不需要额外处理导入；
import static www.
class Test{
public static void main(String[] args){
}
}
calss MyMath{
public static int add(int a,int b){
return a+b;
}
public static int sub(int a,int b){
return a-b;
}
}
2.泛型(JDK1.5之后)
2.1 基本定义
泛型是一种未知的数据类型。我们不知道使用什么数据类型的时候可以使用泛型。所以泛型可以看做是一个变量用来接收数据类型。
2.2 集合类中使用泛型
ArrayList集合在定义的时候，不知道集合中都会储存什么类型的数据，所以类型使用泛型。
public class ArrayList<E>{
public boolean add(E e){}
public E get(int index){}
}
在创建集合对象时会确定泛型的数据类型，把数据类型作为参数传递，把String 赋值给泛型E
ArrayList<String> list = new ArrayList<String>();//创建对象，并确定泛型为String
public class ArrayList<String>{
public boolean add(String e){}
public String get(int index){}
}
ArrayList<Student> list = new ArrayList<Student>();
//此时E为Student类
2.2.1创建集合类不使用泛型
好处：集合不适用泛型，默认类型为Object类型，可以储存任意数据类型的数据。
package Test.zyj.com;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @Name： 集合中不使用泛型和使用泛型
* @Author：ZYJ
* @Date：2019-06-01-14:47
* @Description:
*/
public class Demo01Test {
public static void main(String[] args) {
showo1();
show2();
}
/**
* 集合类使用泛型
*/
private static void showo1(){
ArrayList list = new ArrayList();
list.add("abc");
list.add(11);
//使用迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()){
Object object = it.next();
//向下转型 强制转换
String s = (String) object;
System.out.println(s.length());
}
}
/**
* 集合类使用泛型
*/
private static void show2(){
ArrayList<String> list = new ArrayList<>();
list.add("abc");
list.add("ddd");
Iterator it2 = list.iterator();
while (it2.hasNext()){
Object o =it2.next();
String ss = (String) o;
System.out.println(ss.length());
}
System.out.println();
}
}
若此时想要使用String类特有的方法length（），获取字符串的长度；不能直接使用，多态不能使用子类特有的方法。需要向下转型
Object object ="abc";
String s = (String) obj;
System.out.println(s.length());
此时程序报错 ClassCastException:类型转换异常，不能吧Integer类型转换为为String
创建集合对象使用泛型的好处：
1.避免类型转换的麻烦
1.把运行期异常提升到编译期
private static void show2(){
ArrayList<String> list = new ArrayList<>();
list.add("abc");
list.add(1);//此处在编译器产生异常
}
2.3 泛型类的定义
//基本语法
class Myclass<T>{
T value1;
}
<>中的T被称为：类型参数，用于指代任何类型，实际上这个T可以任意写。
- T ：代表一般的任何类
- E ：代表Element的意思，或者Exception异常的意思
- K ：代表Key的意思
- V ：代表Value的意思，通常与K一个配合使用
- S ：代表Subtype的意思。
范例 ：定义一个泛型类
MyClass<String> myClass1 = new MyClass<String>();
MyClass<Integer> myClass2 = new MyClass<Integer>();
注意：泛型只能接受类，所有的基本数据类型必须使用包装类，即<>中的内容必须为一个类。
2.3.1 泛型可以接收多个类型参数
多个类型参数之间用“，”隔开
Class MyClass<T,E>{
T value1;
E value2;
}
public class Test{
public static void mainI(String[] args){
MyClass<String,Integer> myclass = new MyClass<String,Integer>();
}
}
范例：使用泛型定义一个类
package Test.zyj.com;
/**
* @Name： 使用泛型定义一个类
* @Author：ZYJ
* @Date：2019-06-01-15:12
* @Description:
*/
/**
* 定义Point类 使用泛型
* @param <T>
*/
class Point<T>{
private T x;
private T y;
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
}
public class FunTypeDemo {
public static void main(String[] args) {
//创建对象时指定泛型类型，将类型作为参数传入
Point<String> p = new Point<String>();
p.setX("东京下雨");
p.setY("淋湿巴黎");
//取出数据
String x = p.getX();//避免向下转型
String y = p.getY();
System.out.println(x+y+"....");
}
}
总结：
因为使用泛型之后，在创建类的对象的时候指定了类型，所以在接收这个对象的时候我们已经知道使用了哪一种类型，避免了向下转型。泛型的出现彻底改变了向下转型的需求。引入泛型之后，如果明确设置了类型，则为设置类型。如果没有设置类型，则默认为Object类型。
2.4 泛型方法的定义
泛型定义在方法的修饰符和返回值类型之间：
格式
修饰符 <泛型> 返回值类型 方法名（使用泛型 参数）{
方法体
}
class MyClass{
public <T> void testMexthod(T t){
System.out.println(t);
}
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。
2.4.1.泛型方法是独立定义，可以单独定义泛型方法，和类没有直接关系
泛型方法始终以自己的类型为准
class MyClass{
public <T>（T为类型参数） void test（T t）{//方法中T为参数化类型，不是真正运行时的参数
//T:参数化类型 不是真正类型 具体调用那个类型就是那个类型
return t;
}
}
public static void main(String[] args){
Point3 point3 = new Point3();
//调用方法时传入什么类型 就是什么类型
point3.print("helllo ！");//T=>String
point3.print(22);//T=>int
}
####2.4.2.泛型方法的类型参数是写在方法返回值类型前面定义。<T,…>
public <T>（类型参数类型） T(返回值类型 类型参数的类型) getInfo(T v){
return v;
}
public <T,V> E getInfo(T t ,E e){
return e;
}
2.4.3 泛型类与泛型方法共存
package Test.zyj.com;
/**
* @Name：泛型类与泛型方法同时存在
* @Author：ZYJ
* @Date：2019-06-01-15:52
* @Description:
*/
public class FCaFF {
public static void main(String[] args) {
MyClass01<String> myClass01 = new MyClass01<>();//传入String类
myClass01.testMethod("只能是String类型");
//调用泛型方法 ，传入整形数据类型
Integer i = myClass01.testMethod2(100);
System.out.println(i);
//调用泛型方法，传入字符串类型数据
String s = myClass01.testMethod2("sdasd");
System.out.println(s);
}
}
/**
* 定义泛型类 实例化对象传入什么类型就是什么类型
* @param <T>
*/
class MyClass01<T>{
/**
* 定义泛型方法
* 在调用方法的时候确定泛型的数据类型，传递什么参数，泛型就是什么类型
* @param t
*/
public <T> T testMethod2(T t){
return t;
}
/**
* 普通方法
* @param t
*/
public void testMethod(T t){
System.out.println(t);
}
}
泛型方法之间没关系，泛型方法和泛型类也没有关系
总结：泛型方法与泛型类稍有不同，类型参数也就是 < >写在返回值之前。中的T称为：类型参数，而方法中的T 也被称为参数化类型，它不是运行时真正的参数。
2.5 泛型与静态方法
定义一个含有泛型的静态方法
public static<S> void method(S s){
System.out.println(s);
}
通过类名.方法名（参数）可以直接使用，也可以传递任意类型好的参数
2.4 通配符
泛型会产生新的问题：参数统一问题
public class Test{
public static void main(String[] args){
Message<>
}
}
2.4.1. 用？表示任意数据类型，
使用方法：不能创建对象使用，只能作为方法的参数使用。集合类在定义时不能写通配符。
用在形参
package Test.zyj;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @Name：集合类泛型和
* @Author：ZYJ
* @Date：2019-06-01-16:14
* @Description:
*/
public class Test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
ArrayList<String> list1= new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
printArray(list);
printArray(list1);
}
//遍历集合，但集合中数据类型不唯一，这是不确定写哪一种数据类型 所有写？ 写其他的数据类型会报错
public static void printArray(ArrayList<?> list){
Iterator<?> it = list.iterator();//
while (it.hasNext()){
System.out.print(it.next());
}
}
}
2.4.2.泛型上限及下限
？ extends 类 ：设置泛型上限：
应用在类、方法（声明） 只有上限通配符可以用在泛型类与泛型方法的使用上
应用到方法中仍然不能修改
？必须为 类的本类或 子类
？ super 类 ：设置泛型下限： 只有下限通配符用在方法形参时，可以修改形参对象内容（天然的向上转型）
只能应用到方法参数中
应用到的方法中是可以修改的，但是主要修改类型为、
？必须为本类或父类
三者皆可用在形参上
package Demo.zyj;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* @Name：
* @Author：ZYJ
* @Date：2019-06-01-16:38
* @Description:
*/
public class TestDemo {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
list1.add(1);
list2.add("abs");
list3.add(34);
list4.add("sdas");
list4.add(1212);
/**
* 泛型为Number 可以同时使用
*/
getElement(list3);
getElement2(list3);
//getElement(list2);//报错 String类既不是Number类的子类也不是Number的父类
//getElement2(list2); //报错
getElement(list1);
//getElement2(list1); //报错 Integer类不是Number类的父类
// getElement(list4);//报错 Object类是Number类的父类
getElement2(list4);
}
/**
* 设置上限 ？必须是 Number的子类或本类
* @param coll
*/
public static void getElement(Collection<? extends Number> coll){
Iterator<?> iterator = coll.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
/**
* 设置下限 ？ 必须是Number 的父类或本类
* @param coll
*/
public static void getElement2(Collection<? super Number> coll){
Iterator<?> iterator2 = coll.iterator();
while (iterator2.hasNext()){
System.out.println(iterator2.next());
}
}
}
2.5泛型接口
泛型除了可以定义在类中，也可以定义在接口中，这种情况我们称为泛型接口；
定义泛型接口
public interface IMessage<T> {
void print (T t);
}
2.5.1 泛型接口的实现
1）在子类定义时继续使用泛型
接口使用什么泛型，实现类就使用什么泛型。实现类跟着接口走，就相当于定义了一个含有泛型的类，创建对象的时候确定泛型类型
class MessageImpl<T> implements IMessage<T> {
@Override
public void print(T t) {
System.out.println(t);
}
}
public class TestDemo{
public static void main(String[] args){
IMessage<String> mas = new MessageImpl();
msg.print("Hello world!!")；
}
}
2）在子类实现接口时明确的给出具体类型
class MessageImpl implements IMessage<String>{
@Override
public void print(String t){
System.out.println(t);
}
}
public class TestDemo{
public static void main(String[] args){
IMessage<String> msg = new MessageImpl();
msg.print("hello java")；
}
}
2.6 泛型擦除
泛型代码能够很好的和之前版本得到代码很好的兼容，因为 泛型信息只存于代码编译阶段， 若为指定泛型上限：擦成Object类 ，若指定泛型上限 擦成相应的泛型上限
在进入JVM之前，与泛型相关的信息会被擦除，专业术语叫做类型擦除
1.编译时进行类型擦除，在运行时泛型和普通类型一样
2。如果泛型类型参数未指定上限，
扫一扫
72
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
