Java入土---常用类

常用类 内部类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

内部类是在类的内部再定义一个完整的类

1. 编译后，生成独立的字节码文件
2. 内部类可以直接访问外部类的私有成员，而不破坏封装性。
3. 可为外部类提供必要的内部组件。

//外部类
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相等。

toString()方法

通过调用，将一个Java对象转化成字符串表示形式，建议所有子类重写toString方法。
简写的方法越简洁，易阅读。

equals()方法

是判断两个对象地址是否相等。
默认实现是（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的属性和方法都是静态的

例如
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类

是一个是数学类

• Math.abs(a),求绝对值
• Math.sqrt(a),求平方根
• Math.max(),求最大值
• Math.min(),求最小值
• Math.round(num,2),对浮点数进行四舍五入
• Math.random(),获取0-1的随机数

Random类

提供对随机数的支持

//创建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接口，实现克隆的方法

Timer定时器

需要与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;
    }
}

单例模式

使用场景

• 要求生产唯一序列号
• 计数器
• 连接数据库的对象

步骤

1. 定义一个属性，保存当前类的静态对象。
2. 构造方法私有
3. 创建一个静态get方法返回单例对象