Java-29 泛型 增强for循环 静态导入 可变参数

本文主要是介绍Java-29 泛型 增强for循环 静态导入 可变参数，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 泛型：把明确数据类型的工作提前到编译时期，在创建对象的时候明确。这种有点像把类型当作参数进行传递，所以泛型还有另外一种叫法：参数化类型。
• 格式：

  　　　　<数据类型>
  注意：这里的数据类型只能是引用数据类型

• 好处：

　　　　　　　　1、将运行时期的问题提前到编译时期
　　　　　　　　2、避免了强制类型转化　　　　
　　　　　　　　3、优化了代码程序，消除不必要的黄色警告线

import java.util.ArrayList;

public class GenericDemo1 {
    public static void main(String[] args) {
        //JDK1.7之后会自动的进行类型推断
        ArrayList<String> strings = new ArrayList<>();

        strings.add("hello");
        strings.add("world");
//        strings.add(1);//报错

        //集合遍历
        for (String string : strings) {
            System.out.println(string);
        }
    }
}

• 泛型的高级用法：（通配符）

　　　　泛型通配符<?>
　　　　　　任意类型，如果没有明确，那么就是Object以及任意的Java类了

//如果泛型里面的类型只用一个的时候，并且明确了数据类型的时候，前后必须要写一致
        ArrayList<Object> objects = new ArrayList<Object>();
//        ArrayList<Object> objects2 = new ArrayList<Animal>();
//        ArrayList<Object> objects2 = new ArrayList<Dog>();
//        ArrayList<Object> objects3 = new ArrayList<Cat>();

        //泛型通配符<?>
        //表示任意类型，如果没有明确，那么就是Object以及任意的Java类
        //还没有明确类型
        ArrayList<?> objects1 = new ArrayList<Object>();
        ArrayList<?> objects2 = new ArrayList<Animal>();
        ArrayList<?> objects3 = new ArrayList<Dog>();
        ArrayList<?> objects4 = new ArrayList<Cat>();

　　　　<? extends E>
　　　　　　向下限定，E及其子类

 //<? extends E>
        //向下限定，E及其子类
        ArrayList<? extends Animal> a1 = new ArrayList<Animal>();
        ArrayList<? extends Animal> a2 = new ArrayList<Dog>();
        ArrayList<? extends Animal> a3 = new ArrayList<Cat>();
//        ArrayList<? extends Animal> a4 = new ArrayList<Object>();

　　　　<? super E>
　　　　　　向上限定，E及其父类

 //<? super E>
        //向上限定，E及其父类
        ArrayList<? super Animal> animal1 = new ArrayList<Animal>();
//        ArrayList<? super Animal> animal2 = new ArrayList<Dog>();
//        ArrayList<? super Animal> animal3 = new ArrayList<Cat>();
        ArrayList<? super Animal> animal4 = new ArrayList<Object>();

•  泛型类的使用

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}



public class GenericDemo3 {
    public static void main(String[] args) {
        GenericClass<String> stringGenericClass = new GenericClass<>();

        stringGenericClass.setName("hello");
        System.out.println(stringGenericClass.getName());//hello
//        stringGenericClass.setName(12);//编译错误


    }
}

•  定义含有泛型的类

/*
泛型方法：将泛型定义方法上
            格式：public <泛型类型> 返回类型 方法名(泛型类型 .)
 */
public class GenericDemo4 {
    public static void main(String[] args) {
        GenericDemo4 genericDemo4 = new GenericDemo4();
        genericDemo4.show1(110);
        genericDemo4.show1("hello");
        genericDemo4.show1(false);

        show(112);
        show("true");
        show('h');
    }

    //定义一个泛型方法
    public  <E> void show1(E e){
        System.out.println(e);
    }

    //定义一个含有静态方法的泛型方法
    public static <E> void show(E e){
        System.out.println(e);
    }
}

•  定义泛型接口
  • 使用方式一 ：定义接口的实现类，实现接口，指定接口的类型
  • 使用方式二：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走

/*
        把泛型定义在接口上
        格式:public  interface 接口名<泛型类型1…>

 */

public interface Generic<T> {
    public abstract void show(T t);
}


//定义实现接口类
public class GenericClass2<T> implements Generic<T>{

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}




/*
        泛型接口测试
 */
public class GenericDemo5 {
    public static void main(String[] args) {
        GenericClass2<String> stringGenericClass2 = new GenericClass2<>();
        stringGenericClass2.show("hello");//hello

        GenericClass2<Object> objectGenericClass2 = new GenericClass2<>();
        objectGenericClass2.show(1);
    }
}

•  增强for循环: 用来遍历数组和Collection集合

　　　　增强for循环，JDK1.5之后出现
　　　　到目前为止，JDK1.5之后出现的特性：泛型、增强for循环、包装类（自动装箱、自动拆箱）

• 格式：

for(元素的数据类型 变量名 : 数组名/Collection集合名称){
                    使用变量即可，该变量就是元素。
            }

• 注意：集合和数组能使用增强for循环的，就使用增强for循环，它也可以消除黄色警告线

public class ForDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,2,3,4,5,6};

//        for(int i=0;i<arr.length;i++){
//            System.out.println(arr[i]);
//        }
        System.out.println("+++++++++++++增强for循环遍历数组+++++++++++++");

        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("=====================================");

        //创建一个集合对象
        ArrayList<String> strings = new ArrayList<String>();
        strings.add("hello");
        strings.add("world");
        strings.add("bigdata");
        strings.add("hive");

//        for(String string : strings){
//            System.out.println(string);
//        }
//        strings = null;

        //NullPointerException
//        for (String string : strings) {
//            System.out.println(string);
//        }

        //上面的string是不是从strings集合取出来的，而strings是null
        //所以我们在遍历之前加一个判断，判断是不是空
//        if(strings != null){
//            for (String string : strings) {
//                System.out.println(string);
//            }
//        }

        //其实增强for循环就是用来替代迭代器的
        //如何验证呢？
        //我们之前学迭代器的时候，遇到一个问题：并发修改异常
        //ConcurrentModificationException
        for(String s : strings){
            if("world".equals(s)){
                strings.add("flink");
            }
        }

• 静态导入：
  • 格式：import static 包名….类名.方法名;
  • 注意事项：
    • 方法必须是静态的
    • 如果说本类有其他的方法与静态导入的方法重名了，优先使用的是本类中的方法
    • 当静态导入的方法重名了，通过增加前缀的方法去调用

public class FunctionDemo {

    public static void show(String s){
        System.out.println(s);
    }

    public static int abs(int i){
        System.out.println("这是在FunctionDemo中的abs方法");
        return i;
    }
}

/*
        静态导入：
            静态导入概述
            格式：import static 包名….类名.方法名;
            可以直接导入到方法的级别

 */

import static java.lang.Math.abs;
import static com.shujia.java.day18.FunctionDemo.show;
import static com.shujia.java.day18.FunctionDemo.abs;
public class StaticImportDemo {
    public static void main(String[] args) {
        System.out.println(Math.abs(-100));

        //有没有什么办法，不用去写类名，直接写方法名调用即可
//        System.out.println(abs(-100));
        //有一种办法，可以不用写类名，直接通过使用方法名调用
        //静态导入 import static java.lang.Math.abs;
//        System.out.println(abs(-200));

        //在一个程序种静态导入使用的方式可以和类名直接调用方式共存
        show("hello");//这是在本类中的show方法
        FunctionDemo.show("world");

        //当静态导入的方法重名了，怎么办呢？
        //通过增加前缀的方法去调用
//        System.out.println(abs(20));
        System.out.println(com.shujia.java.day18.FunctionDemo.abs(20));
    }
    
    public static void show(String s){
        System.out.println("这是在本类中的show方法");
    }
}

可变参数：

/*
        可变参数概述
            定义方法的时候不知道该定义多少个参数
        格式
            修饰符 返回值类型 方法名(数据类型...  变量名){}
        注意：
            这里的变量其实是一个数组
            如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

 */
public class ArgsDemo {
    public static void main(String[] args) {
        //求两个数之和
        int a = 10;
        int b = 20;
        sum(a,b);

        //求三个数之和
        int c = 30;
        sum(a,b,c);

        //求四个数之和
        int d = 40;
        sum(a,b,c,d);

        //可变参数改进
        sum(a,b,c,d,12,32,41,2,13,141,431,31,313,89);
        
    }

    public static void sum(int... ints){
        int sum =0;
        //这里的变量其实是一个数组
        for (int anInt : ints) {
            sum +=anInt;
        }
        System.out.println(sum);
    }

    public static void sum(int i,int j){
        System.out.println(i+j);

    }

    public static void sum(int i,int j,int x){
        System.out.println(i+j+x);

    }

    public static void sum(int i,int j,int x,int y){
        System.out.println(i+j+x+y);

    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
        Arrays工具类中的可变参数方法举例：
            public static <T> List<T> asList(T... a)：将数组转成集合

        1、集合与数组之间的互相转换
        2、数组排序
 */
public class ArraysDemo {
    public static void main(String[] args) {
        //集合--数组
        ArrayList<Integer> integers = new ArrayList<Integer>();
        integers.add(33);
        integers.add(44);
        integers.add(11);
        integers.add(55);
        integers.add(22);



        //将集合转成数组
        Object[] objects = integers.toArray();


        //数组--集合
        List<Object> objectList = Arrays.asList(objects);
        for (Object o : objectList) {
            Integer i = (Integer)o;
            System.out.println(i);

        }

        System.out.println("******************************");
        Arrays.sort(objects);
        for (Object object : objects) {
            System.out.println(object);

        }


    }
}

这篇关于Java-29 泛型 增强for循环 静态导入 可变参数的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！