企业官网建设流程全解析

前言：Java中的常用类主要提供了广泛的工具和功能，用于简化开发任务，处理常见的编程需求。前面我们已经介绍过String类的一些基本使用方法，接下来我们再介绍一些其它常用类的使用，本文主要介绍以包装类Integer为例、Math类、Random类。后续再介绍其它常用类。

包装类

引入

【1】什么是包装类：
以前定义变量，经常使用基本数据类型，
对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，将基本数据类型对应进行了一个封装，产生了一个新的类，---》包装类。
int,byte.....--->基本数据类型
包装类--->引用数据类型

【2】对应关系：
基本数据类型 对应的包装类 继承关系
byte Byte ---》Number---》Object
short Short ---》Number---》Object
intInteger---》Number---》Object
long Long ---》Number---》Object
float Float ---》Number---》Object
double Double ---》Number---》Object
charCharacterObject
boolean Boolean Object

【3】已经有基本数据类型了，为什么要封装为包装类？
（1）java语言 面向对象的语言，最擅长的操作各种各样的类。
（2）以前学习装数据的---》数组，int[] String[] double[] Student[]
以后学习的装数据的---》集合，有一个特点，只能装引用数据类型的数据
【4】是不是有了包装类以后就不用基本数据类型了？
不是。
对于集合来说要用包装类(引用数据类型)。
对于一般的类Student等只需要用基本数据类型，更简洁方便。

以Integer为例

【1】直接使用，无需导包：

【2】类的继承关系：

【3】实现接口：

【4】这个类被final修饰，那么这个类不能有子类，不能被继承：

【5】包装类是对基本数据类型的封装： 对int类型封装产生了Integer

【6】类的历史：

【7】属性：

/** * @Auther: themyth */ public class Test01 { //这是一个main方法，是程序的入口： public static void main(String[] args) { //属性： System.out.println(Integer.MAX_VALUE);//2147483647 System.out.println(Integer.MIN_VALUE);//-2147483648 //“物极必反”原理： System.out.println(Integer.MAX_VALUE+1);//-2147483648 System.out.println(Integer.MIN_VALUE-1);//2147483647 } }

【8】构造器（发现没有空参构造器）

（1）int类型作为构造器的参数：

/** * @Auther: themyth */ public class Test02 { //这是一个main方法，是程序的入口： public static void main(String[] args) { Integer integer = new Integer(12); System.out.println(integer.toString());//12 System.out.println(new Integer(13));//13 } }

（2）String类型作为构造器的参数：

【9】包装类特有的机制：自动装箱 自动拆箱：

/** * @Auther: themyth */ public class Test03 { //这是一个main方法，是程序的入口： public static void main(String[] args) { //自动装箱：int---》Integer Integer i = 12; System.out.println(i); //自动拆箱：Integer---》int Integer i2 = new Integer(12); int num = i2; System.out.println(num); } }

（1）自动装箱 自动拆箱 是从JDK1.5以后新出的特性
（2）自动装箱 自动拆箱 ：将基本数据类型和包装类进行快速的类型转换。

验证：

可以自定打断点测试是否走入valueOf方法中：

【10】常用方法：

valueOf方法的底层：

import org.omg.CORBA.INTERNAL; /** * @Auther: themyth */ public class Test04 { //这是一个main方法，是程序的入口： public static void main(String[] args) { //compareTo:只返回三个值：0，-1，1 Integer i1 = new Integer(6); Integer i2 = new Integer(12); System.out.println(i1.compareTo(i2));//return (x < y) ? -1 : ((x == y) ? 0 : 1); //equals：Integer对Object中的equals方法进行了重写，比较的是底层封装的那个value的值。 //Integer对象是通过new关键字创建对象： Integer i3 = new Integer(12); Integer i4 = new Integer(12); System.out.println(i3 == i4);//false 因为比较的是两个对象的地址 boolean flag = i3.equals(i4); System.out.println(flag); //Integer对象通过自动装箱来完成： Integer i5 = 12; Integer i6 = 12; System.out.println(i5.equals(i6));//true System.out.println(i5 == i6);//true Integer i7 = 128; Integer i8 = 128; System.out.println(i7.equals(i8));//true System.out.println(i7 == i8);//false Integer i9 = -129; Integer i10 = -129; System.out.println(i9.equals(i10));//true System.out.println(i9 == i10);//false /** 如果自动装箱在-128~127之间，那么比较的就是具体的数值 否则比较的就是对象的地址 */ //intValue()的作用：将Integer--->int Integer i11 = 130; int i = i11.intValue(); System.out.println(i); //parseInt(String s)：String--->int int i12 = Integer.parseInt("12"); System.out.println(i12); //toString：Integer--->String Integer i13 = 13; System.out.println(i13.toString()); } }

Math类

【1】直接使用，无需导包：

【2】final修饰类，这个类不能被继承：

【3】构造器私有化，不能创建Math类的对象：

不能：

【4】Math内部的所有的属性，方法都被static修饰：类名.直接调用，无需创建对象：

【5】常用方法：

/** * @Auther: themyth */ public class Test01 { //这是一个main方法，是程序的入口： public static void main(String[] args) { //常用属性： System.out.println(Math.PI); //常用方法： System.out.println("随机数："+Math.random());//[0.0,1.0) System.out.println("绝对值："+Math.abs(-80)); System.out.println("向上取值："+Math.ceil(9.1)); System.out.println("向下取值："+Math.floor(9.9)); System.out.println("四舍五入："+Math.round(3.5)); System.out.println("取大的那个值："+Math.max(3, 6)); System.out.println("取小的那个值："+Math.min(3, 6)); } }

【6】静态导入：

//静态导入： import static java.lang.Math.*; /** * @Auther: themyth */ public class Test01 { //这是一个main方法，是程序的入口： public static void main(String[] args) { //常用属性： System.out.println(PI); //常用方法： System.out.println("随机数："+random());//[0.0,1.0) System.out.println("绝对值："+abs(-80)); System.out.println("向上取值："+ceil(9.1));//天花板 System.out.println("向下取值："+floor(9.9));//地板 System.out.println("四舍五入："+round(3.5)); System.out.println("取大的那个值："+max(3, 6)); System.out.println("取小的那个值："+min(3, 6)); } //如果跟Math中方法重复了，那么会优先走本类中的方法（就近原则）： public static int random(){ return 100; } }

随机数案例：

在java中依靠一个类：Math类帮助我们生成，这个类中有一个方法专门用来生成随机数：

Math.random() -------> [0.0,1.0)
Math.random()*6 ----->[0.0,6.0)
(int)(Math.random()*6) ----->[0,5]
(int)(Math.random()*6) +1 ----->[1,6]
应用到程序中：

int num = (int)(Math.random()*6) +1;

练习：
[32,98] -----> [0,66]+32 ----> (int)(Math.random()*67)+32
[-100,200] -----> [0,300] +(-100) ----> (int)(Math.random()*301)-100

Random类

/** * @Auther: themyth */ public class Test02 { //这是一个main方法，是程序的入口： public static void main(String[] args) { //返回带正号的double值，该值大于等于0.0且小于1.0 System.out.println("随机数："+Math.random()); //学习Random类 //（1）利用带参数的构造器创建对象： Random r1 = new Random(System.currentTimeMillis()); int i = r1.nextInt(); System.out.println(i); //（2）利用空参构造器创建对象： Random r2 = new Random();//表面是在调用无参构造器，实际底层还是调用了有参构造器 System.out.println(r2.nextInt(10));//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。 System.out.println(r2.nextDouble());//返回一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。 } }

Math.random()和Random类的区别

Math.random()和Random类都是用于生成随机数的工具，但它们的使用方式和功能略有不同。以下是它们的主要区别：

Math.random()

• 定义:Math.random()是一个静态方法，属于java.lang.Math类。
• 返回值: 生成一个在[0.0, 1.0)范围内的double型随机数，即大于等于 0.0 且小于 1.0。
• 种子控制: 不能显式设置种子。它使用一个全局的种子，无法手动控制或重置，因此随机序列不可重复生成。
• 常见用途: 简单的随机数生成需求，例如生成一个随机的小数或通过乘法生成指定范围内的整数。
• 示例代码:

double randomValue = Math.random(); // 返回 0.0 到 1.0 之间的随机数 int randomInt = (int) (Math.random() * 10); // 返回 0 到 9 之间的随机整数

Random类

• 定义:Random是java.util包中的一个类，需要先创建Random类的实例。
• 返回值: 可以生成不同类型的随机数，如int、long、float、double、boolean等，还可以生成指定范围内的随机数。
• 种子控制: 可以在创建Random对象时指定种子值，这样每次使用相同的种子值时，生成的随机数序列都是相同的，便于测试和重现。
• 多功能性: 提供更多功能，如生成高效的随机整数、长整型数字、布尔值等。可以生成指定范围内的随机数。
• 示例代码:

  Random random = new Random(); int randomInt = random.nextInt(); // 返回任意整数 int randomIntWithinRange = random.nextInt(10); // 返回 0 到 9 之间的随机整数 double randomDouble = random.nextDouble(); // 返回 0.0 到 1.0 之间的随机 double 数 boolean randomBoolean = random.nextBoolean(); // 返回 true 或 false 的随机值

总结

• Math.random(): 简单易用，适合快速生成[0.0, 1.0)范围内的随机double值。
• Random类: 更加灵活且功能丰富，适合需要生成不同类型或特定范围随机数的场景，并支持通过种子值生成可重复的随机序列。