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执行垃圾回收。

包装类

基本类型存储在栈空间。
基本数据类型所对应的引用数据类型。引用数据类型具有可调用的属性跟方法。
包装类的默认值是nul 江西红色教育培训 www.ctbuganxun.com l。

包装类对应

这样可以将栈空间的数据存放到堆空间中。

类型转换与装箱与拆箱

装箱：将基本类型转化为引用类型
拆箱：将引用类型转化为基本类型

拆箱可以调用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方法返回单例对象