12_常用类的概述和使用
目录
Object类的概念和构造方法
- java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间
接子类。 - 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类。
- Object类定义了“对象”的基本行为, 被子类默认继承。
Student.java:
package cn.itcast.day01.demo18;
//手动引入Objects类
import java.util.Objects;
public class Student {
private String name;
private int id;
//无参构造方法
public Student() {
}
//有参构造方法
public Student(String name, int id) {
setName(name);
setId(id);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
//重写父类Objects的equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true; //如果对象o与本当前调用对象相同则返回true
if (o == null || getClass() != o.getClass()) return false; //如果对象o为空 且 与当前调用对象所属类别不同 则返回false
Student student = (Student) o; //把对象o强制转换为Student对象
return id == student.id && Objects.equals(name, student.name); //判断两个对象的id和姓名是否完全一致,返回判断结果
}
@Override
public int hashCode() {
return Objects.hash(name, id); //根据id和name返回两者的哈希值
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
}
StudentTest.java:
package cn.itcast.day01.demo18;
public class StudentTest {
public static void main(String[] args) {
Student st1 = new Student("guanyu", 1002);
Student st2 = new Student("zhangfei", 1003);
Student st3 = new Student("zhangfei", 1003);
boolean b1 = st1.equals(st2);
boolean b2 = st2.equals(st3);
boolean b3 = st2 == st3;
System.out.println("b1 = " + b1);
System.out.println("b2 = " + b2);
System.out.println("b3 = " + b3);
System.out.println("------------------------------------------");
int ia = st1.hashCode();
int ib = st2.hashCode();
int ic = st3.hashCode();
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
System.out.println("ic = " + ic);
System.out.println("------------------------------------------");
String str1 = st1.toString();
System.out.println("str1 = " + str1);
System.out.println(str1); //当打印一个引用变量时会自动调用toString方法
String str2 = "Hello " + str1;
System.out.println("str2 = " + str2);
}
}
编译并执行StudentTest.java:
b1 = false
b2 = true
b3 = false
------------------------------------------
ia = 366189716
ib = -1461449906
ic = -1461449906
------------------------------------------
str1 = Student{name='guanyu', id=1002}
Student{name='guanyu', id=1002}
str2 = Hello Student{name='guanyu', id=1002}
包装类的概念和分类
包装类的概念
通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。
Person p = new Person();
int num = 10;
| 包装类 | 对应的基本类型 |
|---|---|
java.lang.Byte |
byte |
java.lang.Short |
short |
java.lang.Integer |
int |
java.lang.Long |
long |
java.lang.Float |
float |
java.lang.Double |
double |
java.lang.Boolean |
boolean |
java.lang.Character |
char |
Integer类的概述
基本概念:java.lang.Integer类内部包装了一个int类型的变量作为成员变量,主要用于实现对int类型的包装并提供int类型之间的转换等方法.
常用的变量
| 常量类型和名称 | 功能介绍 |
|---|---|
public static final int MAX_VALUE |
表示int类型可以描述的最大值,即2^31-1 |
public static final int MIN_VALUE |
表示int类型可以描述的最小值,即-2^31 |
public static final int SIZE |
表示int类型采用二进制补码形式的位数 |
public static final int BYTES |
表示int类型所占的字节个数 |
public static final Class TYPE |
表示int类型的Class实例 |
Integer类的概念和构造方式/装箱拆箱机制/自动装箱池
package cn.itcast.module2.demo01;
public class IntegerTest {
public static void main(String[] args) {
//1.打印Integer类中常用的的常量数值
System.out.println("最大值是:" + Integer.MAX_VALUE);
System.out.println("最小值是:" + Integer.MIN_VALUE);
System.out.println("所表示的二进制的位数是:" + Integer.SIZE);
System.out.println("所占字节的个数是:" + Integer.BYTES);
System.out.println("对应int类型的Class实例是:" + Integer.TYPE);
System.out.println("-------------------------------------------------");
//2.使用构造方法来构造Integer类型的对象并打印
Integer it3 = Integer.valueOf("123"); //将String类型转换为Integer类型
System.out.println("it3 = " + it3);
//获取调用对象中的整数数值,相当于从Integer类型到int类型的转换
int ia = it3.intValue(); // 获取调用对象的整数数值,相当于从Integer类型到int类型的转换,叫做拆箱
System.out.println("获取到的整数数据是: " + ia);
System.out.println("-------------------------------------------------");
Integer it4 = 789; // 直接通过赋值运算自动装箱
int it5 = it4; // 直接通过赋值运算自动拆箱
System.out.println("it4 = " + it5);
System.out.println("-------------------------------------------------");
//4.装箱拆箱的笔试考点
Integer it6 = 128;
Integer it7 = 128;
Integer it8 = new Integer(128);
Integer it9 = new Integer(128);
System.out.println(it6 == it7); //比较地址 false
System.out.println(it6.equals(it7)); //比较内容 true
System.out.println(it8 == it9); //比较地址 false
System.out.println(it8.equals(it9)); //比较内容 true
System.out.println("============");
Integer it10 = 127;
Integer it11 = 127;
Integer it12 = new Integer(127);
Integer it13 = new Integer(127);
System.out.println(it10 == it11); //比较地址 true
System.out.println(it10.equals(it11)); //比较内容 true
System.out.println(it12 == it13); //比较地址 false
System.out.println(it12.equals(it13)); //比较内容 true
//以上 it10 与 it11 的比较结果验证了"自动装箱池"的概念
/**
* 自动装箱池:
* 在Integer类的内部提供了自动装箱池技术,
* 将-128到127之间的整数已经装箱完毕,
* 当程序中使用该范围之间的整数时,
* 无需装箱直接取用自动装箱池中的对象即可,
* 从而提高效率.
*/
System.out.println("-------------------------------------------------");
//5.实现静态方法的调用
System.out.println("字符串转换为整数的结果是:" + Integer.parseInt("200"));
System.out.println("根据参数指定的整数获取对应的十进制字符串是:" + Integer.toBinaryString(200));
System.out.println("根据参数指定的整数获取对应的二进制字符串是:" + Integer.toBinaryString(200));
System.out.println("根据参数指定的整数获取对应的十六进制字符串是:" + Integer.toHexString(200));
System.out.println("根据参数指定的整数获取对应的八进制字符串是:" + Integer.toOctalString(200));
}
}
//执行结果
最大值是:2147483647
最小值是:-2147483648
所表示的二进制的位数是:32
所占字节的个数是:4
对应int类型的Class实例是:int
-------------------------------------------------
it3 = 123
获取到的整数数据是: 123
-------------------------------------------------
it4 = 789
-------------------------------------------------
false
true
false
true
============
true
true
false
true
-------------------------------------------------
字符串转换为整数的结果是:200
根据参数指定的整数获取对应的十进制字符串是:11001000
根据参数指定的整数获取对应的二进制字符串是:11001000
根据参数指定的整数获取对应的十六进制字符串是:c8
根据参数指定的整数获取对应的八进制字符串是:310
Double类的概述
基本概念: java.lang.Double类型内部包装了一个double类型的变量作为成员变量,主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法.
常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
public static final int SIZE |
表示double类型的二进制位数 |
public static final int BYTES |
表示double类型的字节个数 |
public static final Class<Double>TYPE |
表示double类型的Class实例 |
常用的方法
| 方法声明 | 功能介绍 |
|---|---|
Double(double value) |
根据参数指定的浮点数来构造对象(已过时) |
Double(String s) |
根据参数指定的字符串来构造对象(已过时) |
double doubleValue() |
获取调用对象中的浮点数据并返回 |
static Double valueOf(double d) |
根据参数指定浮点数据得到Double类型对象 |
boolean equals(Object obj) |
比较调用对象与参数指定的对象是否相等 |
String toString() |
返回描述调用对象数值的字符串形式 |
static double parseDouble(String s) |
将字符串类型转换为double类型并返回 |
boolean isNaN() |
判断调用对象的数值是否为非数字 |
扩展: java.lang.Number类是个抽象类,是上述类的父类来描述所有类共有的成员
DoubleTest.java
package cn.itcast.module2.demo01;
public class DoubleTest {
public static void main(String[] args) {
Double db1 = 3.14; //自动装箱
double db2 = db1; //自动拆箱
System.out.println("db1的数值是:" + db1.doubleValue());
//将字符串转换成double类型并返回
double db3 = Double.parseDouble("13.14");
System.out.println("字符串转换出的double数值是:" + db3);
}
}
//执行结果:
db1的数值是:3.14
字符串转换出的double数值是:13.14
Boolean类的概述
BooleanTest.java
package cn.itcast.module2.demo01;
public class BooleanTest {
public static void main(String[] args) {
Boolean bo1 = true; //自动装箱
boolean b1 = bo1; //自动拆箱
System.out.println("b1 = " + b1);
System.out.println("----------------------------------");
//字符串转换成Boolean类型的数据
boolean b2 = Boolean.parseBoolean("true");
boolean b3 = Boolean.parseBoolean("false");
boolean b4 = Boolean.parseBoolean("123");
System.out.println("b2 = " + b2); //true
System.out.println("b3 = " + b3); //false
System.out.println("b4 = " + b4); //false
}
}
Character类的概述
CharacterTest.java
package cn.itcast.module2.demo01;
public class CharacterTest {
public static void main(String[] args) {
Character ct1 = new Character('a'); //构造Character对象(已过时)
char ch1 = ct1.charValue(); //获取Character对象得到字符数据
System.out.println("ch1 = " + ch1);
System.out.println("-------------------------");
Character ct2 = Character.valueOf('b'); //根据指定字符数据得到Character类型的对象
boolean res = ct1.equals(ct2); //比较调用对象与参数对象是否相等
System.out.println(false == res ? "ct1不等于ct2" : "ct1等于ct2");
System.out.println("-------------------------");
Character ct3 = 'c'; //自动装箱
char ch3 = ct3; //自动拆箱
Character ct4 = 'D';
char ch4 = ct4;
System.out.println("ch3 = " + ch3); //自动调用toString()方法
System.out.println("ch4 = " + ch4); //自动调用toString()方法
System.out.println(Character.isUpperCase(ch3) ? "ch3是大写字母" : "ch3是小写字母");
System.out.println(Character.isLowerCase(ch3) ? "ch3是小写字母" : "ch3是大写字母");
System.out.println(Character.isDigit(ch3) ? "ch3是数字字符" : "ch3不是数字字符");
System.out.println("将ch3转换为大写字符为: " + Character.toUpperCase(ch3));
System.out.println("将ch3转换为小写字符为: " + Character.toLowerCase(ch3));
}
}
//执行结果
ch1 = a
-------------------------
ct1不等于ct2
-------------------------
ch3 = c
ch4 = D
ch3是小写字母
ch3是小写字母
ch3不是数字字符
将ch3转换为大写字符为: C
将ch3转换为小写字符为: c
包装类(Wrapper)的使用总结
- 基本数据类型转换为对应包装类的方式: 调用包装类的构造方法或静态方法即可
- 获取包装类对象中基本数据类型变量数值的方式: 调用包装类中的xxxValue方法即可
- 字符串转换为基本数据类型的方式: 调用包装类中的parseXxx方法即可
数学处理类
Math类的概述
基本概念: java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。
常用方法:
| 方法声明 | 功能介绍 |
|---|---|
static int max(int a, int b) |
返回两个参数中的最大值 |
static int min(int a, int b) |
返回两个参数中的最小值 |
static double pow(double a, double b) |
返回第一个参数的幂 |
static int abs(int a) |
返回参数指定数值的绝对值 |
static long round(double a) |
返回参数四舍五入的结果 |
static double sqrt(double a) |
返回参数的平方根 |
static double random() |
返回0.0到1.0的随机数 |
MathTest.java
package cn.itcast.module2.demo01;
public class MathTest {
public static void main(String[] args) {
System.out.println("两个参数中的最大值是: " + Math.max(10, 20));
System.out.println("两个参数中的最小值是: " + Math.min(10, 20));
System.out.println("第一个参数的幂是: " + Math.pow(2, 3));
System.out.println("参数的绝对值是: " + Math.abs(-6));
System.out.println("参数四舍五入的结果是: " + Math.round(3.48));
System.out.println("参数的平方根是: " + Math.sqrt(9));
System.out.println("0.0到1.0之间的一个随机数是: " + Math.random());
}
}
//执行结果
两个参数中的最大值是: 20
两个参数中的最小值是: 10
第一个参数的幂是: 8.0
参数的绝对值是: 6
参数四舍五入的结果是: 3
参数的平方根是: 3.0
0.0到1.0之间的一个随机数是: 0.9211356034418369
BigDecimal类的概述
BigDecimalTest.java
package cn.itcast.module2.demo01;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalTest {
public static void main(String[] args) {
//1.构造BigDecimal类型的两个对象
BigDecimal bd1 = new BigDecimal("5.2");
BigDecimal bd2 = new BigDecimal("1.3");
//2.使用构造完毕的对象实现加减乘除运算
System.out.println("实现加法运算的结果是: " + bd1.add(bd2));
System.out.println("实现减法运算的结果是: " + bd1.subtract(bd2));
System.out.println("实现乘法运算的结果是: " + bd1.multiply(bd2));
System.out.println("实现除法运算的结果是: " + bd1.divide(bd2));
System.out.println("----------------------------------");
//3.实现精确运算
System.out.println(0.1 + 0.2);
BigDecimal bd3 = new BigDecimal("0.1");
BigDecimal bd4 = new BigDecimal("0.2");
System.out.println("精确计算的结果是: " + bd3.add(bd4));
System.out.println("----------------------------------");
//4.注意事项
BigDecimal bd5 = new BigDecimal("2");
BigDecimal bd6 = new BigDecimal("0.3");
System.out.println("除法运算的结果是: " + bd5.divide(bd6, RoundingMode.HALF_UP));
}
}
BigDecimalTest.java
package cn.itcast.module2.demo01;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalTest {
public static void main(String[] args) {
//1.构造BigDecimal类型的两个对象
BigDecimal bd1 = new BigDecimal("5.2");
BigDecimal bd2 = new BigDecimal("1.3");
//2.使用构造完毕的对象实现加减乘除运算
System.out.println("实现加法运算的结果是: " + bd1.add(bd2));
System.out.println("实现减法运算的结果是: " + bd1.subtract(bd2));
System.out.println("实现乘法运算的结果是: " + bd1.multiply(bd2));
System.out.println("实现除法运算的结果是: " + bd1.divide(bd2));
System.out.println("----------------------------------");
//3.实现精确运算
System.out.println(0.1 + 0.2);
BigDecimal bd3 = new BigDecimal("0.1");
BigDecimal bd4 = new BigDecimal("0.2");
System.out.println("精确计算的结果是: " + bd3.add(bd4));
System.out.println("----------------------------------");
//4.注意事项
BigDecimal bd5 = new BigDecimal("2");
BigDecimal bd6 = new BigDecimal("0.3");
System.out.println("除法运算的结果是: " + bd5.divide(bd6, RoundingMode.HALF_UP));
}
}
//执行结果
实现加法运算的结果是: 6.5
实现减法运算的结果是: 3.9
实现乘法运算的结果是: 6.76
实现除法运算的结果是: 4
----------------------------------
0.30000000000000004
精确计算的结果是: 0.3
----------------------------------
除法运算的结果是: 7
BigInteger类的概念
基本概念: 若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述
常用方法:
| 方法声明 | 功能介绍 |
|---|---|
BigInteger(String val) |
根据参数指定的字符串来构造对象 |
BigInteger add(BigInteger val) |
用于实现加法运算 |
BigInteger subtract(BigInteger val) |
用于实现减法运算 |
BigInteger multiply(BigInteger val) |
用于实现乘法运算 |
BigInteger divide(BigInteger val) |
用于实现除法运算 |
BigInteger remainder(BigInteger val) |
用于实现取余运算 |
BigInteger[] divideAndRemainder(BigInteger val) |
用于实现取商和余数的运算 |
BigIntegerTest.java
package cn.itcast.module2.demo01;
import java.math.BigInteger;
public class BigIntegerTest {
public static void main(String[] args) {
BigInteger bi1 = new BigInteger("20");
BigInteger bi2 = new BigInteger("8");
System.out.println("实现加法运算结果是: " + bi1.add(bi2));
System.out.println("实现减法运算结果是: " + bi1.subtract(bi2));
System.out.println("实现乘法运算结果是: " + bi1.multiply(bi2));
System.out.println("实现除法运算结果是: " + bi1.divide(bi2));
System.out.println("实现取余运算结果是: " + bi1.remainder(bi2));
//一次性得到商和余数
BigInteger[] arr = bi1.divideAndRemainder(bi2);
System.out.println("bi1与bi2的商数是:" + arr[0] + ", 余数是:" + arr[1]);
}
}
//执行结果
实现加法运算结果是: 28
实现减法运算结果是: 12
实现乘法运算结果是: 160
实现除法运算结果是: 2
实现取余运算结果是: 4
bi1与bi2的商数是:2, 余数是:4
