Day 13，14笔记-内部类和常用类

JavaSE基础

一、内部类

1.1 概述

• 定义在类的内部的完整的类称为内部类
• 能容纳更多的数据
• 分类：
  • 局部内部类
  • 成员内部类
  • 静态内部了
  • 匿名内部类

1.2 成员内部类

• 类的成员之一
• 定义位置同实例变量和实例方法：类中方法外
• 能访问外部类中所有的数据
• 不能定义静态数据
• 创建对象需要依赖外部类对象

package com.javaclass;

import com.javaclass.Father.Son;

public class TestClass01 {
	public static void main(String[] args) {
		// 创建外部类对象
		Father fa = new Father();
		fa.father();
		// 创建成员内部类对象:需要依赖外部类
		Son s = fa.new Son();
		s.son();
	}
	

}
class Father {
	String name ="father";
	void father(){
		System.out.println("father");
		
	}
	/**
	 * 	内部类
	 * 		能承载更多的信息
	 * 		这个属性和所在的类关联性极强
	 */
	class Son{
		// 成员内部类中不能定义静态属性和方法
		// static String str = "";
		void son() {
			// 访问外部类中的属性/方法
			System.out.println(name +"  son");
		}
		
	}
}

1.3 局部内部类

• 在方法中创建的类成为局部内部类
• 如果在局部内部类中使用方法中的局部变量,这个局部变量需要使用final修饰
• 因为：

package com.javaclass;

public class TestInnerClass {
	public static void main(String[] args) {
		System.out.println("外部类");
		
		// 创建变量
				final int num = 100;
		class Inner{
			public void show() {
				
				System.out.println("局部内部类");
				// 如果在局部内部类中使用方法中的局部变量,这个局部变量需要使用final修饰
				System.out.println(num);
			}
		}
		Inner inner = new Inner();
		inner.show();
	}

}

1.4 静态内部类

• 使用static修饰的成员内部类
• 只能访问外部类的静态数据
• 创建对象不依赖外部类对象，可以直接使用类名调用静态属性和方法

package com.javaclass;

public class TestStaticClass {
	public static void main(String[] args) {
		// Outer outer = new Outer();可以不用创建对象直接访问
		
//		 静态内部类中的静态数据可以直接使用类名调用
		System.out.println(Outer.Inner.info);
		Outer.Inner.show();
				
		//静态内部了可以直接创建对象
		Outer.Inner inner = new Outer.Inner();
		System.out.println(inner.info);
	}

}
class Outer{

	static {
		System.out.println("外部类的静态代码块");
	}	
	static class Inner {
		static {
			System.out.println("内部类的静态代码块");
		}
		static String info = "静态数据";
		public static void show() {
			System.out.println("展示内部类的静态代码块");
		}	
	}
}

1.5 匿名内部类【掌握】

• 没有名字的内部类？
  • 定义类、实现类、创建对象的语法合并
• 需要实现接口或者继承一个类
  • 接口一般只有一个方法
  • 类一般是抽象类

package com.javaclass;

public class ClassTest02 {
	public static void main(String[] args) {
        //实现接口
		Eat eat = new Eat() {
			@Override
			public void eat() {
				System.out.println("猫吃鱼");
			}
		};
		eat.eat();
		//继承抽象类
		Cat cat = new Cat() {
			void brand() {
				System.out.println("波斯猫");
			}
		};
		cat.brand();
		
		
	}
}

interface Eat{
	void eat();
}
abstract class Cat{
	abstract void brand();
}

二、Object

2.1 概述

• 类 Object 是类层次结构的根类。
• 所有对象（包括数组）都实现这个类的方法。

2.2 创建对象

Object() 

package com.javaobject;

public class TestObject01 {
	public static void main(String[] args) {
		Object obj01 = new Object();
		Object obj02 = 100;
		Object obj03 = "Hello";
		Object obj04 = true;
		Object obj05 = 3.1415926;
		Object obj06 = new int[] {11,22,33,44,55};
	
	}
}

2.3 常用方法

getClass

• 获取对象的运行时【真实】类型

		// 获取对象的运行时【真实】类型
		System.out.println(obj01.getClass());
		System.out.println(obj02.getClass());
		System.out.println(obj03.getClass());
		System.out.println(obj04.getClass());
		System.out.println(obj05.getClass());
		System.out.println(obj06.getClass());
		

toString

• 返回该对象的字符串表示。

• 默认返回

  getClass().getName() + '@' + Integer.toHexString(hashCode())
  

• 结果应是一个简明但易于读懂的信息表达式。

• 建议所有子类都重写此方法。

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", address=" + address + ", info=" + info + "]";
	}

hashCode

• 返回对象的哈希值
• 默认的计算方式和地址相关，不同的对象尽量获取不同的哈希值
• 我们希望两个属性完全相同的对象得到相同的哈希值，重写hashcode方法，使用属性计算哈希值

equals

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((address == null) ? 0 : address.hashCode());
		result = prime * result + age;
		result = prime * result + ((info == null) ? 0 : info.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	/**
	 *	抄写3遍
	 */
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		return true;
	}

finalize

@Override
protected void finalize() throws Throwable {
    System.out.println(name + "即将被当做垃圾回收");
}

== 和 equals

• ==
  • 关系运算符，比较两个对象是否相等
  • 基本类型的数据比较数值
  • 引用类型的对象比较地址值
• equals
  • Object中的一个方法，只能用于引用类型的比较，默认比较的是地址值
  • 一般认为两个对象如果具有完全相同的属性，比较应该返回true
  • 一般重写equals方法，比较对象的属性

三、String

3.1 概述

• String 类代表字符串。就是一串字符。
• Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
• 字符串是常量；它们的值在创建之后不能更改。

3.2 创建对象

package com.javastring;

public class TestString01 {
	public static void main(String[] args) {
		/**
			构造方法摘要 
			String() 
			          初始化一个新创建的 String 对象，使其表示一个空字符序列。
			           
			String(byte[] bytes, int offset, int length, String charsetName) 
			          通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 
			          
			String(char[] value, int offset, int count) 
			          分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 
			          
			String(int[] codePoints, int offset, int count) 
			          分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。 
			          
			String(String original) 
			          初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 
		 */
		// 创建一个空的字符串
		String s01 = new String();
		
		// 使用字符串创建对象
		String s02 = new String("Hello");
		
		// 使用byte数组创建,规则参考ASCII表
		byte[] bytes = new byte[] {65,66,67,68,69,70,71};
		String s03 = new String(bytes,2,3);
		System.out.println(s03);
		
		// 使用字符创建对象
		char[] chars = new char[] {'床','前','明','月','光'};
		String s04 = new String(chars,1,3);
		System.out.println(s04);
		
		// 参考Unicode创建字符
		int[] arr = new int[] {20000,12500,31150,52365,86100};
		String s05 = new String(arr, 0, arr.length);
		System.out.println(s05);
		
	}
}

3.3 常用方法

package com.javastring;

import java.util.Arrays;

public class TestString02 {
	public static void main(String[] args) {
		/**
			常用方法
			增
			 String concat(String str) 
			          将指定字符串连接到此字符串的结尾。 
			
			
			删
			
			
			改
			 String replace(char oldChar, char newChar) 
			          返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
			 String replaceAll(String regex, String replacement) 
			          使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
			 String replaceFirst(String regex, String replacement) 
			          使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 
			 String toLowerCase() 
			          使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 
			 String toUpperCase() 
			          使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 
			 String trim() 
			          返回字符串的副本，忽略前导空白和尾部空白。 
			
			
			查
			 char charAt(int index) 
			          返回指定索引处的 char 值。 
			 boolean contains(CharSequence s) 
			          当且仅当此字符串包含指定的 char 值序列时，返回 true。 
			 boolean endsWith(String suffix) 
			          测试此字符串是否以指定的后缀结束。 
			 boolean startsWith(String prefix) 
			          测试此字符串是否以指定的前缀开始。 
			 boolean equals(Object anObject) 
			          将此字符串与指定的对象比较。 
			 boolean equalsIgnoreCase(String anotherString) 
			          将此 String 与另一个 String 比较，不考虑大小写。 
			 int hashCode() 
			          返回此字符串的哈希码。 
			 int indexOf(String str) 
			          返回指定子字符串在此字符串中第一次出现处的索引。 
			 int indexOf(String str, int fromIndex) 
			          返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 
			 int lastIndexOf(String str) 
			          返回指定子字符串在此字符串中最右边出现处的索引。 
			 int lastIndexOf(String str, int fromIndex) 
			          返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 
			 int length() 
			          返回此字符串的长度。 
			 String substring(int beginIndex) 
			          返回一个新的字符串，它是此字符串的一个子字符串。 
			 String substring(int beginIndex, int endIndex) 
			          返回一个新字符串，它是此字符串的一个子字符串。 
			static String valueOf(Object obj) 
			          返回 Object 参数的字符串表示形式。 
			          
			          
			其他
			 int compareTo(String anotherString) 
			          按字典顺序比较两个字符串。 
			 int compareToIgnoreCase(String str) 
			          按字典顺序比较两个字符串，不考虑大小写。 
			 byte[] getBytes() 
			          使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 
			 char[] toCharArray() 
			          将此字符串转换为一个新的字符数组。 
			 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
			          将字符从此字符串复制到目标字符数组。 
			 String[] split(String regex) 
			          根据给定正则表达式的匹配拆分此字符串。 
			 String[] split(String regex, int limit) 
			          根据匹配给定的正则表达式来拆分此字符串。 
		 */
		
		// 拼接字符串
		System.out.println("Hello".concat("World"));
		
		// 替换
		System.out.println("Hello".replace('l', 'L'));
		System.out.println("Hello".replaceAll("l", "L"));
		// 转换成大写
		System.out.println("Hello".toUpperCase());
		// 去除两头的空格
		System.out.println(" He llo  ".trim());
		
		// 查询指定索引位置的字符
		System.out.println("Hello".charAt(0));
		System.out.println("Hello".charAt(1));
		System.out.println("Hello".charAt(2));
		
		String str = "Hello";
		for (int i = 0; i < str.length(); i++) {
			System.out.println(str.charAt(i));
		}
		
		// fghjkljklDFGHJK%^&*(6789：大写、小写、数字、其他字符出现的次数
		
		// 截取字符串
		str = "abcdefghijklmnopqrstuvwxyz";
		System.out.println(str.substring(7));
		System.out.println(str.substring(7,7+7));
		
		// 把字符串转换成byte数组
		byte[] bytes = str.getBytes();
		System.out.println(Arrays.toString(bytes));
		
		// 把字符串转换成字符数组
		char[] chars = str.toCharArray();
		System.out.println(Arrays.toString(chars));
		
	}

}

四、StringBuffer

4.1 概述

• 线程安全的可变字符序列。
• 一个类似于 String 的字符串缓冲区，但能修改。
• 但通过某些方法调用可以改变该序列的长度和内容。

4.2 创建对象

package com.shine.str;

public class Demo04 {
	public static void main(String[] args) {
		/**
			构造方法摘要 
				StringBuffer() 
				          构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。 
				StringBuffer(int capacity) 
				          构造一个不带字符，但具有指定初始容量的字符串缓冲区。 
				StringBuffer(String str) 
				          构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。 
		 */
		
		//  构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。 
		StringBuffer buffer01 = new StringBuffer();
		System.out.println(buffer01.length());
		System.out.println(buffer01.capacity());
		
		// 构造一个不带字符，但具有指定初始容量的字符串缓冲区。 
		StringBuffer buffer02 = new StringBuffer(1024);
		System.out.println(buffer02.length());
		System.out.println(buffer02.capacity());
		
		// 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。 
		StringBuffer buffer03 = new StringBuffer("abcdefg");
		System.out.println(buffer03.length());
		System.out.println(buffer03.capacity());
	}
}

4.3 常用方法

增加数据

package com.javastring;

public class TestStringBuffer02 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
		 * 增
			 StringBuffer append(Object obj) 
			          追加 Object 参数的字符串表示形式。 
			 StringBuffer insert(int offset, Object obj) 
			          将 Object 参数的字符串表示形式插入此字符序列中。 
		 */
		
		// 空的字符串缓冲区,内容为0,容量16
		StringBuffer buffer = new StringBuffer();
		
		buffer.append("Hello");
		System.out.println(buffer.length());
		System.out.println(buffer.capacity());
		
		buffer.append(true);
		System.out.println(buffer.length());
		System.out.println(buffer.capacity());
		
		buffer.append(3.14);
		System.out.println(buffer.length());
		System.out.println(buffer.capacity());
		
		// 在指定位置插入元素
		buffer.insert(1, 222);
		System.out.println(buffer);
		System.out.println(buffer.length());
		System.out.println(buffer.capacity());
		
		/**
		 *	扩容：
		 *		ensureCapacityInternal(count + len);	确保容量
		 *			newCapacity(minimumCapacity)		计算容量
		 *			默认扩容：	int newCapacity = (value.length << 1) + 2;
		 *			默认扩容不足：
		 *				如果没有超过MAX_ARRSY_SIZE,扩容到需要的容量
		 *				如果超过MAX_ARRSY_SIZE,没有超过Integer.MAX,扩容需要的容量
		 *				如果超过Integer.MAX,报错OutOfMemoryError
		 */
		
		// 每次扩大2倍加2，如果不够且没有超过数组最大值,扩容到需要的容量
		buffer.append("01234567890123456789");
		System.out.println(buffer.length());
		System.out.println(buffer.capacity());
		
	
	}
}

删改查数据

package com.javastring;

public class TestStringBuffer03 {
	public static void main(String[] args) {
		/**
		 * 		 
		 * 删
			 StringBuffer delete(int start, int end) 
			          移除此序列的子字符串中的字符。 
			 StringBuffer deleteCharAt(int index) 
			          移除此序列指定位置的 char。 
		 
		 * 改
			 void ensureCapacity(int minimumCapacity) 
			          确保容量至少等于指定的最小值。 
			 StringBuffer replace(int start, int end, String str) 
			          使用给定 String 中的字符替换此序列的子字符串中的字符。 
			 StringBuffer reverse() 
			          将此字符序列用其反转形式取代。 
			 void setCharAt(int index, char ch) 
			          将给定索引处的字符设置为 ch。 
			 void setLength(int newLength) 
			          设置字符序列的长度。 
			 void trimToSize() 
			          尝试减少用于字符序列的存储空间。 
		 
		 * 查
			 int length() 
			          返回长度（字符数）。 
			 int capacity() 
			          返回当前容量。 
			 char charAt(int index) 
			          返回此序列中指定索引处的 char 值。 
			 int indexOf(String str) 
			          返回第一次出现的指定子字符串在该字符串中的索引。 
			 int indexOf(String str, int fromIndex) 
			          从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 
			 int lastIndexOf(String str) 
			          返回最右边出现的指定子字符串在此字符串中的索引。 
			 int lastIndexOf(String str, int fromIndex) 
			          返回最后一次出现的指定子字符串在此字符串中的索引。 
			 String substring(int start) 
			          返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 
			 String substring(int start, int end) 
			          返回一个新的 String，它包含此序列当前所包含的字符子序列。 
		 */
		StringBuffer buffer = new StringBuffer();
		
		buffer.append("01234567890123456789");
		System.out.println(buffer);
		
		// 删除区间内容
		buffer.delete(0, 5);
		System.out.println(buffer);
		
		// 如果预知有大批量的数据会加入,手动调整容量
		buffer.ensureCapacity(1024);
		System.out.println(buffer.capacity());
		
		// 替换区间内容
		buffer.replace(0, 3, "伍六");
		System.out.println(buffer);
		
		//反转
		buffer.reverse();
		System.out.println(buffer);
		//复原
		buffer.reverse();
		System.out.println(buffer);
		
		// 设置字符的数量
		buffer.setLength(10);
		System.out.println(buffer);
		
		// 调整容量:把容量调整为长度
		buffer.trimToSize();
		System.out.println(buffer.length());
		System.out.println(buffer.capacity());
		
		
	}
}

4.4 StringBuilder

• 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
• 作用、构造方法、常用方法和StringBuffer相同
• 线程不安全，效率较高，单线程推荐使用

五、包装类

5.1 概述

• 每一种基本类型都有其对应的引用类型
• 这些引用类型中有属性和方法，更方便我们操作数据
• 这些引用类型称为包装类

5.2 包装类大全

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

5.3 常用方法

• 整数–》字符串
• 字符串–整数

package com.shine.pack;

public class Demo01 {
	public static void main(String[] args) {
		// 基本类型int
		int i = 10;
		System.out.println(i);
		
		// 引用类型Integer,存储基本类型的数据 && 提供属性和方法
		Integer ii = new Integer(20);
		System.out.println(ii);
		
		int iii = Integer.parseInt("100");
		System.out.println(iii);
		
		// 前端 == 后端
		System.out.println(Integer.MAX_VALUE);
		
		/**
			static int parseInt(String s) 
			          将字符串参数作为有符号的十进制整数进行解析。 
			static String toBinaryString(int i) 
			          以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。 
			static String toOctalString(int i) 
			          以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 
			static String toString(int i) 
			          返回一个表示指定整数的 String 对象。 
			static String toHexString(int i) 
			          以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 
		 */
		// 十进制数字转换成其他进制字符串
		System.out.println(Integer.toBinaryString(66));
		System.out.println(Integer.toString(66));
		System.out.println(Integer.toOctalString(66));
		System.out.println(Integer.toHexString(66));
		
	}
}

六、System

6.1 概述

• System 类包含一些有用的类字段和方法。它不能被实例化。
• 在 System 类提供的设施中，有标准输入、标准输出和错误输出流；
• 对外部定义的属性和环境变量的访问；
• 加载文件和库的方法；
• 还有快速复制数组的一部分的实用方法。

6.2 常用方法

当前时间毫秒值

package com.javastring;

import java.util.Map;
import java.util.Properties;


public class TestSystem {
	public static void main(String[] args) {
		/**
		 *	方法摘要 
				static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
				          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 
				static long currentTimeMillis() 
				          返回以毫秒为单位的当前时间。 
				static void exit(int status) 
				          终止当前正在运行的 Java 虚拟机。 
				static void gc() 
				          运行垃圾回收器。 
				          
				static Map<String,String> getenv() 
				          返回一个不能修改的当前系统环境的字符串映射视图。 
				static String getenv(String name) 
				          获取指定的环境变量值。 
				static Properties getProperties() 
				          确定当前的系统属性。 
				static String getProperty(String key) 
				          获取指定键指示的系统属性。 
				static String getProperty(String key, String def) 
				          获取用指定键描述的系统属性。 
		 */
		long startTime = System.currentTimeMillis();
		for (long i = 0; i < 10000000000L; i++) {
			//System.out.println(i);
		}
		long endTime = System.currentTimeMillis();
		System.out.println(endTime - startTime);

	}

}

退出JVM

	public static void main(String[] args) {
		System.out.println("main方法开始...");
		show();
		System.out.println("main方法结束...");
	}
	
	public static void show(){
		System.out.println("show方法开始...");
		for (int i = 0; i < 100; i++) {
			System.out.println(i);
			if (i == 6) {
				// break;	// 终止循环
				// return;	// 结束方法
				System.exit(0);	// 结束虚拟机,0是状态码
			}
		}
		System.out.println("show方法结束...");
	}
}

gc

	public static void main(String[] args) {
		// 手动触发垃圾回收
		System.gc();
		
		System.out.println("OVER");
    }

环境和属性

public static void main(String[] args) {
		// 获取所有的系统设置信息
		Map<String, String> map = System.getenv();
		System.out.println(map);
		
		String env = System.getenv("JAVA_HOME");
		System.out.println(env);
		
		Properties properties = System.getProperties();
		System.out.println(properties);
	}
}

七、Math

package com.javastring;

public class TestMath {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			static double abs(double a) 
			          返回 double 值的绝对值。 
			static long round(double a) 
			          返回最接近参数的 long。 
			static double ceil(double a) 
				返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
			static double floor(double a) 
			          返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。 
			          
			static double pow(double a, double b) 
			          返回第一个参数的第二个参数次幂的值。 
			static double sqrt(double a) 
			          返回正确舍入的 double 值的正平方根。 
			static double cbrt(double a) 
			          返回 double 值的立方根。 
			          
			static double max(double a, double b) 
			          返回两个 double 值中较大的一个。 
			static double min(double a, double b) 
			          返回两个 double 值中较小的一个。 
			          
			static double random() 
			          返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 
		 */
		
		System.out.println(Math.abs(3.3));
		System.out.println(Math.abs(-3.3));
		
		System.out.println(Math.round(3.3));
		System.out.println(Math.round(3.6));
		
		System.out.println(Math.ceil(5.5));
		System.out.println(Math.floor(5.5));
		
		// a的b次方
		for (int i = 2; i <= 10; i++) {
			System.out.println(Math.pow(2, i));
		}
		
		// 平方根
		for (int i = 2; i <= 20; i++) {
			System.out.println(Math.sqrt(i));
		}
		
		// 立方根
		for (int i = 2; i <= 20; i++) {
			System.out.println(Math.cbrt(i));
		}
	}
	
}

// 生成33~88之间的随机数字
for (int i = 0; i < 1000; i++) {
    //左闭右开区间
    System.out.println(Math.random()*55+33);
}

八、Random

package com.shine.math;

import java.util.Random;

public class Demo03 {
	public static void main(String[] args) {
		// 创建随机对象
		Random r = new Random();
		
		// 生成布尔值
		for (int i = 0; i < 10; i++) {
			System.out.println(r.nextBoolean());
		}
		
		// 生成指定范围的随机数字
		for (int i = 0; i < 10; i++) {
			System.out.println(r.nextInt(100));
		}
		
		// 生成55~99之间的随机数字	
        for (int i = 0; i < 10; i++) {
			System.out.println(r.randint(100));
		}
		// 生成一注双色球【考试题】
	}
}

九、BigDecimal

import java.math.BigDecimal;

public class Demo01 {
	public static void main(String[] args) {
		// 数学运算小数不准确
		System.out.println(1.0 - 0.9);
		System.out.println(10.0 / 3);
		
		BigDecimal bd01 = new BigDecimal("1.0");
		BigDecimal bd02 = new BigDecimal("0.9");
		System.out.println(bd01.add(bd02));
		System.out.println(bd01.subtract(bd02));
		System.out.println(bd01.multiply(bd02));
		System.out.println(bd01.divide(bd02, 3, BigDecimal.ROUND_HALF_UP));
	}
}

十、日期相关

10.1 Date

• 类 Date 表示特定的瞬间，精确到毫秒。

import java.util.Date;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 构造方法摘要 
				Date() 
				          分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。 
				Date(int year, int month, int date) 
				          已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date) 或 GregorianCalendar(year + 1900, month, date) 取代。 
				Date(int year, int month, int date, int hrs, int min) 
				          已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date, hrs, min) 或 GregorianCalendar(year + 1900, month, date, hrs, min) 取代。 
		 */
		
		Date date01 = new Date();
		System.out.println(date01);
		
		Date date02 = new Date(96, 10, 11);
		System.out.println(date02);
		
		System.out.println(date01.getYear());
		System.out.println(date01.getMonth());
		System.out.println(date01.getDate());
	}
}

10.2 Calendar

package com.shine.time;

import java.util.Calendar;

public class Demo02 {
	public static void main(String[] args) {
		// 创建日历对象
		Calendar rightNow = Calendar.getInstance();
		System.out.println(rightNow);
		System.out.println(rightNow.get(Calendar.YEAR));
		System.out.println(rightNow.get(Calendar.MONTH));
		System.out.println(rightNow.get(Calendar.DAY_OF_MONTH));
		System.out.println(rightNow.get(Calendar.HOUR));
		System.out.println(rightNow.get(Calendar.MINUTE));
		System.out.println(rightNow.get(Calendar.SECOND));
	}
}

10.3 日期格式化SimpleDateFormat

• SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。
• 它允许进行
  • 格式化（日期 -> 文本）
  • 解析（文本 -> 日期）和规范化。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo04 {
	public static void main(String[] args) throws ParseException {
		// 2023年3月31日 16:18:22
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		
		// 日期-->文字
		String time = sdf.format(new Date());
		System.out.println(time);
		
		// 文字-->日期
		String strTime = "2023年03月31日 16:23:10";
		Date date = sdf.parse(strTime);
		System.out.println(date);
		
	}
}