基本类型包装类

概述

将基本数据类型封装成对象，便于我们使用。Java就为每种基本类型提供了对应的包装类类型。

对应类型

如何使用

参考阿里巴巴开发手册中的 OOP规约

13. 关于基本数据类型与包装数据类型的使用标准如下： 
    1） 【强制】所有的POJO类属性必须使用包装数据类型。 
    2） 【强制】RPC方法的返回值和参数必须使用包装数据类型。 
    3） 【推荐】所有的局部变量使用基本数据类型。 

说明：POJO类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何NPE问题，或者入库检查，都由使用者来保证。 

正例：数据库的查询结果可能是null，因为自动拆箱，用基本数据类型接收有NPE风险。 

反例：某业务的交易报表上显示成交总额涨跌情况，即正负x%，x为基本数据类型，调用的RPC服务，调用不成功时，返回的是默认值，页面显示为0%，这是不合理的，应该显示

Integer

Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

常量

// int最大值
public static final int   MIN_VALUE = 0x80000000;

// int最小值
public static final int   MAX_VALUE = 0x7fffffff;

案例代码

public class IntegerFieldDemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

构造方法

// 将int类型转为Integer类型
public Integer(int value) {}

// 将String类型转为Integer类型
public Integer(String s) throws NumberFormatException {}

案例代码

public class ConstructorDemo {
    public static void main(String[] args) {
        Integer num1 = new Integer(100);
        Integer num2 = new Integer("100");
        
        System.out.println(num1);
        System.out.println(num2);
    }
}

类型和进制转换方法

// Integer转为byte类型
public byte byteValue()
    
// Integer转为short类型 
public short shortValue()
    
// Integer转为int类型
public int intValue()
    
// Integer转为double类型
public double doubleValue()
    
// int转为二进制类型的String类型
public static String toBinaryString(int i)
    
// int转为八进制类型的String类型
public static String toOctalString(int i)
    
// int转为十六进制类型的String类型
public static String toHexString(int i)
    
// 将String类型转为int类型
public static int parseInt(String s)
   
// 将int转为Integer
public static Integer valueOf(int i)

// 将String转为Integer
public static Integer valueOf(String s)

案例代码

public class ConvertMethodDemo {
    public static void main(String[] args) {
        Integer num = new Integer(100);
        
        byte byteValue = num.byteValue();
        double doubleValue = num.doubleValue();
        int intValue = num.intValue();
        
        String binaryString = Integer.toBinaryString(100);
        String hexString = Integer.toHexString(100);
        String octalString = Integer.toOctalString(100);
        
        int parseInt = Integer.parseInt("100");
        
        Integer valueOf = Integer.valueOf(100);
        Integer valueOf2 = Integer.valueOf("100");
        
        System.out.println(byteValue);
        System.out.println(doubleValue);
        System.out.println(intValue);
        System.out.println(binaryString);
        System.out.println(hexString);
        System.out.println(octalString);
        System.out.println(parseInt);
        System.out.println(valueOf);
        System.out.println(valueOf2);
    }
}

自动拆装箱

Java 5 增加了自动装箱、拆箱机制，提供基本数据类型和包装类型的相互转换操作。

自动装箱即自动将基本数据类型转换成包装类型

自动拆箱即自动将包装类型转换成基本数据类型

public class TestInteger {
    public static void main(String[] args) {
        int num1 = 10;
        // 自动装箱
        Integer num2 = num1;

        // 自动拆箱
        num2++;
        
        System.out.println(num2);    // 11
    }
}

[【注意】底层调用的是valueIOf()]()

Character

常用方法

// 判断是否是大写字符
public static boolean isUpperCase(char ch)
    
// 判断是否是小写字符
public static boolean isLowerCase(char ch)
    
// 判断是否是数字    
public static boolean isDigit(char ch)
    
// 字符转大写
public static char toUpperCase(char ch)
    
// 字符转小写
public static char toLowerCase(char ch)

总结

基本类型包装类是对基本数据类型的封装，并提供了一些字段和方法使其更符合面向对象思想

除了Integer和Character，其他6种都是首字母大写

泛型

概述

Java泛型是JavaSE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型在定义的时候是宽泛的，而在使用的时候是确定的。可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

泛型的优点

1、提高了程序的安全性(类型安全)
2、提高了程序的可扩展性、可重用性
3、将运行期遇到的问题转移到了编译期
4、省去了类型强转的麻烦(Object类对象)

泛型格式

泛型标识符：<自定义无意义英文大写单字母占位符>
    常用格式：        
        <T> Type 
        <E> Element
        <K> Key
        <V> Value

泛型类：把泛型定义在类上
    格式:public class 类名<泛型类型1,…>
        【注意】泛型类型必须是引用类型
        
泛型方法：把泛型定义在方法上
    格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
        
泛型接口：把泛型定义在接口上
    格式:public  interface 接口名<泛型类型1…>

泛型方法

public class GenericityMethodDemo {
    public static void main(String[] args) {
        System.out.println(getData(100));
        System.out.println(getData("Java"));
        System.out.println(getData('A'));
        System.out.println(getData(false));
    }

    /**
     * 泛型方法
     * 格式：
     *         泛型限定符 返回值类型 方法名(泛型类型 参数名) {}
     * 
     * @param <T> 泛型限定符
     * @param t 任意类型的参数
     * @return 返回任意类型参数
     */
    public static <T> T getData(T t) {
        return t;
    } 
}

【注意】

1、要求形式参数列表中必须有一个参数是当前自定义泛型，因为需要通过参数来约束当前方法运行过程中泛型对应的具体数据类型是哪一个
        
2、返回值类型可以使用自定义泛型，而且是被形式参数列表中传入的泛型对应具体的数据类型控制
        
3、方法体内也可以使用自定义泛型，同时也是被参数当中泛型对应具体数据类型约束监控

泛型类

public class GenericityClassDemo {
    public static void main(String[] args) {
        Number<Integer> num1 = new Number<Integer>(100);
        Number<String> num2 = new Number<String>("100");
        System.out.println(num1.getT());
        System.out.println(num2.getT());
    }
}

/**
 * 泛型类，把泛型定义到类上，整个类内都可以使用。是对泛型方法的封装
 * @param <T> 泛型标识符
 */
class Number<T> {
    private T t;

    // Constrator、setters、getters
}

【注意】

1、类内可以直接使用对应的类名声明泛型
2、类内使用的泛型具体数据类型是在创建当前类对象时约束
3、在创建当前类对象时没有约束泛型对应的具体数据类型，那么所有使用到泛型的位置都是Object类型，有悖于泛型使用原则
4、如果类声明过了泛型，那么类中所有使用此泛型的方法都同时被声明，即无法使用其他类型
5、泛型类中定义的静态方法不能直接使用类声明的泛型，因为泛型需要在创建对象时声明，而静态方法在类加载时就加载完成，此时泛型还没有声明。如果静态方法想要使用泛型，只能自己声明自己使用

泛型接口

/**
 * 自定义一个比较器接口
 * @param <T> 泛型
 */
interface Comparable<T> {
    /**
     * 这是一个比较方法，实现类应该实现这个方法以达到比较的目的
     * 
     * @param t 传入被比较的对象
     * @return 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
     */
    public abstract int compareTo(T t);
}

/**
 * 自定义父类，实现比较器接口
 */
class Father implements Comparable<Father>{
    private String name;
    private int age;
    
    // Constrator、setters、getters
    
    @Override
    public int compareTo(Father f) {
        return this.age - f.age;
    }
}

public class GenericityInterfaceDemo {
    public static void main(String[] args) {
        Father father1 = new Father("小明父亲", 30);
        Father father2 = new Father("小红父亲", 29);
        
        if (father1.compareTo(father2) < 0) {
            System.out.println("小红父亲年长：" + father2.getAge());
        } else {
            System.out.println("小明父亲年长：" + father1.getAge());
        }
    }
}

【注意】

1、接口中的成员变量不能使用泛型，因为static、final
2、泛型接口的实现可以指定泛型的类型，也可以不指定

泛型通配符

表示全部类型，类似Object

<?>

泛型上限

表示以T为父类的所有子类（包括父类）

<? extends T>

泛型下限

表示以E为子类的所有父类（包括子类）

<? super E>

泛型推断

JDK1.7新特性，可以省略实例化对象时尖括号内的类型不写

总结

1、泛型就是泛化的类型，本质是参数化类型，是jdk1.5引入的新特性，用在类、接口和方法上，即泛型类，泛型接口和泛型方法

2、为了解决利用继承Object来实现通用性导致的强制类型转换和可能发生的类型转换异常的问题。

3、泛型的好处是确保了编译时期的类型安全，和避免了强制类型转换的麻烦

4、缺陷是因为泛型使用了类型擦除机制，jvm运行之前会将泛型信息擦除掉，这样做是为了兼容jdk1.5之前的代码，但是也会导致通过反射可以跳过泛型的问题，因为运行期间并没有泛型的限制

5、泛型通配符？代表任意类型，泛型上限<? extends T>，泛型下限<? extends T>

6、jdk1.7新特性泛型推断，声明变量时定义过泛型得话，在实例化对象时可以省略类型，但是还要加<>，否则还是原类型

版权属于：不冷

本文链接：https://www.buleng.xyz/archives/69/

转载时须注明出处及本声明