学习目标
Object类
Date、DataFormat、Calendar
System类
StringBuilder
包装类
一、Object类
1、概述：Object类是所有类的父类、有些类直接继承Object、而另一些类间接继承Object类
2、构造方法：public Object();
3、常用方法：
3.1、getClass();获取类型、判断对象的真实类型
// instanceof 判断一个对象是否是一个具体类的实例
if (p instanceof Student) {
System.out.println("p是studnet实例");
}
// getClass(); 获取类型, 判断对象的真实类型, 不包含父类继承的类型.
/*
获取类型有两种方式 :
1. 对象获取 对象名.getClass(); 方法
2. 类型获取 类型.class 属性
*/
if (p.getClass() == Student.class) {
System.out.println("类型一样");
}
3.2、toString();返回该对象的字符串表示。该字符串内容就是对象的类型+@+内存地址值。覆盖重写。
@Override
public String toString() {
// `非静态方法中 / 对象方法` 属性使用, 或方法调用,
// 默认之前都有 this 关键字. this.name, this.age, this.introduce();
return "Student {name = " + name + ", age = " + age + "}";
}
3.3、equals(Object obj);指示其他某个对象是否与此对象“相等”。默认是指对象“地址值”、重写好可比较对象属性、"=="表示对比二个基本类型、equals对比二个引用类型
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
3.3、public int hashCode();返回对象的哈希码值。
3.4、protected Object clone(); 创建并返回此对象的副本
3.5、public final void notify() ;唤醒正在等待对象监视器的单个线程
3.6、public final void notifyAll();唤醒正在等待对象监视器的所有线程。
3.7、public final void wait();导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
注：上面没有实例的在后面会学到。现在作为了解。
4、Objects工具类
4.1、概述：工具类、方法基本都为static、直接使用该工具类的类名实现调用
4.2、static boolean equals(Object a, Object b) ;判断二个参数数据是否相等
区别：==比较的是2个对象的地址值，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。
二、Date、DateFormat、Calendar 日期类
1.1、Date 日期类
1.2、概述：获取当前的日期、精确到毫秒
1.3、构造方法：new Date();创建一个表示当前时间日期对象
1.4、常用方法：
1.4.1、new Date(long time);创建一个从“标准时间”开始的时间日期对象（1970-1-1 00:00:00）中国东八区
1.4.1、long getTime(); 获取从标准时间到现在总共经过的毫秒数、1s = 1000ms
public class DateTest1 {
public static void main(String[] args) {
// 1. 创建一个当前时间日期对象
Date date = new Date();
// date = Thu Aug 16 16:21:46 CST 2018
System.out.println("date = " + date);
// 2. 创建一个从标准时间开始的时间日期对象
Date date2 = new Date(0L);
// date2 = Thu Jan 01 08:00:00 CST 1970
System.out.println("date2 = " + date2);
// 3. getTime(); 获取时间毫秒数
long time = date.getTime();
System.out.println("time = " + time);
// 4. 演示 :
Date date3 = new Date(time);
System.out.println("date3 = " + date3);
}
}
2、DateFormat 日期格式化
2.1、概述：日期格式化类、DateFormat为抽象类、所以要java.text.SimpleDateFormat子类实现
2.2、构造方法：new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
2.3、常用方法：
2.3.1、String format(Date date)将一个日期对象转换为一个字符串对象.
2.3.2、Date parse(String source) 将一个字符串对象转换为一个日期对象
public class TestDateFormat {
public static void main(String[] args) throws ParseException {
// 1. 创建一个日期格式类对象
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 2. 格式化 (日期 -> 字符串)
String str = df.format(new Date());
// str = 2018-08-16 16:50:17
System.out.println("str = " + str);
// 3. 解析 (字符串 -> 日期)
String dateStr = "2008年08月08日 08:08:08";
SimpleDateFormat df2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date date = df2.parse(dateStr);
// date = Fri Aug 08 08:08:08 CST 2008
System.out.println("date = " + date);
}
}
3、Calendar 日历类
3.1、概述：public abstract class Calendar extends Object 是一个抽象类
3.2、获取对象：Calendar.getInstance();获取当前时间/日期表示的日对象
3.3、常用方法：
3.3.1、int get(int field) ;获取 `年月日` 组件.
3.3.2、void set(int field, int value) ;给指定的组件设置对应的数值.
3.3.3、void add(int field, int value); 根据日历的规则，将指定的时间量添加或减去给定的日历字段。
public class TestCalendar {
public static void main(String[] args) {
// l. 创建一个表示当前 `时间/日期` 的日历对象
Calendar now = Calendar.getInstance();
System.out.println("now = " + now);
// 2. get 方法
/*
int i = now.get(1); 代码的阅读性太差
System.out.println("i = " + i); 2018
*/
printCalendar(now);
// 3. set 方法
// 需求1 : 回到 2008 年.
now.set(Calendar.YEAR, 2008);
// 需求2 : 将 day 设置为 8 号.
now.set(Calendar.DAY_OF_MONTH, 8);
printCalendar(now);
// 4. add 添加
// 需求3 : 去到 100 年之后.
now.add(Calendar.YEAR, 100);
// 需求4 : 回到半年之前.
now.add(Calendar.MONTH, -6);
printCalendar(now);
}
// 定义一个方法, 输出年月日
public static void printCalendar(Calendar now) {
int year = now.get(Calendar.YEAR);
int month = now.get(Calendar.MONTH) + 1; // 0 ~ 11
int day = now.get(Calendar.DAY_OF_MONTH);
System.out.println("今天是 : " + year + "年" + month + "月" + day + "日.");
}
}
三、System 系统类
1、概述：public final class System extends Object;System类提供的设施包括标准输入，标准输出和错误输出流;
2、字段：
2.1、 in 标准输入流 new Scanner(System.in);
2.2、 out 标准输出流 System.out.println("");
2.3、err 标准错误流. (红色字体, 多线程)System.err.println()
3、常用方法：
3.1、static void exit(int status) 正常退出Java虚拟机.System.exit(0)
3.2、static long currentTimeMillis() ; 获取当前时间毫秒.
3.3、static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 复制一个数组中的元素到另一个数组中存储.
参数1 : src -> source 源数据 (数组A)
参数2 : srcPos -> source position 源数据位置 (从数组A的哪个位置开始)
参数3 : dest -> destination 目的地 (数组B)
参数4 : destPos -> destination position 目的地位置. (数组B的哪个位置开始)
参数5 : length 长度, 从数组A中拷贝多长的元素个数.
演示一：
public class Test01 {
public static void main(String[] args) {
System.out.println("hello Java.");
System.out.println("Hello World 1.");
System.err.println("Hello World 2."); // 多线程 (错误流, 红色字体)
System.exit(0); // 退出虚拟机 (程序就提前结束了)
}
}
演示二：
public class CurrentTimeMillisTest2 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
// 调用方法 / 执行代码
long sum = 0;
for (int i = 0; i < 1000000000; i++) {
sum += i;
}
long end = System.currentTimeMillis();
// 共耗时 : 280 毫秒.
System.out.println("共耗时 : " + (end - start) + " 毫秒.");
}
}
演示三：arrayCopy 数组元素复制方法
public class Test01 {
public static void main(String[] args) {
int[] src = new int[]{ 10, 20, 30, 40, 50 };
int[] dest = new int[10];
System.arraycopy(src, 0, dest, 0, 5);
System.out.println("src = " + Arrays.toString(src));
System.out.println("dest = " + Arrays.toString(dest));
int[] dest2 = new int[10];
System.arraycopy(src, 0, dest2, 5, 5);
System.out.println("dest2 = " + Arrays.toString(dest2));
}
}
四、StringBuilder 字符串构造者类
1、概述：public final class StringBuilder extends Object implements Serializable, CharSequence字符串构造者类
2、构造方法：
2.1、StringBuilder();构造一个没有字符的字符串构建器，初始容量为16个字符
2.2、StringBuilder(String str);构造一个初始化为指定字符串内容的字符串构建器。
3、常用方法：
3.1、StringBuilder append(b) ;链式编程、将 b参数的字符串表示附加到序列中
3.2、String toString() ;将字符串构建者中的数据转换为字符串常量.
问题引入：
public class StringBuilderTest1 {
public static void main(String[] args) {
// String 类的优点 : 常量, 可以共享.
String s1 = "hello"; // 字面值
String s2 = "hello";
// 请问 : s1 的地址和 s2 的地址一致呢 ???
System.out.println(s1 == s2); // true
// String 类的缺点 : 常量, 不可再次更改.
String s3 = "hello";
String s4 = s3 + " world."; // 说明 : 字符串如果进行大量的拼接, 就会造成内存的浪费.
System.out.println(s3 == s4); // false
}
}
// 请问 : 如何解决字符串拼接中, 关于内存浪费的问题 ??? StringBuilder 字符串构建者类.
演示一：
public static void main(String[] args) {
// 1. 创建一个 StringBuilder 对象
StringBuilder sb = new StringBuilder(); // 堆区中开辟了一块空间 (拼接字符串)
// 2. 调用 append 方法拼接
StringBuilder sb2 = sb.append("hello");
StringBuilder sb3 = sb2.append(" world.");
System.out.println(sb == sb2);
System.out.println(sb2 == sb3);
System.out.println("sb = " + sb);
System.out.println("sb2 = " + sb2);
System.out.println("sb3 = " + sb3);
}
演示二：
public static void main(String[] args) {
// 1. 创建一个字符串构建者对象
StringBuilder sb = new StringBuilder();
// 2. 链式编程
sb.append("hello").append(" world.").append(true).append(998); // append 方法在拼接过程中, 不会产生新空间.
System.out.println("sb = " + sb);
// 调用方法
printString(sb.toString());
}
// 方法 :
public static void printString(String str) {
System.out.println("str = " + str);
}
五、包装类
1、概述：parseInt(String s);将字符串参数作为有符号的十进制整数进行解析
2、装箱与拆箱（编译器）
装箱 : 将基本数据类型自动包装为包装类型.
拆箱 : 将包装类型自动拆解为基本数据类型.
用到的方法：
public static void main(String[] args) {
// 集合 : <泛型> 泛型不能是基本数据类型.
new ArrayList<Integer>(); // 整型包装类
new ArrayList<Character>(); // 字符包装类
/*
基本数据类型 包装引用类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
*/
// 自动装箱 :
// int num = 100;
// Integer integerNum1 = Integer.valueOf(100);
Integer integerNum1 = 100; // 引用类型 = 基本数据类型
// 自动拆箱 :
// Integer integerNum2 = integerNum1;
// int num2 = integerNum1.intValue();
int num2 = integerNum1;
// 基本类型和包装可以直接运算.
// int sum = integerNum1.intValue() + num2;
int sum = integerNum1 + num2;
System.out.println("sum = " + sum);
}
显示：sum = 200;
基本数据类型,包装类型与字符串的转换
public static void main(String[] args) {
// 需求 : 基本数据类型转换为字符串类型
int num1 = 100;
// 方式一 : 推荐使用, 并记忆
String str1 = num1 + "";
// 方式二 : 了解
String str2 = String.valueOf(100);
// 将字符串转换为包装类型:
Integer integer_num1 = new Integer("998");
Integer integer_num2 = Integer.valueOf("998");
// 将字符串转换 `基本数据类型`
int num = 998;
System.out.println(num + 2);
String str = "998";
str = str + 2;
System.out.println("str = " + str);
// `控制台 / 页面` 获取的数据就是 String 类型.
// 运算 : 需要将字符串转换为 `基本数据类型`.
// static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析。
String str3 = "998"; // 如果字符串无法解析为整型, 程序就会抛出 NumberFormatException 数字格式化异常.
int n = Integer.parseInt(str3);
n = n + 2;
System.out.println("n = " + n);
}
显示：
