数据结构与算法（Java）-002- Java功能复习

泛型使用

1.在类名后面 <泛型名>
2.在类中直接使用 泛型名 来定义变量类型
3.在新建对象的时候，泛型名变成一个具体的类型

package top.itcourse.genericity;                                                                                  
/*                                                                                                                
 * 1.在类名后面 <泛型名>                                                                                                  
 * 2.在类中直接使用 泛型名 来定义变量类型                                                                                          
 * 3.在新建对象的时候，泛型名变成一个具体的类型                                                                                        
 */                                                                                                               
public class Genericity<AnyType> {                                                                                
    private AnyType storedValue;                                                                                  

    public AnyType read() {                                                                                       
        return storedValue;                                                                                       
    }                                                                                                             

    public void write(AnyType x) {                                                                                
        storedValue = x;                                                                                          
    }                                                                                                             

    public static void main(String[] args) {                                                                      
        // 新建对象的时候，泛型名 被具体化                                                                                       
        Genericity<String> genericity = new Genericity<>();                                                       

        genericity.write("JavaWeb架构师");                                                                           

        System.out.println(genericity.read());                                                                    
    }                                                                                                             
}                                                                                                                                                                                                                        

结果是：
JavaWeb架构师

自动拆箱装箱

基本数据类型和它们的包装类之间可以直接的相互赋值，这就是自动拆箱装箱。

package top.itcourse.genericity; 

public class Genericity<AnyType> {
    private AnyType storedValue;

    public AnyType read() {
        return storedValue;
    }

    public void write(AnyType x) {
        storedValue = x;
    }

    public static void main(String[] args) {

        // 泛型具体化的时候使用的是包装类
        Genericity<Integer> genericity = new Genericity<>();

        // 在传递参数的时候，直接传int这种基本数据类型（自动装箱）        
        genericity.write(56);

        // 自动拆箱     
        int read = genericity.read();

        System.out.println(read);
    }
}

结果是：
56

通配符

对集合中元素进行互转的限制：? extends Father，表示Father及其子类可以使用。

package top.itcourse.genericity;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Genericity<AnyType> {

    //  1.Collection<? extends Shape>：表示这个Collection集合可以是Shape及其子类
    public static int totalArea(Collection<? extends Shape> shapes) {
        int totalArea = 0;

        for (Shape shape : shapes) {
            totalArea += shape.getArea();
        }
        return totalArea;
    }
    public static void main(String[] args) {
        // 2.传Collection<Circle extends Shape> 
        System.out.println(totalArea(Arrays.asList(new Circle[]{new Circle(),new Circle(),new Circle()})));

        // 3.传Collection<Square extends Shape>      
        System.out.println(totalArea(Arrays.asList(new Square[]{new Square(),new Square(),new Square()})));
    }
}

class Shape {
    public int getArea() {
        return 1;
    }
}

class Square extends Shape {
    public int getArea() {
        return 2;
    }
}

class Circle extends Shape {
    public int getArea() {
        return 3;
    }
}

结果：
9
6

泛型方法

为什么使用泛型方法：
1. 该特定类型用做返回类型；
2. 该类型用在多于一个的参数类型中；
3. 该类型用于声明一个局部变量。

package top.itcourse.generivity; 

public class TestGenerivityMethod {
    /*
    * 泛型方法：
    * 修饰符 <T> 返回类型 方法名(形参){ 局部变量; }
    * 
    * 1.该特定类型用做返回类型；
    * 2.该类型用在多于一个的参数类型中；
    * 3.该类型用于声明一个局部变量。
    */
    /**
    * 
    * @Title: indexAnyNums 
    * @Description: 查询target在anyNums中的位置，不存在返回-1 
    * @param @param anyNums：数据源数组
    * @param @param target：目标对象
    * @param @return  返回目标对象在数据源数组中的位置 
    */
    public static <AnyNum> int indexAnyNums(AnyNum[] anyNums,AnyNum target) {
        for (int i = 0; i < anyNums.length; i++) {
            if (target.equals(anyNums[i])) {
                return i;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int indexAnyNums = indexAnyNums(new String[] {"PHP" ,"Java","C++"},"Java");
        System.out.println(indexAnyNums);
    }
}

结果是：
1

类型界限

当我们对泛型对象使用一些特定类才有的操作时，编译是不会被通过的。这时候我们可以使用泛型界限来解决这个问题。

public class TestGenerivityBounds {
    /*
    * 在指定泛型的时候，说明这个泛型将会从什么类过来（如过这个类还有泛型，就一直指定下去），
    * 在后面使用这个泛型对象的时候，就可以直接调用相关的方法。
    * 
    * <AnyNum extends Shape>：这个泛型的父类是Shape（如果Shape也有泛型的话，可以继续指定下去）
    */
    public static <AnyNum extends Shape> int getArea(AnyNum anyNum) {
        // 就可以调用这个泛型的 getArea方法了        
        return anyNum.getArea();
    }

    public static void main(String[] args) {
        System.out.println(getArea(new Square()));
    }
}

interface Shape {
    public int getArea();
}

class Circle implements Shape {

    @Override
    public int getArea() {
        return 1;
    }
}

class Square implements Shape {
    @Override
    public int getArea() {
        return 2;
    }

}

结果是：
2

类型擦除

编译器生成的bytecode是不包涵泛型信息的，泛型类型信息将在编译处理时被擦除，这个过程即类型擦除。类型变量由类型界限来代替。

记住：
1.虚拟机中没有泛型，只有普通类和普通方法
2.所有泛型类的类型参数在编译时都会被擦除
3.创建泛型对象时请指明类型，让编译器尽早的做参数检查（Effective Java，第23条：请不要在新代码中使用原生态类型）
4.不要忽略编译器的警告信息，那意味着潜在的ClassCastException等着你。

限制：
1. 基本类型不能做类型参数。
2. instanceof检测：只对原始类型转换工作进行检测。不同的泛型参数之间可以相互强制转换[通过object]（因为泛型擦除），通过编译，但是运行的时候会出现类型转换异常。
3. 因为类型擦除，实际上只有一个原始类，所以不同的类型参数的对象之间的静态部分是共享的
4. 不能创建泛型对象、数组（根据泛型参数创建类型变量）。如：T t = new T();T[] t = new T[10];

public class TestTypeErasure<T> {

    public static void main(String[] args) {
        // 1.   基本类型不能做类型参数。
        // Test<int> test1 = new Test<>();

        // 2.   instanceof检测：只对原始类型转换工作进行检测。不同的泛型参数之间可以相互强制转换[通过object]（因为泛型擦除），通过编译，但是运行的时候会出现类型转换异常。
        Test<Integer> test2 = new Test();
        test2.write(12);
        Object object = test2;
        Test<String> test3 = (Test<String>)object;
        // java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String       
        String read = test3.read();
        System.out.println(read);

        //3. 因为类型擦除，实际上只有一个原始类，所以不同的类型参数的对象之间的静态部分是共享的
        test2.setStr("灰灰");
        System.out.println(new Test().getStr());        //灰灰
    }
}


class Test<AnyType> {

    // 静态部分
    private static String str;

    public static String getStr() {
        return str;
    }

    public static void setStr(String string) {
        str = string;
    }

    //4. 不能创建泛型对象、数组（根据泛型参数创建类型变量）。如：T t = new T();T[] t = new T[10];
//  AnyType anyType2 = new AnyType();
//  AnyType[] anyTypes = new AnyType[10];

    private AnyType anyType;

    public AnyType read() {
        return anyType;
    }

    public void write(AnyType anyType) {
        this.anyType = anyType;
    }

}

结果：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
灰灰

函数对象

当我需要使用特定的方法去完成不同的功能时，我们可以创建一个类，这个类中有一个方法，然后把这个类的对象传递进去。这个类的实例就是函数对象。

public class TestFuncClass {
    /*
    * 2. 把函数对象传进去，调用相关的方法
    */
    public static int choose(int a, int b,MaxMin<Integer> mm) {
        return mm.compare(a, b);
    }

    public static void main(String[] args) {
        /*
        * 3. 具体调用的时候，去具体实现这个函数对象中的方法        
        */
        int max = choose(10, 20, (a, b) -> 
            a > b ? a : b);

        System.out.println("max: " + max);

        int min = choose(10, 20, (a, b) -> 
            a>b?b:a);

        System.out.println("min: " + min);
    }
}

/*
 * 1. 定义函数对象： 使用泛型、接口
 */
interface MaxMin<AnyType> {
    public int compare(AnyType a, AnyType b);
}

结果：
max:20
min:10

其它

源码下载：

关注下方微信公众号，
回复：
DS-AA-Java.code

• 欢迎加入交流群：451826376

• 更多信息：www.itcourse.top