黑马程序员_Java基础_泛型应用 和 基本数据类型对象包装类

最新推荐文章于 2022-07-07 14:17:46 发布
最新推荐文章于 2022-07-07 14:17:46 发布
阅读量455 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012956156/article/details/45460819
版权
------- android培训、 java培训、期待与您交流！ ----------


泛型：JDK1.5版本之后出现的新特性   用于解决安全问题，是一个类型安全机制

好处：
1.将运行时期出现问题ClassCastException，转移到了编译时期
 方便于程序员解决问题，让运行好事情问题减少，安全
 
2.避免了强制转换麻烦

泛型格式： 通过<>来定义要操作的引用数据类型

 

在使用java 提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见
只要见到<>就要定义泛型

其实<>就是用来接收类型的

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候
早起定义Object来完成扩展
现在定义泛型来完成扩展

例子1：

<strong>public class GenericDemo {


    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<String>();

        

        list.add("a");

        list.add("alg");

        list.add("ngdt");

        list.add("qwwfe");

//      list.add(4);   这会在编译时报错，因为数据类型不一致  

//      其实，List存储的是对象类型，而基本类型先经过自动装箱拆箱放入List集合中

        

        Iterator<String> it = list.iterator();

        while(it.hasNext()){

            String s = it.next();

            System.out.println(s+":"+s.length());
        } 

    }


}</strong>


 例子2：

<strong>public class GenericDemo01 {

    public static void main(String[] args) {

        TreeSet<String> tree = new TreeSet<String>(new MyComparator());

        

        tree.add("a");

        tree.add("alg");

        tree.add("akk");

        tree.add("qwwfe");

        tree.add("ngdt");

        

        Iterator<String> it = tree.iterator();

        while(it.hasNext()){

            String s = it.next();

            System.out.println(s);

        }

    }

}

class MyComparator implements Comparator<String>{


    @Override

    public int compare(String o1, String o2) {

        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));

        if(num == 0 ){

            return o1.compareTo(o2);

        }

        return num;

    }

    

}</strong>

泛型类定义的泛型，在整个类中有效，如果被方法使用
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了

为了让不同方法可以操作不同类型，而且类型还不确定
那么可以将泛型定义在方法上


特殊之处：
静态方法不可以访问类上的定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
 

 例子3： 
<strong>//在类名中定义泛型

class Demo<T>{

    public void show(T t){

        System.out.println("show :" + t);

    }

    public void print(T t){

        System.out.println("print :" + t);

    }

    public static <W> void method(W w){

        System.out.println("method:" + w);

    }

}


//在方法中定义泛型   （根据自己的需要进行选择定义）

class Demo01{

    public <T> void show(T t){

        System.out.println("show :" + t);

    }

    public <T> void print(T t){

        System.out.println("print :" + t);

    }

}


public class GenericDemo03 {


    public static void main(String[] args) {

        

        //将泛型定义在类中，整体都是泛型

        Demo<String> d = new Demo<String>();

        d.show("hello");

        d.print("work");

        d.method("静态方法");

        

        //方法中能定义多种类型

        Demo01 e = new Demo01();

        e.show("i am String");

        e.print(new Integer(3));

    }

}</strong>
 例子4： 
<strong>/*

 泛型定义在接口上

 */

interface Inter<T>{

    void show(T t);

} 


class InterImp01 implements Inter<String>{

    @Override

    public void show(String t) {

        System.out.println(t);

    }

    

}


class InterImp<T> implements Inter<T>{

    @Override

    public void show(T t) {

        System.out.println(t);

    }

}


public class GenericDemo04 {

    public static void main(String[] args) {

        InterImp01 i = new InterImp01();

        i.show("interImp");

        

        InterImp<Integer> n = new InterImp<Integer>();

        n.show(4);

    }


}</strong>

  ?通配符，  也可以理解为占位符   表示任意
 
 泛型的限定：
 ？ extends E ：可以接收 E类型或者E的子类型。   上限
 ？ super E :可以接收E类型或者E的父类型。   下限

例子5：  
<strong>public class GenericDemo05 {


    public static void main(String[] args) {

        

/*      ArrayList<String> list = new ArrayList<String>();

        list.add("abc1");

        list.add("abc2");

        list.add("abc3");

        list.add("abc4");

        

        ArrayList<Integer> list01 = new ArrayList<Integer>();

        list01.add(1);

        list01.add(2);

        list01.add(3);

        list01.add(4);

        printColl(list);

        printColl(list01);

*/

        ArrayList<Person> list02 = new ArrayList<Person>();

        list02.add(new Person("lisi__01"));

        list02.add(new Person("lisi__02"));

        list02.add(new Person("lisi__03"));

        list02.add(new Person("lisi__04"));

        showColl(list02);

        

        ArrayList<Student> list03 = new ArrayList<Student>();

        list03.add(new Student("student__01"));

        list03.add(new Student("student__02"));

        list03.add(new Student("student__03"));

        list03.add(new Student("student__04"));

        showDownColl(list03);

    }

    

    //上限方式

    public static void showColl(ArrayList<? extends Person> list){

        Iterator<? extends Person> it = list.iterator();

        while(it.hasNext()){

            System.out.println(it.next().getName());

        }

    }

    //下限方式

    public  static void showDownColl(ArrayList<? super Student> list){

        Iterator<? super Student> it = list.iterator();

        while(it.hasNext()){

            System.out.println(it.next().toString());

        }

    }

    

    

    //迭代器的遍历

    public static void printColl(ArrayList<?> list){

        Iterator<?> it = list.iterator();

        while(it.hasNext()){

            System.out.println(it.next());

        }

    }


}


class Person{

    private String name;

    Person(String name){

        this.name = name;

    }

    public String getName() {

        return name;

    }


    public void setName(String name) {

        this.name = name;

    }

}

class Student extends Person{

    Student(String name){

        super(name);

    }

}</strong>
 例子6： 
<strong>/*

 * TreeSet泛型父类继承比较   

 * 

 */

public class GenericDemo06 {


    public static void main(String[] args) {

        TreeSet<Student> tree = new TreeSet<Student>(new Compa());

        tree.add(new Student("student__02"));

        tree.add(new Student("student__02"));

        tree.add(new Student("student__01"));

        tree.add(new Student("student__04"));

        tree.add(new Student("student__03"));

        

        Iterator<Student> it = tree.iterator();

        while(it.hasNext()){

            System.out.println(it.next().getName());

        }

        

        TreeSet<Work> work  = new TreeSet<Work>(new Compa());

        work.add(new Work("work__03"));

        work.add(new Work("work__01"));

        work.add(new Work("work__04"));

        work.add(new Work("work__02"));

        Iterator<Work> i = work.iterator();

        while(i.hasNext()){

            System.out.println(i.next().getName());

        }

        


    }


}


class Compa implements Comparator<Person>{

    @Override

    public int compare(Person o1, Person o2) {

        return o1.getName().compareTo(o2.getName());

    }

    

}


class Work extends Person{

    Work(String name) {

        super(name);

    }

    

}</strong>


例子7： 
class Worker {


}


class Utils<E> {

    private E e;

    public E getObject() {

        return e;

    }


    public void setObject(E e) {

        this.e = e;

    }

}


public class GenericDemo02 {

    public static void main(String[] args) {

        Utils<Worker> u = new Utils<Worker>();

        u.setObject(new Worker());

        Worker w = u.getObject();

    }


}

 1.基本数据类型对象包类

byte    Byte
short    Short
int        Integer
long    Long
boolean    Boolean
float    Float
double    Double
char    Charcter

2.基本数据类型转换成字符串
基本数据类型呢+""
基本数据类型呢.toString(基本数据类型值)。
如：Interger.toString(34);//将34转换成为"34"
3.字符串转换成基本数据类型
int a = Integer.parseInt("123");
double b = Double.parseDouble("12.34");
boolean b = Boolean.parseBoolean("true");
Interger i = new Integer("123");
int num = i.intValue();
4.十进制转成其他进制
toBinaryString();二进制
toHexString();十六进制
toOctalString();八进制
5.其他进制转换成十进制
parseInt(String str,int radix);//radix表示进制数
 测试例子1： 

public class IntegerDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        //整数类型的最大值
        print("int max:"+ Integer.MAX_VALUE);
        //整数类型的最小值
        print("int min:" + Integer.MIN_VALUE);
        //将一个字符串转成整数
        int num = Integer.parseInt("123");  //必须输入数字格式，否则或抛出异常
        print("num+4:" +( num +4));
        long num_ = Long.parseLong("123456789");  //必须输入数字格式，否则或抛出异常
        print("num_+4:" +( num_ +4));
        
        //十进制转化二进制
        print(Integer.toBinaryString(5));
        //十进制转换十六进制
        print(Integer.toHexString(60));
        //十进制转换八进制
        print(Integer.toOctalString(8));
        
        
        //二进制转十进制
        print(Integer.parseInt("110", 2));
        //八进制转十进制
        print(Integer.parseInt("10", 8));
        //十六进制转十进制
        print(Integer.parseInt("3c", 16));
        
        
        
    }
    
    public static void print(Object obj){
        System.out.println(obj.toString());
    }
}


 简单测试例子：
/*
 JDK1.5版本以后出现的新特性
 */
  
public class IntegerDemo01 {
    public static void main(String[] args) {
//      Integer x = new Integer("4");
        Integer x = 4; //自动装箱   相当于new Integer("4");
        x = x + 2;  //x+2    x进行自动拆箱，变成int类型数据与2进行运算，得到结果再进行装箱
        
        Integer m = 128;
        Integer n = 128;
        System.out.println(m==n);    //结果：false
        
        Integer a = 127;
        Integer b = 127;
        System.out.println(a==b);   //结果是：true
        //因为a和b指向同一个Integer对象
        //因为当数值在byte(-128~127)范围内容，对于新特性，如果该数值已经存在，则不会再开辟新的内存空间
        
        Integer y = new Integer("123");
        Integer z = new Integer(123);
        
        System.out.println("y==z"+(y==z));   //false   因为y   z分别是两个对象
        System.out.println("y.equals(y)"+x.equals(y));  //true   两个数值是一样大小的
        
    }
}




未来幻想者
关注
java基本数据类型泛型_Java中的泛型
weixin_33484163的博客
03-08 1689
泛型规范在JDK1.5版本中被添加，使用泛型机制编写的代码比起随意使用Object变量然后再进行强制类型转换的代码具有更高的安全性和可读性，同时也更为简洁。泛型对于集合类尤其有用，例如 ArrayListarray = new ArrayList();。一、泛型泛型程序设计(Generic programming)意味着编写的代码可以被很多操作不同数据类型的对象所重用。例如ArrayListarr...
60.泛型格式是什么？java中的数据类型有哪些？java中基本数据类型的包装类是哪些？
嘻哈怪才的博客
01-05 245
泛型格式是什么？ Java中泛型规定： <自定义无意义应为大写单字母占位符> 常用: <T> Type <E> Element <K> Key <V> Value 作用： 泛型可以用来约束 方法、类、接口 java中的数据类型有哪些？java中基本数据类型的包装类是哪些？ Java中有两大数据类型 <1>基本数据类型：byte,short,int,long,float,double,char <2>引用数据类型：对象，数
Java泛型大全
weixin_45203607的博客
10-02 4370
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
Java的泛型（参数化类型）
热门推荐
花未央D8023的博客
05-30 7万+
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、
基本数据类型泛型_Java泛型详解，通俗易懂只需5分钟
weixin_36381252的博客
01-21 1349
我们知道，使用变量之前要定义，定义一个变量时必须要指明它的数据类型，什么样的数据类型赋给什么样的值。假如我们现在要定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串，例如：x = 10、y = 10x = 12.88、y = 129.65x = "东京180度"、y = "北纬210度"针对不同的数据类型，除了借助方法重载，还可以借助自动装箱和向上转型。我们知道，基本数据类型可以自动...
Java之泛型 再学习 为什么泛型会报错？为什么需要包装类？为什么又要有基本数据类型？
KAKA的博客
03-25 1453
话说 KK 今日遇到了泛型，当 KK 想将泛型改为基本数据类型的时候，编译器报错了。 咦？这是为什么？为什么会报错？—— KK 很疑惑 原来，泛型必须是包装类类型，也就是只能代表引用类型，而不能是基本数据类型，也就是不能是原始数据类型，比如 long / int / short / byte / double / float / boolean / char ，这些都是不能被引用了。 噢~...
Java 基础知识——泛型
敲代码的小李同学的博客
07-07 1894
泛型概念及应用，包括泛型类、接口、方法，通配符，泛型限定的应用，最后是泛型的局限性。
为什么泛型类的类型不能是基本数据类型
淡定我咔的博客
11-20 1万+
1.泛型的定义：在程序中我们将一个对象放入集合中，但是集合不会记住对象的类型，当我们在次使用对象的时候，对象变为Object类型，而程序中还是原来的类型，我们必须要自己转换其类型，为了解决这个问题，则提出泛型。 2.泛型要求包容的是对象类型，而基本数据类型在Java中不属于对象。但是基本数据类型有其封装类，且为对象类型。 3.想放int类型，要放Integer类型不能直接放int（基本数据类型...
泛型类的类型为什么不能是基本
pengzhisen123的博客
11-06 4693
1、泛形要求能包容的是对象类型，而基本类型在java里不属于对象。 但是基本类型都有其包装类型，也就是对象类型： int->Integer long->Long ....... 2、java, 泛型问题，就是<>里面可以填写哪些类型？  想放int的话要写integer，不能光一个int的，int 是基本数据类型，Integer是其包装类，注意是一个类
python的练习题2
10-16
python的练习题2
行人重识别-用于行人重识别的稀疏标签平滑正则化优化-附项目源码+流程教程-优质项目实战.zip
10-16
行人重识别_用于行人重识别的稀疏标签平滑正则化优化_附项目源码+流程教程_优质项目实战
php语言基础（精编版65页ppt）.pdf
10-16
php语言基础（精编版65页ppt）.pdf
9217968970910743X8.5CM模板 横.psd
最新发布
10-16
9217968970910743X8.5CM模板 横.psd
Datawhale精彩SQL项目复制和学习笔记.zip
10-16
Datawhale精彩SQL项目复制和学习笔记
毕业设计论文SpringBoot+Vue川剧科普平台.docx
10-16
毕业设计论文
java获得集合的泛型类型_Java集合之泛型类和泛型接口
06-01
Java中可以通过反射来获得集合的泛型类型。具体的实现方法是通过获取集合的Class对象，然后获取该Class对象上的泛型信息。 以List为例，假设我们有一个List类型的集合，可以使用以下代码获取该集合的泛型类型： ``...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值