JAVASE的学习笔记（五）（包装类与泛型）

最新推荐文章于 2022-07-04 13:30:46 发布
最新推荐文章于 2022-07-04 13:30:46 发布
阅读量106 收藏
点赞数
分类专栏： JavaSe学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47267252/article/details/114945167
版权

JAVASE的学习笔记（五）

包装类

为什么需要包装类

Java设计之初由一个基本原则：一切皆对象（先有类才有对象），一切的操作都是需要用对象的形式进行描述。

但是出现不是对象“东西”，基本数据类型不是对象，无法使用对象的形式来进行操作

创建对象之后，那么我们可以通过.运算符调用响应的属性和行为，操作基本数据类型也想使用对象的形式？

代码

public class Demo01{
    public static void main(String...args){
        int num = 100;
        //将基本数据类型int包装成temp的对象
        Int temp = new Int(100);
        //使用包装后的对象，调用行为或者属性
        temp.m1();
        
        //从对象中取得了基本数据
        int result = temp.intValue();
        System.out.println("result="+result);
    }
}
/**
* 实现基本数据类型int的包装类
*/
public class Int{
    private int number;
    
    public Int(int number){
        this.number = number;
    }
    
    public void m1(){
        System.out.println("number="+number);
    }
    //获取包装类中的数据
    public int intValue(){
        return this.number;//可以省略this
    }
}

系统包装类

在这里插入图片描述

数据类型转换（核心）★★

字符串java.lang.String和基本数据类型之间的转换

  • Integer类： public static int parseInt(String s) : Integer.parseInt(String s)
  • Double类： public static double parseDouble(String s)
  • Boolean类： `public static boolean parseBoolean(String s)
  • Character包装没有

包装类的使用

  • 装箱操作:将基本数据类型变成包装类，每个包装类的构造方法都可以接收各自数据类型的变量
  • 拆箱操作：从包装类中提取出包装的数据（基本数据类型），利用Number类提供的上述六个方法
    自动装箱拆箱：
public class Demo05{
    public static void main(String...args){
       Integer obj = 11;//自动装箱 int->Integer，不需要我们在使用构造方法了
       int temp = obj;//自动拆箱 Integer->int 实际上底层调用obj.intValue()方法
       //包装类可以进行计算
       obj++;//自动拆箱过程 obj->int
       System.out.println(obj);//自动装箱 int->Integer
       System.out.println(temp*obj);//自动拆箱Integer->int
    }
}

泛型

概念：泛型就是参数化的类型（传递），使用广泛的类型

使用泛型的原因？

数据类型不明确

  • 装入数据的类型（赋值）都被处理Object类型，从而“失去”了自己实际的类型
  • 往往我们在获取数据的时候，还需要转换数据类型，效率低下，并且十分容易产生错误

泛型的作用？

  • 安全性：在编译期间就检查数据类型是否安全（是否匹配）
  • 省心（高效性）：所有的强制类型转换都是变成自动（隐藏）的，提高了代码的重用率

如何定义泛型？

定义格式：使用<任意的字母>符号

泛型中常用的字母含义（约定）

  • T ： Type表示类型
  • K,V : 代表键值对Key和Value
  • E：代表Element
  • N：代表Number数字
  • ?：表示不确定性

泛型的使用规则

（1）不能使用静态属性上，static修饰的不能使用泛型★★★

（2）使用的时候需要指定数据类型：
　　　　a.编译的时候会检查数据的类型
　　　　b.获取数据的时候不再需要强制类型转换

（3）泛型使用是不能指定基本数据类型，只能使用基本数据类型对应的包装类

使用泛型定义接口，我们称之为泛型接口，因为泛型中只能由公共的抽象方法和静态的公共常量（不能使用泛型 。接口中，泛型字母只能使用在方法中，不能使用在全局变量中 因为接口只包括全局常量和公共、抽象方法，而全局变量是static的，所以不能用，所以只能用在方法中），JDK8之后可以定义普通的默认方法和静态的默认方法

泛型的使用范围

（1）泛型类：public class Student01<T1,T2>
（2）泛型接口

public interface Info<T>{
    T getVar();
    void setVar(T value);
}

a.非泛型类实现接口：声明的子类实现接口必须指定“具体的类型”

public class InfoImpl01 implements Info<Double>{   
    private Double var;
    
    public Double getVar(){
        return var;
    }
    
    public void setVar(Double var){
        this.var = var;
    }

}

public class Demo05{
    public static void main(String[] args){
        //Info<String> info = new InfoImpl01();
        
        Info<Double> info = new InfoImpl01();
        info.setVar(123.456);
        System.out.println(info.getVar().getClass());
              
    }
}

b.泛型类实现接口

public class InfoImpl02<U> implements Info<U>{   
    private U var;
    
    public U getVar(){
        return var;
    }
    
    public void setVar(U var){
        this.var = var;
    }

}

（3）泛型方法：没有使用泛型类，也没有使用泛型接口，直接在方法上使用泛型

public class FunsTest{
   
   //普通方法
   public <T> int test01(T num){
       System.out.println(num);
       System.out.println(num.getClass());
       return 100;
   }
   public <T> T test02(T num){
       System.out.println(num);
       System.out.println(num.getClass());
       return num;
   }
   //静态方法
   public static <T> String test03(T num){
       System.out.println(num);
       System.out.println(num.getClass());
       return "悟空";
   }
   public static <T> T test04(T num){
       System.out.println(num);
       System.out.println(num.getClass());
       return num;
   } 
}

public class Demo06{
    public static void main(String[] args){
       FunsTest ft = new FunsTest();
       ft.test01("悟空");//没有在编译期间检查数据的类型
       //会自动将<T>自动变成String,数据决定泛型的类型
       //编译不会产生错误
       /**不符合规范的，但是是推荐使用*/
       
       //标准写法，不推荐使用
       ft.<Integer>test01("八戒");//编译检查了数据类型
              
    }
}

（4）泛型数组
private T[] array ;//只能声明，不能创建

public class Demo07{
   public static void main(String[] args){
       Dog<String> dog = new Dog<>();
       
       Integer[] temp = m1(1,2,3,4);
       System.out.println(java.util.Arrays.toString(temp));
       
       String[] temp01 = m1("悟空","八戒");
       System.out.println(java.util.Arrays.toString(temp01));
       
   }
   
   public static <T> T[] m1(T...array){
       return array;
   }
}
class Dog<T>{
  // private T[] array = new T[10];//不能创建
   private T[] array ;//只能声明
   

}
泛型类型之间不存在转换，没有所谓的对象上转型，接口回调
  1. Student无法转换为Student<0bject>
public class Demo01 {
public static void main(String.. . args){
	Student<String> s1 = new Student<>();
	s1. setMath("良好”);
	s1. setEnglish("中等");
	//s1数据就可以传递了
	//调用m1方法Student<String>->Student<0bject>
	//泛型类型之间转换?
	m1(s1);
	//错误:不兼容的类型: Student<Str ing>无法转换为Student<0bject>
	}
public static void m1 (Student<0bject> temp){
	System . out . println(" temp=”+temp) ;
	}
}

2.修改代码，将m1中的泛型不指定类型，不指定T就是Object,这种情况违背了使用泛型的意图，丢失了原本的类型，又需要判断类型进行强转

public class Demo02{
    public static void main(String...args){
        Student<String> s1 = new Student<>();
        s1.setMath("良好");
        s1.setEnglish("中等");
        //s1数据就可以传递了
        m1(s1);
        
        
    }
    //Student不写泛型的范围比Student<Object>范围大
    public static void m1(Student temp){
        //不兼容的类型: Object无法转换为String
        //又丢失了你原本的类型，我们又需要判断类型进行强转
        String math = temp.getMath();
        System.out.println("temp="+temp);
    }
}
  1. ? 通配符：根据你传递的泛型变化而变化
受限的泛型（限定泛型）
  • 上限限定使用extends关键字，表示这个类型必须是继承某个类或者实现某个接口，也可以是该类的本身或接口的本身
public class Person<T extends Number>
  • 下限限定使用super关键字，表示类型是某个类的父类或者是某个接口的父接口，也可以是这个类的接口本身
public class Person<T super Number>//错误：下限限定使用super关键字，不能使用在泛型类和泛型接口中
  • 下限限定使用super关键字，不能使用在泛型类和泛型接口中，一般我们使用在泛型的方法传递中
public static void m1(Person<? super Double> temp){
        System.out.println(temp);
    }

泛型擦除规则

  • 声明实现类，实现的接口必须指定"具体的类型"
    class Service01 implements UserService<String>{}

  • 实现类和接口同时擦除（不写），使用Object
    class Service02 implements UserService{
    public void add(Object t){}}

  • 实现类是泛型，实现的接口擦除，使用Object
    class Service03<T> implements UserService{
    public void add(Object t){}}

  • 实现类是泛型,实现的接口泛型，泛型相等
    class Service04<U> implements UserService<U>{
    public void add(U t){}}

  • 错误：实现类擦除，接口泛型

public interface UserService<T>{
    void add(T t);
}
//声明实现类，实现的接口必须指定"具体的类型"
class Service01 implements UserService<String>{
    public void add(String t){
        
    }
}
//实现类和接口同时擦除（不写），使用Object
class Service02 implements UserService{
    public void add(Object t){
        
    }
}
//实现类是泛型，实现的接口擦除，使用Object
class Service03<T> implements UserService{
    private T value;
    
    public void add(Object t){
        
    }
}
//实现类是泛型,实现的接口泛型，泛型相等
class Service04<U> implements UserService<U>{
    public void add(U t){
        
    }
}
class Service05<X,Y,Z> implements UserService<Y>{
    public void add(Y t){
        
    }
}
//错误：实现类擦除，接口泛型
/*
class Service06 implements UserService<Y>{
    public void add(Y t){
        
    }
}
*/
月色夜雨
关注
专栏目录
JAVASE学习笔记
qq_46628467的博客
06-13 445
javaSE
javaSE基础学习笔记 day18 泛型 通配符 File类
yu1590的博客
07-29 215
javaSE基础学习笔记 day18泛型 （JDK 5.0新特性）泛型类 接口泛型方法泛型在继承方面的体现通配符的使用：？File 类及其使用。 泛型 （JDK 5.0新特性） 在集合中使用泛型： 集合接口或集合类在 JDK 5.0 时都修改为带泛型的结构。 在实例化集合时，可指明具体的的泛型类型。 指明类型后，在集合接口或集合类中凡是定义的类或接口时，内部结构（如方法，属性，构造器）使用到泛型的位置，都指为实例化时指定的泛型类型。 泛型类型必须是类，基本数据类型用包装类来代替。 若不指定泛型类型，则默认
利用C#反射机制，将type作为泛型T传入方法
02-24 2596
利用C#反射机制，将type作为泛型T传入方法
JavaSE学习笔记(六)：泛型
weixin_46476301的博客
04-18 228
目录 一、泛型的概念 二、泛型的设计背景 三、泛型的使用 注意点 泛型在继承上的体现 通配符的基本使用 总结 一、泛型的概念 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。 从JDK1.5以后，Java引入了“参数化类型(Parameterized type)”的概念，允许我们在创建集合时再指定集..
JavaSE学习笔记(10.Java泛型)
qq418674358的专栏
07-05 177
1. 泛型类的使用： public class GenericTypeTest { public static void main(String args[]) { /*1.泛型类实例化，t1实例和t2实例分别制定泛型类型为String和Integer*/ /*2.泛型目的就是，通过编译检查，保证t1实例的所有的泛型操作都满足T为String，t2实例的所有的泛型操作都满足T...
JavaSE笔记（四）泛型与集合类
qq_25928447的博客
10-20 3649
Java泛型与集合类 在前面我们学习了最重要的类和对象，了解了面向对象编程的思想，注意，非常重要，面向对象是必须要深入理解和掌握的内容，不能草草结束。在本章节，我们会继续深入了解，从我们的泛型开始，再到我们的数据结构，最后再开始我们的集合类学习。 走进泛型 为了统计学生成绩，要求设计一个Score对象，包括课程名称、课程号、课程成绩，但是成绩分为两种，一种是以优秀、良好、合格 来作为结果，还有一种就是 60.0、75.5、92.5 这样的数字分数，那么现在该如何去设计这样的一个Score类呢？现在的问题就是
JavaSE笔记-泛型与集合类
a35065521的博客
05-06 801
JavaSE笔记-泛型与集合类 在前面我们学习了最重要的类和对象，了解了面向对象编程的思想，注意，非常重要，面向对象是必须要深入理解和掌握的内容，不能草草结束。在本章节，我们会继续深入了解，从我们的泛型开始，再到我们的数据结构，最后再开始我们的集合类学习。 走进泛型 为了统计学生成绩，要求设计一个Score对象，包括课程名称、课程号、课程成绩，但是成绩分为两种，一种是以优秀、良好、合格 来作为结果，还有一种就是 60.0、75.5、92.5 这样的数字分数，那么现在该如何去设计这样的一个Score类呢？现在
JavaSe学习笔记
MinQo的博客
07-04 2103
JavaSe学习笔记
JAVASE深度学习笔记 - - 泛型使用详解
qq_37779333的博客
08-12 261
泛型 所谓泛型就是变量类型的参数化，简单来理解就是（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 从使用的角度来讲的话就是，为了提高安全性，使用泛型的基础之上程序编译期间没有问题的话，那么执行期间一定没有问题，看下边这个例子； 在这里...
传智播客视频JavaSE学习笔记
12-20
以上是根据传智播客视频JavaSE学习笔记总结的关键知识点，覆盖了Java基础环境配置、字符串操作、多线程编程、集合框架、输入输出流、网络编程、反射机制、正则表达式等多个方面，希望对Java初学者和进阶者有所帮助。
javase基础学习笔记
10-08
首先，我们从“javase学习笔记”开始。这部分内容可能涵盖了以下几个关键知识点： 1. **环境配置**：安装JDK（Java Development Kit），设置环境变量如JAVA_HOME、PATH和CLASSPATH，确保能够正确运行Java程序。 2....
javaSE基础笔记
10-19
### JavaSE基础知识点详解 #### 一、JavaSE概述与集成开发环境（IDE） - **JavaSE**: Java Standard Edition 的缩写...以上总结了JavaSE基础学习中涉及的一些关键概念和技术点，希望对正在学习Java的朋友们有所帮助。
JAVASE学习笔记（十三）（jdk新特性（AutoCloseable接口 & Stream流））
qq_47267252的博客
12-17 1575
JavaSe学习笔记（十四）Java7新特性 - `AutoCloseable`1. 概述2. 应用场景示例如何解决改进注意 Java7新特性 - AutoCloseable 1. 概述 JDK在1.7之后出现了自动关闭类的功能，该功能的出现为各种关闭资源提供了相当大的帮助，这里我们谈一谈自动关闭类。 JDK1.7之后出现了一个重要的接口，以及改造了一个重要的方法结构： AutoCloseable自动关闭接口 try(){}–catch{}–finally{} 相应的 一些资源也实现了该接口，如P
JAVASE学习笔记（十六）（Optional的应用）
qq_47267252的博客
01-04 1029
jdk1.8新特性的应用 概述 作用 简化程序逻辑 可以修复程序代码中的逻辑判断的问题 源码分析 通过源码分析 ，可以知道是一个， 2. : 相当于 3. :相当于 4. :相当于 应用 ：和 场景：当用户第一次注册给其设置默认昵称和密码： 总结 和区别 问题： 为什么方法会报 由此我们发现：方法如果传入的对象为null，就直接返回 而源码则是当传值为空的时候，直接给创建一个空对象： 中 ,,的认识 注意： ,,都属于的中间方法。但此处的方法与之前的流中间方法无关
JAVASE学习笔记（十五）（行为参数化 & 策略者模式 &匿名内部类 & Lambda表达式）
qq_47267252的博客
12-28 988
JAVASE学习笔记（十五）问题行为参数化标准建模总结问题匿名内部类匿名内部类简述如何选择匿名内部类或实现类解决需求（==重点==）函数式接口总结Lambda表达式 此文为学相伴项目课程笔记 问题 在实际应用场景中，不管你做什么，怎么优化，用户需求总是在不断变化 那么，在理想状态下，应该把自己的开发的工作量降到最小？ 此外类似的功能还应该很简单，而且易于长期维护 所以要如何做？ 此处我们可以引出行为参数化 行为参数化 行为参数化：就是可以帮助你处理频繁变更的需求的一种软件开发模式。 简单来说，就是准
JAVASE学习笔记（十四）（stream流===＞ 结果映射 & 数据处理 &查找检索 ）
qq_47267252的博客
12-20 627
JAVASE学习笔记（十三.2）map & peek & flatmap（结果映射）场景peek解决：map解决flatMap解决flatMap与map区别flatMap语法：map语法结论flatmap的使用1.合并-并集 & 返回指定列2. 合并-交集-共同好友3. 合并-差集reduce（数据处理）概述语法案例其他的操作maptoInt、maptoDouble、maptoLong查找检索 map & peek & flatmap（结果映射） 场景 场景： 把集
JAVASE学习笔记 （十）（异常）
qq_47267252的博客
03-28 548
JAVASE学习笔记 （十）异常体系结构ErrorExceptionError和Exception的区别:异常的演示异常处理机制自定义异常总结 异常体系结构 Java中把异常当成对象来处理，并且定义了一个基类java.long.Throwable作为素有异常的超类 在Java API中已经定义了许多异常类.这些异常分为两大类： 错误：Error 主要是jvm（Virtual MachineError）错误和awt错误（GUI编程） 异常：Exception IO异常，Runtime异常等等 Err
JAVA基础总结
qq_47267252的博客
06-26 433
加载程序到JVM中的时机：静态成员是放在堆中，是共享数据。所以当线程并发时容易出现数据安全问题。非静态成员及实例变量还有成员变量，他们在被使用的时候会有入栈和出栈的过程。局部变量会会在每个线程入栈的时候创建的各自的局部变量表内。 成员变量则是在创建对象，申请堆内存的时候，在每个对象的堆空间的局部变量表中 所以，通常不被太多次改变的数据将其用static修饰为静态成员。被多次改变的，不用static== 一个类有了继承，才会有多态的概念== 关键字就是为了给父类私有属性赋值。 继承就是为了去拿一些东西，去拓展
JavaSE学习笔记：核心概念与单例模式解析
"这是一篇关于JavaSE学习的...JavaSE的学习不仅涉及语法和基础概念，还包括面向对象的设计原则、多态性、抽象类与接口的使用，以及设计模式的应用。理解并熟练掌握这些知识点，是成为一名合格的Java开发者的关键步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月色夜雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值