Java包装类和泛型

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 1.4k | 阅读时长 ≈ 6
Java包装类和泛型

2

Java包装类和泛型

  在Java中基本类型使用方便，但是没有对应的方法操作这些基本的数据类型。因此可以使用一个类把基本类型数据装起来，在这个类中定义一些方法，这个类称为包装类。

包装类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package demo01;

public class Wrapper {
    public static void main(String[] args) {
        //装箱：从基本类型转换为对应的包装类对象
        //拆箱：从包装类型转换为对应的基本类对象
        //通过自动装箱获取包装类对象
        Integer integer1 = 10;
        //通过Integer类构造函数创建就包装类对象
        Integer integer2 = new Integer(15);
        Integer integet3 = new Integer("20");
        //通过Integer静态方法创建包装类对象
        Integer integer4 = Integer.valueOf(25);
        Integer integet5 = Integer.valueOf("30");

        //JDK1.5后出现了自动装箱和自动拆箱的过程，首先进行自动拆箱先将Integer对象进行自动拆箱变为int基本类型，然后进行自加5，最后进行自动装箱，从int基本类型变为Integer包装类对象。
        integer1 += 5;

        //从基本类型到String类型的转换
        //通过+""变成String类型
        String s1 = integer1 + "";
        //通过包装类对象的toString方法
        String s2 = integer1.toString();
        //通过包装类的静态toString方法
        String s3 = Integer.toString(integer1);
        //通过String类的静态valueOf方法
        String s4 = String.valueOf(integer1);

        //从String类型到基本类型的转换
        //通过包装类的parseInt/parseFloat等静态方法
        Integer integer6 = Integer.parseInt(s1);
        //通过包装类的valueOf
        Integer integer7 = Integer.valueOf(s1);
    }
}

1

泛型和迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package demo01;

import java.util.Iterator;
import java.util.Vector;

//泛型是一种未知的数据类型，当我们不知道需要哪种数据类型时，可以使用泛型，当使用时再确定。
//泛型类的定义：修饰符 + class + 类名<代表泛型的变量>
//泛型接口的定义和泛型类相同，只是将class改成interface即可。
//写子类或者实现类时，有两种方式，可以指定父类或者接口的类型，这样子类或者实现类就是确定的类型，也可以将定义子类或者实现类仍然是泛型类。
public class Generics<E> {
    E e;

    public Generics(E e) {
        this.e = e;
    }

    public static void main(String[] args) {
        System.out.println("----------测试泛型类----------");
        //使用泛型时：类名<类型> 对象名 = new 类名<>(参数列表);
        Generics<Integer> generics1 = new Generics<>(1);
        Generics<String> generics2 = new Generics<>("hello world!");
        Generics<Double> generics3 = new Generics<>(3.14);
        Generics<Object> generics4 = new Generics<>("Object");
        generics1.print("Integer");
        generics2.print("String");
        generics3.print("Double");

        System.out.println("----------测试泛型方法----------");
        Generics.print(1, "Integer");
        Generics.print("hello world!", "String");
        Generics.print(3.14, "Double");

        System.out.println("----------测试泛型通配符----------");
        Vector<Integer> integerVector = new Vector<>();
        integerVector.add(1);
        integerVector.add(2);
        integerVector.add(3);
        Vector<Double> doubleVector = new Vector<>();
        doubleVector.add(1.1);
        doubleVector.add(2.2);
        doubleVector.add(3.3);
        Vector<String> stringVector = new Vector<>();
        stringVector.add("hello");
        stringVector.add("world");
        stringVector.add("java");
        Generics.print(integerVector);
        Generics.print(doubleVector);
        Generics.print(stringVector);

        System.out.println("----------测试受限泛型----------");
        test1(generics1);
        test1(generics3);
        test2(generics4);
    }

    public void print(String s) {
        System.out.println("我的类型是：" + s + " 值为：" +  e);
    }

    //泛型方法的定义：修饰符 <泛型> + 返回值类型 + 方法名(参数列表)
    //泛型方法更能说明泛型的用处，print函数不能确定打印什么样的数据，因此传入int，float，double，String等类型时，就需要进行函数重载，当写了泛型方法时，在参数列表中不指定类型，而在调用方法时确定泛型的数据类型。
    public static <T> void print(T t, String s) {
        System.out.println("我的类型是：" + s + " 值为：" +  t);
    }

    //泛型通配符：在参数传递的数据中，泛型类型不确定时，可以通过通配符<?>表示，一旦使用泛型的通配符后，不能进行类型转换，只能使用object中的共性方法，自身方法无法使用。
    //注意：只能在参数传递时使用，不能创建<?>类型的数据。
    public static void print(Vector<?> v) {
        //Iterator接口：import java.util.Iterator
        //用于集合操作之中，关于集合操作我会在后面的博客中进行讲解，因为数组增删元素特别繁琐，因此Java给我们提供了一些接口和类可以非常方便的操作元素，这就是集合。
        //集合元素操作时有迭代器的概念，在C++和Python中也有迭代器，就相当于一个指针指向某个元素，迭代器对象有两个非常重要的方法，一个是hasNext()方法，可以判断是否已经迭代完成，另一个是next()方法，当没有迭代完成时，可以指向下一个元素。
        Iterator<?> iterator = v.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    //泛型的上限：此时的泛型？必须是Number类型的同类或子类，因此generics1和generics3可以调用
    public static void test1(Generics<? extends Number> g) {

    }

    //泛型的下限：此时的泛型？必须是Number类型的同类或父类，因此generics4可以调用
    public static void test2(Generics<? super Number> g) {

    }
}

1

Java小结

  今天介绍的是Java的包装类和泛型的概念，现在使用包装类时，因为提供了自动装箱和自动拆箱的功能，因此和基本数据类型非常相似，泛型的概念不常使用，常常用于集合的一些操作之中，类似于C++中的模板概念，作为了解，见到的时候能够辨别即可。

-------------本文结束感谢您的阅读-------------
0%