Java中哪些常用类被形象地称为入土类？
- 内容介绍
- 文章标签
- 相关推荐
本文共计3113个文字，预计阅读时间需要13分钟。
常用内部类+成员内部类+静态内部类+局部内部类+匿名内部类+内部类是类内部的再定义，编译后生成独立的字节码文件+内部类可以直接访问外部类的私有成员，而不破坏封装性。
常用类 内部类- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
内部类是在类的内部再定义一个完整的类
- 编译后，生成独立的字节码文件
- 内部类可以直接访问外部类的私有成员，而不破坏封装性。
- 可为外部类提供必要的内部组件。
//外部类
public class Animal{
//内部类
class Dog{
}
}
成员内部类
在类的内部定义，与变量实例，实例方法同级别的类。
外部类的一个实例部分，创建内部类对象，必须先创建外部类对象。
当外部类跟内部类存在重名属性时，内部类方法会优先选择内部类属性，如果想访问外部类，要用Outer.this.name;
内部类当中不定义静态成员，但可以包含静态常量final.
public class Outer{
private String name;
class Inner{
private String phone;
public void show(){
system.out.println(name);
system.out.println(phone);
}
}
}
//调用
Outer outer = new Outer();
Inner inner = outer.new Inner();
//或者
Inner inner = new Outer().new Inner();
inner.show();
静态内部类
在内部类的基础上，加一个static关键字,级别与外部类相同。但是可以被外部类使用。
可以直接创建使用，不依赖于外部类对象。
访问外部类的成员变量的时候，要创建外部类对象才能使用，因为静态成员变量级别相当于外部类。
调用时要：外部类.内部类 变量名 = new 内部类.外部类();
定义在外部类的方法中，仅限于方法中调用。
局部变量，类，不能加访问修饰符,同时不能含有static静态修饰符。
访问外部类要加外部类.this.变量；
局部内部类访问当前方法中的局部变量时，因无法保障变量生命周期与自身相同，变量必须修饰为final。
public class Outer{
public void show(){
String address = "山东";
class Inner{
private String phone;
public void show2(){
system.out.println(address)
}
}
Inner inner = new Inner();
inner.show2();
}
}
匿名内部类
是一个没有类名的局部内部类（特征与局部内部类相同）
必须继承一个父类或者实现一个接口。
是定义类，实现类，创建对象的语法合并，只能创建一个该类对象
//匿名内部类相当于在Usb类中创建一个局部内部类。
Usb usb = new Usb(){
public void service(){
//方法实现
}
}
object类
所有的类都直接或间接继承object类。
getClass()方法返回实际对象类型，用于判断两个引用中实际储存对象类型是否一致。
判断两个对象是否是一个类型
hashCode()方法返回对象的哈希码
哈希值是根据对象地址或者字符串或数字使用hash算法计算出来的int类型的数值。
相同对象返回相同的hash值。
- s1与s2hash值不相等，s1与s3相等。
通过调用，将一个Java对象转化成字符串表示形式，建议所有子类重写toString方法。
简写的方法越简洁，易阅读。
是判断两个对象地址是否相等。
默认实现是（this == obj），比较两个地址是否相同。
可以进行覆盖，比较两个对象内容是否相同。
equals重写步骤
public boolean equals(Object obj){
//判断两个对象是否是同一个引用
if(tihs == obj){
return true;
}
if(obj == null){
return false;
}
//if(this.getClass() == obj.getClass())
//instanceof判断对象是否是某种类型
if(obj instanceof Student){
//强制类型转换
Student s = (Student)obj;
//比较属性
if(this.name.equals(s.gerName()) && this.age == s.getAge()){
return true;
}
return false;
}
}
finalize()方法
当对象被判定为垃圾对象时，由jvm自动调用，用于标记垃圾对象，进入垃圾回收队列。
手动回收：使用System.gc();通知jvm执行垃圾回收。
基本类型存储在栈空间。
基本数据类型所对应的引用数据类型。引用数据类型具有可调用的属性跟方法。
包装类的默认值是null。
包装类对应
这样可以将栈空间的数据存放到堆空间中。
类型转换与装箱与拆箱装箱：将基本类型转化为引用类型
拆箱：将引用类型转化为基本类型
拆箱可以调用Number类的方法
- byteValue()
- doubleValue()
- floatValue()
- intValue()
- longValue()
- shortValue()
装箱通过包装类的构造类型来进行转换。
//装箱
int num1 = 13;
Integer integer = new Integer(num1);
//拆箱
int num2 = integer.intValue();
//jbk1.5之后支持自动装箱。
int age = 13;
Integer integer4 = age;
//自动拆箱
int age2 = integer4;
基本类型转化字符串
int n1;
String s = Integer.toString(n1);
字符串转化为基本类型
String str = "123";
int num = Integer.parseInt(str);
Boolean字符串转基本类型。
"true" -> true,非"true" -> false
String str = "true";
boolean b1 = Boolean.parseBoolean(str);
Integer缓冲区
Integer类型在堆空间内会有-128-127的缓存，在-128-127之内时，是直接从堆空间内调用，而超过127后，才会重新创建空间来存储值。
String类字符串是常量，创建后不可改变
字符串值是存储在字符串池中，可以共享。
String name = "hello";//hello会存储在字符串池中
name = "zhangsan";//在字符串池中开辟新空间，name指向新的zhangsan。
String name2 = "zhangsan";//name2与name指向同一个字符串，地址相同。
//对象的方式创建。
String s = new String("zhangsan");//会在栈里创建name，堆里创建“zhangsan”，方法池里也创建“zhangsan”，堆中的zhangsan指向方法池中的对象。
常用方法
- length(),获取字符串长度，空格也算一个字符。
- charAt(int index),返回某个位置字符串
- contains(String),判断是否含有某个子字符串。
- toCharArray();返回字符串对应的数组
- indexOf(String str);返回子字符串首次出现的位置
- lastIndexOf(String str);返回字符串最后出现的位置
- trim();去掉字符串前后的空格
- toUpperCase();把小写转化成大写
- toLowerCase();大写转化成小写
- endWith(str);判断是否已str结尾
- starWith(str);判断是否以str开头。
- replace();用新的字符或字符串替换旧的字符或字符串
- split();对字符串进行拆分
- equals();对两个字符串进行比较，equalslsIgnoreCase()忽略大小写。
- compareTo();比较大小
StringBuffer:可变长字符串，运行效率慢，线程不安全。
StringBuilder:可变长字符串，运行效率快，线程不安全。
方法：
- append()追加
- insert()添加
- replace()替换
- delete()删除
- delete(0,sb.length())清空
StringBuilder sb = new StringBuilder();
sb.append("asdas");//z追加字符串
sb.insert(0,"我在组前面");//在指定位置添加字符串。
sb.replace(head,last,str);//把指定区域内的字符串替换
sb.delete(head,last);//指定位置的字符删除
与string的区别：
- 效率高，节省内存
系统类，主要提供系统的属性和方法
System类无构造方法，只有定义成静态方法，直接用类名调用，system的属性和方法都是静态的
例如
system.out.println();
就是调用system当中的println方法
//src：原数组，srcpos：复制开始位置，dest:目标数组，destPos:目标数组位置，length:复制长度
System.arraycopy(src,srcPos,dest,destPost,length)
System.exit(0); //强制退出程序
long a = System.currentTimeMillis();//返回一个毫秒值，是当前世界时与1970年1月1日午夜之间的差，可以用作计时器。
Date类
大部分方法已经被Calendar类所取代。
Date提供时间与日期的支持
Date d = new Date();//返回系统日期与时间
Date d1 = new Date(2020 - 1900,6-1,1);//获取指定时间
long s = d.getTime();//获取距离1970年毫秒数
Calendar类
Calendar类是一个被保护的类，无法通过new来创建对象。
Calendar calendar = Calendar.getInstance();//创建calendar对象
System.out.println(calendar.getTime());//打印时间
int year =calendar.get(Calendar.YEAR);//获取年
int month = calendar.get(Calendar.MONTH);//获取月，从0-11；
int day = calendar.get(Calendar.DAY_OF_MONTH);//日
int hour = calendar.get(Calendar.HOUR_OF_DAY);//小时
int minute = calendar.get(Calendar.MINUTE);//分钟
int second = calendar.get(Calendar.SECOND);//秒
//修改时间
Calendar calendar2 = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH,5);
//add方法修改时间
calendar2.add(Calendar.HOUR,1);//加一个小时；
//获取时间的最大值；
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH)//获取该月的最大天数。
DateFormat类
日期的格式化显示
Date date = new Date();//获取时间对象
DateFormat df1 = DateFormat.getDateInstance();// 获取工具类对象
String time1 = df1.format(date);//获取格式化字符串，time1返回一个集体的日期。
DateFormat df2 = DateFormat.getDateTimeInstance();
String time2 = df2.format(date);//返回一个详细的日期及时间
SimpleDateFormat类
提供了日期与字符串的转换
String day = "2020/04/03 22:32:31";
SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date d1 = df.parse(day)//将字符串转化为Date类型的日期
//日期转字符串
Date d2 = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd===HH:mm:ss");
String s = df.format(d2)//将日期转化为字符串
- y是年
- M是月
- d是日
- H是小时
- m是分
- s是秒
是一个是数学类
- Math.abs(a),求绝对值
- Math.sqrt(a),求平方根
- Math.max(),求最大值
- Math.min(),求最小值
- Math.round(num,2),对浮点数进行四舍五入
- Math.random(),获取0-1的随机数
提供对随机数的支持
//创建random对象
Random rand = new Random();
int r1 = rand.nextInt(100);//获得一个0-100的随机整数
double r2 = rand.nexDouble();//获得一个double类型的随机数
//可以用循环来获取好多
//有范围的1000-1100,只需在r1上加1000；
BigInteger类
表示大整数类，封装了大整数中常见的数学运算。
使用字符串来表示大整数。
BigInteger b1 = new BigInteger("6666666666");
BigInteger b2 = new BigInteger("6666666666");
b1.add(b2);//加法
b1.subtract(b2);//减法
b1.multiply(b2);//乘法
b1.divide(b2);//除法，结果是整数
b1.remainder(b2);//取余
BigDecimal类
对大的小数进行计算。
BigDecimal b1 = new BigDecimal("15.3");
BigDecimal b2 = new BigDecimal("3.0");
b1.add(b2);//加法
b1.subtract(b2);//减法
b1.multiply(b2);//乘法
b1.divide(b2,5,BigDecimal.ROUND_HALF_UP);//除法,保留五位小数
对象克隆
在类中使用Cloneable接口，实现克隆的方法
需要与TimerTask类结合使用，定时执行任务。
//创建timer对象
Timer t1 = new Timer();//定义一个Timer对象，控制定时任务的执行方式
TimerTask task = new TimerTask(){//定义定义任务的内容
public void run(){
//定时执行的内容
}
}；
t1.schedule(task,3000)//3000毫秒后执行，固定时间后执行
//===================================
t1.schedule(task,new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").prase(具体的时间，格式是上面定义的))//在具体的时间执行
//====================================
t1.schedule(task,3000)
//在固定的时间间隔重复执行
t1.schedule(task,2000,3000)//两秒后开始执行，每三秒执行一次
枚举类
使用enum来修饰类，变成枚举类
public enum SeasonEnum {
SPRING("春天"),SUMMER("夏天"),FALL("秋天"),WINTER("冬天");
private final String name;
private SeasonEnum(String name)
{
this.name = name;
}
public String getName() {
return name;
}
}
单例模式
使用场景
- 要求生产唯一序列号
- 计数器
- 连接数据库的对象
步骤
- 定义一个属性，保存当前类的静态对象。
- 构造方法私有
- 创建一个静态get方法返回单例对象
本文共计3113个文字，预计阅读时间需要13分钟。
常用内部类+成员内部类+静态内部类+局部内部类+匿名内部类+内部类是类内部的再定义，编译后生成独立的字节码文件+内部类可以直接访问外部类的私有成员，而不破坏封装性。
常用类 内部类- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
内部类是在类的内部再定义一个完整的类
- 编译后，生成独立的字节码文件
- 内部类可以直接访问外部类的私有成员，而不破坏封装性。
- 可为外部类提供必要的内部组件。
//外部类
public class Animal{
//内部类
class Dog{
}
}
成员内部类
在类的内部定义，与变量实例，实例方法同级别的类。
外部类的一个实例部分，创建内部类对象，必须先创建外部类对象。
当外部类跟内部类存在重名属性时，内部类方法会优先选择内部类属性，如果想访问外部类，要用Outer.this.name;
内部类当中不定义静态成员，但可以包含静态常量final.
public class Outer{
private String name;
class Inner{
private String phone;
public void show(){
system.out.println(name);
system.out.println(phone);
}
}
}
//调用
Outer outer = new Outer();
Inner inner = outer.new Inner();
//或者
Inner inner = new Outer().new Inner();
inner.show();
静态内部类
在内部类的基础上，加一个static关键字,级别与外部类相同。但是可以被外部类使用。
可以直接创建使用，不依赖于外部类对象。
访问外部类的成员变量的时候，要创建外部类对象才能使用，因为静态成员变量级别相当于外部类。
调用时要：外部类.内部类 变量名 = new 内部类.外部类();
定义在外部类的方法中，仅限于方法中调用。
局部变量，类，不能加访问修饰符,同时不能含有static静态修饰符。
访问外部类要加外部类.this.变量；
局部内部类访问当前方法中的局部变量时，因无法保障变量生命周期与自身相同，变量必须修饰为final。
public class Outer{
public void show(){
String address = "山东";
class Inner{
private String phone;
public void show2(){
system.out.println(address)
}
}
Inner inner = new Inner();
inner.show2();
}
}
匿名内部类
是一个没有类名的局部内部类（特征与局部内部类相同）
必须继承一个父类或者实现一个接口。
是定义类，实现类，创建对象的语法合并，只能创建一个该类对象
//匿名内部类相当于在Usb类中创建一个局部内部类。
Usb usb = new Usb(){
public void service(){
//方法实现
}
}
object类
所有的类都直接或间接继承object类。
getClass()方法返回实际对象类型，用于判断两个引用中实际储存对象类型是否一致。
判断两个对象是否是一个类型
hashCode()方法返回对象的哈希码
哈希值是根据对象地址或者字符串或数字使用hash算法计算出来的int类型的数值。
相同对象返回相同的hash值。
- s1与s2hash值不相等，s1与s3相等。
通过调用，将一个Java对象转化成字符串表示形式，建议所有子类重写toString方法。
简写的方法越简洁，易阅读。
是判断两个对象地址是否相等。
默认实现是（this == obj），比较两个地址是否相同。
可以进行覆盖，比较两个对象内容是否相同。
equals重写步骤
public boolean equals(Object obj){
//判断两个对象是否是同一个引用
if(tihs == obj){
return true;
}
if(obj == null){
return false;
}
//if(this.getClass() == obj.getClass())
//instanceof判断对象是否是某种类型
if(obj instanceof Student){
//强制类型转换
Student s = (Student)obj;
//比较属性
if(this.name.equals(s.gerName()) && this.age == s.getAge()){
return true;
}
return false;
}
}
finalize()方法
当对象被判定为垃圾对象时，由jvm自动调用，用于标记垃圾对象，进入垃圾回收队列。
手动回收：使用System.gc();通知jvm执行垃圾回收。
基本类型存储在栈空间。
基本数据类型所对应的引用数据类型。引用数据类型具有可调用的属性跟方法。
包装类的默认值是null。
包装类对应
这样可以将栈空间的数据存放到堆空间中。
类型转换与装箱与拆箱装箱：将基本类型转化为引用类型
拆箱：将引用类型转化为基本类型
拆箱可以调用Number类的方法
- byteValue()
- doubleValue()
- floatValue()
- intValue()
- longValue()
- shortValue()
装箱通过包装类的构造类型来进行转换。
//装箱
int num1 = 13;
Integer integer = new Integer(num1);
//拆箱
int num2 = integer.intValue();
//jbk1.5之后支持自动装箱。
int age = 13;
Integer integer4 = age;
//自动拆箱
int age2 = integer4;
基本类型转化字符串
int n1;
String s = Integer.toString(n1);
字符串转化为基本类型
String str = "123";
int num = Integer.parseInt(str);
Boolean字符串转基本类型。
"true" -> true,非"true" -> false
String str = "true";
boolean b1 = Boolean.parseBoolean(str);
Integer缓冲区
Integer类型在堆空间内会有-128-127的缓存，在-128-127之内时，是直接从堆空间内调用，而超过127后，才会重新创建空间来存储值。
String类字符串是常量，创建后不可改变
字符串值是存储在字符串池中，可以共享。
String name = "hello";//hello会存储在字符串池中
name = "zhangsan";//在字符串池中开辟新空间，name指向新的zhangsan。
String name2 = "zhangsan";//name2与name指向同一个字符串，地址相同。
//对象的方式创建。
String s = new String("zhangsan");//会在栈里创建name，堆里创建“zhangsan”，方法池里也创建“zhangsan”，堆中的zhangsan指向方法池中的对象。
常用方法
- length(),获取字符串长度，空格也算一个字符。
- charAt(int index),返回某个位置字符串
- contains(String),判断是否含有某个子字符串。
- toCharArray();返回字符串对应的数组
- indexOf(String str);返回子字符串首次出现的位置
- lastIndexOf(String str);返回字符串最后出现的位置
- trim();去掉字符串前后的空格
- toUpperCase();把小写转化成大写
- toLowerCase();大写转化成小写
- endWith(str);判断是否已str结尾
- starWith(str);判断是否以str开头。
- replace();用新的字符或字符串替换旧的字符或字符串
- split();对字符串进行拆分
- equals();对两个字符串进行比较，equalslsIgnoreCase()忽略大小写。
- compareTo();比较大小
StringBuffer:可变长字符串，运行效率慢，线程不安全。
StringBuilder:可变长字符串，运行效率快，线程不安全。
方法：
- append()追加
- insert()添加
- replace()替换
- delete()删除
- delete(0,sb.length())清空
StringBuilder sb = new StringBuilder();
sb.append("asdas");//z追加字符串
sb.insert(0,"我在组前面");//在指定位置添加字符串。
sb.replace(head,last,str);//把指定区域内的字符串替换
sb.delete(head,last);//指定位置的字符删除
与string的区别：
- 效率高，节省内存
系统类，主要提供系统的属性和方法
System类无构造方法，只有定义成静态方法，直接用类名调用，system的属性和方法都是静态的
例如
system.out.println();
就是调用system当中的println方法
//src：原数组，srcpos：复制开始位置，dest:目标数组，destPos:目标数组位置，length:复制长度
System.arraycopy(src,srcPos,dest,destPost,length)
System.exit(0); //强制退出程序
long a = System.currentTimeMillis();//返回一个毫秒值，是当前世界时与1970年1月1日午夜之间的差，可以用作计时器。
Date类
大部分方法已经被Calendar类所取代。
Date提供时间与日期的支持
Date d = new Date();//返回系统日期与时间
Date d1 = new Date(2020 - 1900,6-1,1);//获取指定时间
long s = d.getTime();//获取距离1970年毫秒数
Calendar类
Calendar类是一个被保护的类，无法通过new来创建对象。
Calendar calendar = Calendar.getInstance();//创建calendar对象
System.out.println(calendar.getTime());//打印时间
int year =calendar.get(Calendar.YEAR);//获取年
int month = calendar.get(Calendar.MONTH);//获取月，从0-11；
int day = calendar.get(Calendar.DAY_OF_MONTH);//日
int hour = calendar.get(Calendar.HOUR_OF_DAY);//小时
int minute = calendar.get(Calendar.MINUTE);//分钟
int second = calendar.get(Calendar.SECOND);//秒
//修改时间
Calendar calendar2 = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH,5);
//add方法修改时间
calendar2.add(Calendar.HOUR,1);//加一个小时；
//获取时间的最大值；
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH)//获取该月的最大天数。
DateFormat类
日期的格式化显示
Date date = new Date();//获取时间对象
DateFormat df1 = DateFormat.getDateInstance();// 获取工具类对象
String time1 = df1.format(date);//获取格式化字符串，time1返回一个集体的日期。
DateFormat df2 = DateFormat.getDateTimeInstance();
String time2 = df2.format(date);//返回一个详细的日期及时间
SimpleDateFormat类
提供了日期与字符串的转换
String day = "2020/04/03 22:32:31";
SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date d1 = df.parse(day)//将字符串转化为Date类型的日期
//日期转字符串
Date d2 = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd===HH:mm:ss");
String s = df.format(d2)//将日期转化为字符串
- y是年
- M是月
- d是日
- H是小时
- m是分
- s是秒
是一个是数学类
- Math.abs(a),求绝对值
- Math.sqrt(a),求平方根
- Math.max(),求最大值
- Math.min(),求最小值
- Math.round(num,2),对浮点数进行四舍五入
- Math.random(),获取0-1的随机数
提供对随机数的支持
//创建random对象
Random rand = new Random();
int r1 = rand.nextInt(100);//获得一个0-100的随机整数
double r2 = rand.nexDouble();//获得一个double类型的随机数
//可以用循环来获取好多
//有范围的1000-1100,只需在r1上加1000；
BigInteger类
表示大整数类，封装了大整数中常见的数学运算。
使用字符串来表示大整数。
BigInteger b1 = new BigInteger("6666666666");
BigInteger b2 = new BigInteger("6666666666");
b1.add(b2);//加法
b1.subtract(b2);//减法
b1.multiply(b2);//乘法
b1.divide(b2);//除法，结果是整数
b1.remainder(b2);//取余
BigDecimal类
对大的小数进行计算。
BigDecimal b1 = new BigDecimal("15.3");
BigDecimal b2 = new BigDecimal("3.0");
b1.add(b2);//加法
b1.subtract(b2);//减法
b1.multiply(b2);//乘法
b1.divide(b2,5,BigDecimal.ROUND_HALF_UP);//除法,保留五位小数
对象克隆
在类中使用Cloneable接口，实现克隆的方法
需要与TimerTask类结合使用，定时执行任务。
//创建timer对象
Timer t1 = new Timer();//定义一个Timer对象，控制定时任务的执行方式
TimerTask task = new TimerTask(){//定义定义任务的内容
public void run(){
//定时执行的内容
}
}；
t1.schedule(task,3000)//3000毫秒后执行，固定时间后执行
//===================================
t1.schedule(task,new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").prase(具体的时间，格式是上面定义的))//在具体的时间执行
//====================================
t1.schedule(task,3000)
//在固定的时间间隔重复执行
t1.schedule(task,2000,3000)//两秒后开始执行，每三秒执行一次
枚举类
使用enum来修饰类，变成枚举类
public enum SeasonEnum {
SPRING("春天"),SUMMER("夏天"),FALL("秋天"),WINTER("冬天");
private final String name;
private SeasonEnum(String name)
{
this.name = name;
}
public String getName() {
return name;
}
}
单例模式
使用场景
- 要求生产唯一序列号
- 计数器
- 连接数据库的对象
步骤
- 定义一个属性，保存当前类的静态对象。
- 构造方法私有
- 创建一个静态get方法返回单例对象