javaSE泛型——新特性、泛型

一、新特性
java之所以可以一直稳居在编程语言的前列，是因为它不是已成不变的，java的每一个版本都会有新特性，我们主要需要掌握以下几个版本的新特性：
JDK1.2：推出了轻量级的界面包：Swing
JDK1.5：推出新程序结构的设计思想
JDK1.8：Lambda表达式、接口定义加强
1.可变参数
我们来看这样的一个例子：
要求设计一个方法，用于计算任意参数整数相加的结果，对于不同的参数进行相加，我们一起拿在编写函数的时候是通过方法重载的方法来实现的，但是我们知道这样是有弊端的，因为你不到用户到底需要进行多少个数相加，你只能将所有的情况都考虑一遍，显然这是不可能的，所以我们希望我们的方法可以实现任意个数进行相加。所以就有了我们的可变参数：
可变参数的定义格式：
public [static] [final] 返回值方法名称（[参数类型参数名称] [参数类型 … 参数名称]）{ }
这个参数上使用的"…"实际上表示一个数组的结构。
例子：

package com.wschase.xintexing;

/**
 * Author:WSChase
 * Created:2018/12/10
 */
public class TestXin {
    public static void main(String[] args) {
        //1.方法的可变参数
        System.out.println(add(1,4,5,6));
        System.out.println(add(new int[]{1,2,3}));
        System.out.println(add(new int[]{1,2,3,4,5,6}));
    }

    private static int add(int ... data) {//其实可变参数本质上还是数组
        int result=0;
        //正是因为可变参数的本质还是数组，所以我们下面的处理还是用数组来处理的
        for(int i=0;i<data.length;i++){
            result +=data[i];
        }
    return result;
    }
}

注意：需要传递多类参数的时候，可变参数一定要放在最后，并且在一个方法里面我们只能设置一个可变参数。
例子：传递多了类可变参数

     //2.传递多类参数
    public static int add(String msg,int ... data){
        int result=0;
        for(int i=0;i<data.length;i++){
            result +=data[i];
        }
        return result;
    }
        public static void main(String[] args) {
//        //2.传递多类参数
        System.out.println(add("hello"));
        System.out.println(add("hello",1,4,5));
        System.out.println(add("he",new int[]{1,2,3}));
    }

}

2.foreach循环
foreach循环格式：
for(数据类型临时变量：数组（集合）){
//循环次数为数组长度，而每一次循环都会顺序取出数组中的一个元素赋值给临时变量
}
例子：

//2.foreach循环
public class TestXin{
    public static void main(String[] args) {
        int[] data=new int[]{1,2,3,4,5};
        for(int i:data){//在这是将数组中元素的值赋给了临时变量i
            System.out.println(i);//在这我们使用数组中与那素赋值直接使用临时变量赋值就可以了
        }
    }
}

从上面我们可以看到，foreach循环的使用比较方便，但是它也有一个缺点就是当我们需要索引取得数组中的元素值的时候这个就不可以了，我们得单独用一个变量来自增进行。但是如果我们姿势给数组中元素进行整体赋值或者整体取得数组中的元素的时候我们使用foreach循环比较好。
3.静态导入
就是在一个类里面是static修饰的方法，在另外一个类里面使用的时候我们直接用方法名使用，这个时候就需要我们用静态导入的方法将这个静态方法从一个类里面导入到另外一个类中。
二、泛型
从JDk1.5以后引入了三大常用新特性：泛型、枚举、注解。后面的两种我们在前面已经学习过了，这个泛型主要是为了解决程序参数转换的问题。
1.为什么会出现泛型？
当我们的一个方法要接收不同类型的参数的时候，我们需要定义的这个类型得是Object，但是最后我们都需要通过强制类型转换来实现。泛型就是为了解决这一类问题。
2.泛型的格式
（1）泛型类的基本语法
class MyClass{
T value1;
}
这里尖括号<>中的T表示类型参数，可以用于指代任何类型。实际上这个T可以是任意的，但是我们为了规范问题，还是用参数类型的首字母表示。常见的如下：
T：表示一般的任何类
E：白哦是Element的意思，或者Exception异常的意思
K：表示Key的意思
V：表示Values的意思，通常与K一起使用
S:表示Subtype的意思
（2）泛型类定义：如果一个类被的形式定义了，那么它就被称为泛型类。定义泛型类之后的使用：

MyClass<String> myClass1=new MyClass<String>();
MyClass<Integer> myClass2=new MyClass<Integer>();

注意1：泛型只能接受类，所有的基本数据类型必须使用包装类。
注意2：泛型类里面的属性的类型必须是我们泛型当中规定的类型。
泛型类引入多个类型参数以及使用

class MyClass<T,E>{
T value1;
E value2;
}
public class Test{
public static void main(String[] args){
MyClass<String,Integer> myClass = new MyClass<String,Integer>();
      }
}

(3)泛型方法
语法：

class MyClass{
public <T> void testMethod(T t){
System.out.println(t);
}
}

使用类型参数做返回值的泛型方法:

//3.使用类型参数做返回值的泛型方法
class MyClass{
    public <T> T testMethod(T t){
        return t;
    }
}

注意：在泛型方法里面，如果表示参数类型的得在方法返回值的前面有一个对应的<>里面是参数类型。
(4)泛型方法和泛型类是共存的

//4.泛型方法和泛型类是共存的
class MyClass<T> {
//泛型类中的普通方法
    public void testMethod1(T t) {
        System.out.println(t);
    }
//泛型类中的泛型方法
    public <T> T testMethod2(T t) {
        return t;
    }
}
public class TestXin{
    public static void main(String[] args) {
        MyClass<String> myClass= new MyClass<>();//在后面这个<>里面可以不要参数类型
        myClass.testMethod1("这是泛型类中的泛型方法");
        Integer i=myClass.testMethod2(100);
        //由于上面传入的是100，所以返回的类型T也就是100了。
        System.out.println(i);
    }
}

上面泛型的类型容易混淆，所以为了区分我们对于泛型类的类型和泛型方法中的类型使用不同的类型进行泛型处理：

class MyClass<T> {
//泛型类中的普通方法
    public void testMethod1(T t) {
        System.out.println(t);
    }
//泛型类中的泛型方法
   public <E> E testMethod2(E e) {
        return e;
    }
}
public class TestXin{
    public static void main(String[] args) {
        MyClass<String> myClass= new MyClass<>();//在后面这个<>里面可以不要参数类型
        myClass.testMethod1("这是泛型类中的泛型方法");
        Integer i=myClass.testMethod2(100);
        //由于上面传入的是100，所以返回的类型T也就是100了。
        System.out.println(i);
    }
}

3.泛型的几种情况
（1）泛型类里面只有普通方法
（2）普通类里面只有泛型方法
（3）泛型类里面既有泛型方法又有普通方法

//泛型的几种情况
//    3.泛型的几种情况
//            （1）泛型类里面只有普通方法
    class Person<T>{
        private T name;
        private T age;
        //泛型类中没有参数的普通方法
        public void getInfo(){

        }
        //泛型类中有参数的普通方法
        public void fun(T t){
            System.out.println("t="+t);
        }
}
//            （2）普通类里面只有泛型方法
    class Person1{
        private String name;
         private int age;
         //普通类中的泛型方法:注意泛型方法是需要在返回值类型前面有类型声明（占位）的
    public <E> void fun1(E e){
        System.out.println("e="+e);
    }
         //普通类中有返回值的泛型方法
    public <E> E fun2(E e){
        return e;
    }

}
//            （3）泛型类里面既有泛型方法又有普通方法
class Person3<T>{
        private T name;
        private T age;
    //下面这些都是普通方法
    public Person3(T name) {
        this.name = name;
    }

    public Person3(T name, T age) {
        this.name = name;
        this.age = age;
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
    //泛型方法
    public <E> void fun1(E e){
        System.out.println("e="+e);
    }
    //注意：下面的这个方法返回类型和传参类型之所以一样，是因为返回值类型是由传递的参数类型决定的，这样的话类型肯定是一样的。
    public <E> E fun2(E e){
        return e;
    }
}
public class TestXin{
    public static void main(String[] args) {

    }
}

javaSE泛型——新特性、泛型

猜你喜欢