Java重温

最新推荐文章于 2022-01-18 15:48:40 发布

Alworm

最新推荐文章于 2022-01-18 15:48:40 发布

阅读量163

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/shaxu123/article/details/104954357

版权

Java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

（一）泛型(上)

1）No泛型

public class NeedGeneric1 {
    private static int add(int a, int b) {
        System.out.println(a + "+" + b + "=" + (a + b));
        return a + b;
    }

    private static float add(float a, float b) {
        System.out.println(a + "+" + b + "=" + (a + b));
        return a + b;
    }

    private static double add(double a, double b) {
        System.out.println(a + "+" + b + "=" + (a + b));
        return a + b;
    }

    private static <T extends Number> double add(T a, T b) {
        System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
        return a.doubleValue() + b.doubleValue();
    }

    public static void main(String[] args) {
        NeedGeneric1.add(1, 2);
        NeedGeneric1.add(1f, 2f);
        NeedGeneric1.add(1d, 2d);
        NeedGeneric1.add(Integer.valueOf(1), Integer.valueOf(2));
        NeedGeneric1.add(Float.valueOf(1), Float.valueOf(2));
        NeedGeneric1.add(Double.valueOf(1), Double.valueOf(2));
    }
}

我们不难发现，同一个add方法，我们需要写要几个不同参数形式的方法去适配所有的情况，这无疑是十分不方便的。

2)Have泛型

package com.jay.java.泛型.DefineGeneric;

public class GenericClass<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public static void main(String[] args) {
        GenericClass<String> genericClass=new GenericClass<>();
        genericClass.setData("Generic Class");
        System.out.println(genericClass.getData());
    }
}

3）泛型的意义

适用于多种数据类型执行相同的代码（代码复用）
泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

4)视频部分代码

泛型Car

package lys.genericityup.Bean;

public class Car <T>{
    private T car;

    public Car(T car){
        this.car = car;
    }

    public T getObject() {
        return this.car;
    }
}

测试方法

package lys.genericityup.test;

import lys.genericityup.Bean.Car;
import org.junit.Test;

import java.util.Date;

public class TestMain {

    @Test
    public void testCar(){
        Car<String> car = new Car<>("Bus");
        System.out.println(car.getObject());

        Car<Date> car2 = new Car<Date>(new Date());
        System.out.println(car2.getObject());

    }
}

（二）泛型(下)

1) 泛型的继承规则

对于泛型参数是继承关系的泛型类之间是没有继承关系的
泛型类可以继承其它泛型类，例如: public class Car<T> extends Vehicle<T>
泛型类的继承关系在使用中同样会受到泛型类型的影响

2)视频中部分代码

Car类

package lys.genericitydown.bean;

public class Car<T> extends Vehicle<T>{

    public Car(T name) {
        super(name);
    }
}

Vehicle类

package lys.genericitydown.bean;

public class Vehicle<T> {
    private T name;

    public Vehicle(T name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Vehicle{" +
                "name=" + name +
                '}';
    }
}

Test类

package lys.genericitydown.test;

import lys.genericitydown.bean.Car;
import org.junit.Test;

import javax.xml.crypto.Data;
import java.util.Date;

public class TestMain {
    @Test
    public void test01(){
        System.out.println(new Car<String>("BMW").toString());

    }

}

3) 泛型的通配符问题

<? extends Parent>指定了泛型类型的上级
<? super Child>指定了泛型类型的下级
<?>指定了没有限制的泛型类型

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eoSS6jbf-1584538429218)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1584536788750.png)]$

4）参考代码

public class GenericByWildcard {
    private static void print(GenericClass<Fruit> fruitGenericClass) {
        System.out.println(fruitGenericClass.getData().getColor());
    }

    private static void use() {
        GenericClass<Fruit> fruitGenericClass = new GenericClass<>();
        print(fruitGenericClass);
        GenericClass<Orange> orangeGenericClass = new GenericClass<>();
        //类型不匹配,可以使用<? extends Parent> 来解决
//        print(orangeGenericClass);
    }

    /**
     * <? extends Parent> 指定了泛型类型的上届
     */
    private static void printExtends(GenericClass<? extends Fruit> genericClass) {
        System.out.println(genericClass.getData().getColor());
    }

    public static void useExtend() {
        GenericClass<Fruit> fruitGenericClass = new GenericClass<>();
        printExtends(fruitGenericClass);
        GenericClass<Orange> orangeGenericClass = new GenericClass<>();
        printExtends(orangeGenericClass);

        GenericClass<Food> foodGenericClass = new GenericClass<>();
        //Food是Fruit的父类，超过了泛型上届范围，类型不匹配
//        printExtends(foodGenericClass);

        //表示GenericClass的类型参数的上届是Fruit
        GenericClass<? extends Fruit> extendFruitGenericClass = new GenericClass<>();
        Apple apple = new Apple();
        Fruit fruit = new Fruit();
        /*
         * 道理很简单，？ extends X  表示类型的上界，类型参数是X的子类，那么可以肯定的说，
         * get方法返回的一定是个X（不管是X或者X的子类）编译器是可以确定知道的。
         * 但是set方法只知道传入的是个X，至于具体是X的那个子类，不知道。
         * 总结：主要用于安全地访问数据，可以访问X及其子类型，并且不能写入非null的数据。
         */
//        extendFruitGenericClass.setData(apple);
//        extendFruitGenericClass.setData(fruit);

        fruit = extendFruitGenericClass.getData();

    }

    /**
     * <? super Child> 指定了泛型类型的下届
     */
    public static void printSuper(GenericClass<? super Apple> genericClass) {
        System.out.println(genericClass.getData());
    }

    public static void useSuper() {
        GenericClass<Food> foodGenericClass = new GenericClass<>();
        printSuper(foodGenericClass);

        GenericClass<Fruit> fruitGenericClass = new GenericClass<>();
        printSuper(fruitGenericClass);

        GenericClass<Apple> appleGenericClass = new GenericClass<>();
        printSuper(appleGenericClass);

        GenericClass<HongFuShiApple> hongFuShiAppleGenericClass = new GenericClass<>();
        // HongFuShiApple 是Apple的子类，达不到泛型下届，类型不匹配
//        printSuper(hongFuShiAppleGenericClass);

        GenericClass<Orange> orangeGenericClass = new GenericClass<>();
        // Orange和Apple是兄弟关系，没有继承关系，类型不匹配
//        printSuper(orangeGenericClass);

        //表示GenericClass的类型参数的下界是Apple
        GenericClass<? super Apple> supperAppleGenericClass = new GenericClass<>();
        supperAppleGenericClass.setData(new Apple());
        supperAppleGenericClass.setData(new HongFuShiApple());
        /*
         * ？ super  X  表示类型的下界，类型参数是X的超类（包括X本身），
         * 那么可以肯定的说，get方法返回的一定是个X的超类，那么到底是哪个超类？不知道，
         * 但是可以肯定的说，Object一定是它的超类，所以get方法返回Object。
         * 编译器是可以确定知道的。对于set方法来说，编译器不知道它需要的确切类型，但是X和X的子类可以安全的转型为X。
         * 总结：主要用于安全地写入数据，可以写入X及其子类型。
         */
//        supperAppleGenericClass.setData(new Fruit());

        //get方法只会返回一个Object类型的值。
        Object data = supperAppleGenericClass.getData();
    }

    /**
     * <?> 指定了没有限定的通配符
     */
    public static void printNonLimit(GenericClass<?> genericClass) {
        System.out.println(genericClass.getData());
    }

    public static void useNonLimit() {
        GenericClass<Food> foodGenericClass = new GenericClass<>();
        printNonLimit(foodGenericClass);
        GenericClass<Fruit> fruitGenericClass = new GenericClass<>();
        printNonLimit(fruitGenericClass);
        GenericClass<Apple> appleGenericClass = new GenericClass<>();
        printNonLimit(appleGenericClass);

        GenericClass<?> genericClass = new GenericClass<>();
        //setData 方法不能被调用， 甚至不能用 Object 调用；
//        genericClass.setData(foodGenericClass);
//        genericClass.setData(new Object());
        //返回值只能赋给 Object
        Object object = genericClass.getData();

    }

}

5)泛型中的约束和局限性

不能实例化泛型类
静态变量或方法不能引用泛型类型变量，但是静态泛型方法是可以的
基本类型无法作为泛型类型
无法使用 instanceof 关键字或==判断泛型类的类型
泛型类的原生类型与所传递的泛型无关，无论传递什么类型，原生类是一样的
泛型数组可以声明但无法实例化
泛型类不能继承Exception或者Throwable
不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出

(三) Collection

1）List

 @org.junit.Test
    public void test01(){
        List list = new ArrayList();
        list.add(10);
        list.add("hello");
        list.add(true);
        list.add(99.9f);
        /*
        第一种遍历方法
        */
        for (Object o : list) {
            System.out.println(o);
        }
        /*
        第二中遍历方法
        */
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }

2）`HashSet`

HashSet中没有重复的元素，可以用于去重

@org.junit.Test
    public void test02(){
        /**
         * HashSet中没有重复的元素
         */
        Set set = new HashSet();
        set.add(1);
        set.add("Hello");
        set.add(1246.4f);
        set.add("Hello");
        for (Object o : set) {
            System.out.println(o);
        }
    }

3) Queue

@org.junit.Test
    public void test03(){
        /**
         * 不要使用add方法添加
         * 相同：两者都是往队列尾部插入元素，
         * 不同的：当超出队列界限的时候，add（）方法是抛出异常让你处理，而offer（）方法是直接返回false
         */
        Queue queue = new LinkedList<>();
        queue.offer(1);
        queue.offer("Hello");
        queue.offer(999.9d);
        for (Object o : queue) {
            System.out.println(o);
        }
        /**
         * peek()方法会返回队列的头部
         */
        System.out.println("QueueHead:"+queue.peek());
        System.out.println("QueueSize:"+queue.size());

        /**
         * poll()会把队列的头部取出
         */
        System.out.println("QueueHead:"+queue.poll());
        System.out.println("QueueSize:"+queue.size());


    }

4)`HashMap`

@org.junit.Test
    public void test04(){
        /*
       	添加键值对到map中去
        */
        Map<String,String> map = new HashMap<String,String>();
        map.put("1a","Hello");
        map.put("2b","World");
        map.put("3c","Java");
        /*
        遍历方法一：
        	只获取出map中的values
        */
        System.out.println("打印Values");
        for (String value : map.values()){
            System.out.println(value);
        }
        System.out.println("============================");
        /*
        遍历方法二：
        	获取出map中的key和value
        */
        System.out.println("打印Key:Value");
        Set<String> set = map.keySet();
        for (String key : set) {
            String value = map.get(key);
            System.out.println(key+":"+value);
        }
        System.out.println("============================");
        /*
        遍历方法三：
        	最常用的方法
        */
        System.out.println("最常用的方式打印");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+":"+value);
        }
    }

5）Array

@org.junit.Test
    public void test05(){
        /**
         * 一旦转换是不能修改的
         */
        List list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        for (Object o : list) {
            System.out.println(o);
        }

        System.out.println("List转换为数组");
        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));

        /**
         * 把List转换为不能更改的List
         */

        ArrayList<Object> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        List<Object> unlist = Collections.unmodifiableList(list2);
        /**
         * unlist不能更改
         */

    }