所有类的顶级父类
存在于java.lang包中，这个包不需要我们手动导包
默认返回 类名@地址 的格式，来展示对象的地址值，如：a00000.Student@a0834e7。
如果想看属性值我们可以重写这个方法，重写后返回的就是把属性值拼接成一个字符串。
如：Student [name=苏大强, age=20, id=10001]
当前对象和参数对象比较大小，默认是比较内存地址，如果要比较对象的属性，可以重写该方法
==和equals的区别
1、 当使用==比较时，如果相比较的两个变量是引用类型，那么比较的是两者的物理地
值（内存地址），如果相比较的两个变量都是数值类型，那么比较的是具体数值是否相等。
2、 当使用equals()方法进行比较时，比较的结果实际上取决于equals()方法的具体实现
众所周知，任何类都继承自Object类，因此所有的类均具有Object类的特性，比如String、integer等，他们在自己的类中重写了equals()方法，此时他们进行的是数值的比较，而在Object类的默认实现中，equals()方法的底层是通过==来实现的。
native：表示由C语言来实现的
返回该对象的哈希码值
转换成地址值：Integer.toHexString(hashCode())
是一个封装char[]数组的对象
如果是第一次使用字符串，java会在字符串常量池创建一个对象。
再次使用相同的内容时，会直接访问常量池中存在的对象。
方式1：
String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String()
初始化一个新创建的 String 对象，使其表示一个空字符序列。
方式2：String name= ”abc”;
length()
charAt()
lastIndexOf()
substring()
equals()
startsWith()
endsWith()
split()
trim() 去除字符串两端的空格
test 1:
package StringTest;
public class test1 {
public static void main(String[] args){
String a = "a1";//“a1”在编译的时候就能确定，所以编译的时候，a1被放进了常量池中，同时a指向常量池中的a1对象
String b = "a"+ 1;//a和1这两个常量都能在编译时确定，所以他们相加的结果也能确定，因此编译器检查常量池中是否有值为a1的String对象，发现有了，因此b也指向常量池中的a1对象
System.out.println(a==b);//==判断的是a和b是否指向同一个对象，也就是同一块内存区域
}//true
}
test2：
package StringTest;
public class test2 {
public static void main(String[] args){
String a = "ab";
String bb = "b";
String b = "a"+ bb; //编译器不能确定为常量
System.out.println(a==b);
}//false
}
test3：
package StringTest;
public class test3 {
public static void main(String[] args){
String a = "ab";
final String bb = "b";
String b = "a"+ bb; //bb加final后是常量，可以在编译器确定b
System.out.println(a==b);
}//true
}
test4：
package StringTest;
public class test4 {
public static void main(String[] args){
String a = "ab";
final String bb = getBB();
String b = "a"+ bb;//bb是通过函数返回的，虽然知道它是final的，但不知道具体是啥，要到运行期才知道bb的值
System.out.println(a==b);
}//false
private static String getBB(){ return "b"; }
}
test5：
package StringTest;
public class test5 {
private static String a = "ab";
public static void main(String[] args){
String s1 = "a";
String s2 = "b";
String s = s1 + s2;//+的用法
System.out.println(s == a);
System.out.println(s.intern() == a);//intern的含义
}//flase true
}
test6：
package StringTest;
public class test6 {
private static String a = new String("ab");
public static void main(String[] args){
String s1 = "a";
String s2 = "b";
String s = s1 + s2;
System.out.println(s == a);
System.out.println(s.intern() == a);
System.out.println(s.intern() == a.intern());
}//flase false true
}
把基本类型进行包装，提供更加完善的功能。
Number：数字包装类的抽象父类，提供了各种获取值的方式
Integer i=new Integer(999); // 创建一个Integer对象，表示指定的int值
Integer i2=new Integer("999"); // 创建一个Integer对象，表示String参数“999”指定的int值
| 返回值 |
方法名 |
作用 |
| byte |
byteValue() |
Integer → byte |
| double/float |
double/floatValue() |
转为double/float |
| int/long |
int/longValue() |
转为int/long |
| static int |
parseInt(String s) |
String → int |
| static Integer |
valueOf(String s) |
String → Integer |
| String |
toString() |
转为String |
装箱：将基本类型装换成包装类，分为自动装箱和手动装箱（就是必须手动的new一个对象）
拆箱：将包装类型转换成基本类型，分为自动拆箱和手动拆箱（就是程序默认将其自动的创建一个对象）
(1) int → Integer new Integer(primitive)
(2) Integer → int Integer 对象.xxxValue()
(3) Integer → String Integer 对象.toString()
(4) String → Integer new Integer(String str)
(5) int → String Integer.valueOf(primitive)
在Integer类中，包含256个Integer缓存对象，范围是 -128到127。使用valueOf()时，如果指定范围内的值，访问缓存对象，而不新建；如果指定范围外的值，直接新建对象。
(6) String →int Integer.parseXxx())
创建对象
1、new Double(3.14)
2、Double.valueOf(3.14)//和 new 没有区别
方法
static double parseDouble(String s)
返回一个新的 double 值，该值被初始化为用指定 String 表示的值，这与 Double 类的 valueOf 方法一样
static Double valueOf(double d)
返回表示指定的 double 值的 Double 实例
示例
基本类型→字符串类型
字符串类型→基本类型
存在于java.util.Date包。
用来封装一个毫秒值表示一个精确的时间点。
从1970-1-1 0点开始的毫秒值。
new Date()：封装的是系统当前时间的毫秒值
new Date(900000000000L)：封装指定的时间点
getTime()：取内部毫秒值
setTime()：存取内部毫秒值
getMonth()：获取当前月份
getHours()：获取当前小时
compareTo(Date)：当前对象与参数对象比较。当前对象大返回正数，小返回负数，相同0
日期格式化工具，可以把Date对象格式化成字符串，也可以日期字符串解析成Date对象。
new SimpleDateFormat(格式)
格式：yyyy-MM-dd HH:mm:ss
MM/dd/yyyy..
format(Date)：把Date格式化成字符串
parse(String)：把String解析成Date
BigDecimal：常用来解决精确的浮点数运算。
BigInteger：常用来解决超大的整数运算。
BigDecimal.valueOf(2);
add(BigDecimal bd)： 做加法运算
substract(BigDecimal bd) ： 做减法运算
multiply(BigDecimal bd) ： 做乘法运算
divide(BigDecimal bd) ： 做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂
append()
1、 在线程安全上，
--StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
--StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
2、 在执行效率上，StringBuilder > StringBuffer > String
3、 源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。
abstract class AbstractStringBuilder implements Appendable, CharSequence {
在 Java 中，允许在一个类（或方法、语句块）的内部定义另一个类，称为内部类(Inner Class)，有时也称为嵌套类(Nested Class)。内部类和外层封装它的类之间存在逻辑上的所属关系，一般只用在定义它的类或语句块之内，实现一些没有通用意义的功能逻辑，在外部引用它时必须给出完整的名称。内部类主要用于设计具有互相协作关系的类集合。
通过将一个类定义在另一个类的内部，也可以有效的隐藏该类的可见性，实现极好的封装特性。但不易理解，实际开发使用不多。
