java常用类

java常用类 1内部类 1.2成员内部类

说白了就是普通的内部类

在类的内部定义，与实例变量、实例方法同级别的类。外部类的一个实例部分，创建内部类对象时，依赖外部类对象
Outer outer = new Outer();
Inner inner = outer.new Inner();内部类、外部类存在重名属性时，优先访问内部属性内部类中不可以定义静态成员，但是可以定义final常量 1.3静态内部类

说白了就是加static的内部类

不依赖外部类对象，可直接创建或者通过类名访问，可声明静态成员
Outer.Inner inner = new Outer.Inner();
Outer.Inner.show() //调用等级相当于普通的外部类只有静态内部类可以用static修饰，普通的类不可以加static 1.4局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法局部内部类访问外部方法中的局部变量时，因为无法保证变量的声明周期与自身相同，变量必须修饰为final (jdk1.7以前需要写final,jdk1.8之后默认是final)局部内部类与外部方法中的成员变量同一级别 1.5匿名内部类

必须继承一个父类或者实现一个接口定义类、实现类、创建类的语法合并也可说是没有类名的局部内部类作用：减少代码量，但是代码可能会变得难懂
创建代码过程如下所示：

public class application {
    public static void main(String[] args) {
        //new实现类
        usb u1 = new usbimpl();
        u1.start();

        //局部内部类
        class fun implements usb{
            @Override
            public void start() {
                System.out.println("风扇开始运转了......");
            }
        }
        usb u2 = new fun();
        u2.start();

        //匿名内部类实现
        usb u3 = new usbimpl(){
            @Override
            public void start() {
                System.out.println("内部类......");
            }
        };
        u3.start();
    }
}

2object类 2.1 getclass()方法

返回对象类型用来判断两个对象的类型是否一致

public class test {
    public static void main(String[] args) {
        demoA a = new demoA();
        demoA b = new demoA();

        Class s1 = a.getClass();
        Class s2 = b.getClass();

        if(s1==s2){
            System.out.println("对象s1和s2一个类型");
        }else {
            System.out.println("对象s1和s2不一个类型");
        }

        System.out.println("======================");

        demoA a1 = new demoA();
        demoB b1 = new demoB();

        Class s3 = a1.getClass();
        Class s4 = b1.getClass();

        if(s3==s4){
            System.out.println("对象s3和s4一个类型");
        }else {
            System.out.println("对象s3和s4不一个类型");
        }
    }
}

2.2 hashCode()方法

通过对象的地址值来计算hash值也可以通过返回的哈希值判断是否是一个对象返回值是哈希值 2.3 toString() 方法

返回对象的字符串类型加哈希值也可以自己去重写这个方法 2.4 equals() 方法

用来判断两个对象是否相等，比较的是地址值s1.equals(s2)，返回值是布尔值，要么是false，要么true也可对其进行覆盖，看两个对象的内容是否相同也可比较字符串是否相等 2.5 finalize() 方法

不用的对象会自动被 finalize() 方法回收，JVM调用的手动回收机制，调用System.gc()方法，提醒JVM回收垃圾，但是回收不回收另说 3 包装类

包装类一般是基本数据类型的首字母大写，包装类中内置的有相应的方法可以使用

3.1装箱与拆箱 *** 作

普通数据类型和对象数据类型之间的转换称为装箱与拆箱，普通数据类型存放在栈而对象类型存放在堆

JDK1.5之后，装箱与拆箱 *** 作自动进行 3.2基本数据类型与字符串之间转换 3.2.1基本类型转字符串

若是int类型，使用int包装类中Integer中的toString()方法

3.2.2字符串转基本类型

使用Integer中的parseXXX()方法来转换

boolean类型 “true”->true, 非"true"->false,使用的是Boolean包装类中的parseBoolean()方法 3.3整数缓冲区

面试题
java预先创建了我们平时开发常用的256个整数包装类型，减少jvm的工作量，需要时直接调用，即在开发中对已创建的对象进行复用

public class test1 {
    public static void main(String[] args) {
        //new对象来比较
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);

        //自动装箱 *** 作 把int转为对象
        Integer integer3 = 100;
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);

        //自动装箱其实就是在调用valueOf()方法
        //Integer integer5 = Integer.valueOf(200)
        
        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5== integer6);
        
    }
}

4 String类 4.1 字符串的存储

public class test2 {
    public static void main(String[] args) {
        //定义字符串
        String str1 = "java";
        //修改字符串
        str1 = "happy";
        String str2 = "zhangsan";
        


        //演示字符串的另外一种创建方式,new String();
        
        String name = new String("java");
        String name1 = new String("java");
        //比较的是地址值
        //使用String.equal()方法比较的是字符串内容
        System.out.println(name == name1);
        System.out.println(name.equals(name1));


    }
}

内存图

面试可能会问这条语句创建几个对象

 String name = new String("java");

答：堆和字符串池中各创建一个对象

5 BigDecimal类

java中的浮点数采用近似值，如果需要使用精确值就要使用BigDecimal类

public class demo03 {
    public static void main(String[] args) {
        //java中采用近似值,而不是精确值
        double x1 = 1.0;
        double x2 = 0.9;
        System.out.println(x1-x2);

        //面试题
        
        double result = (1.4-0.5)/0.9;
        System.out.println(result);

        //BigDecimal实现
        //特点就是要使用字符串传值 更加精确

        //减法
        BigDecimal d1 = new BigDecimal("1.0");
        BigDecimal d2 = new BigDecimal("0.9");
        System.out.println(d1.subtract(d2));
        //加法
        BigDecimal d3 = new BigDecimal("1.0");
        BigDecimal d4 = new BigDecimal("0.9");
        System.out.println(d3.add(d4));
        //乘法
        BigDecimal d5 = new BigDecimal("1.0");
        BigDecimal d6 = new BigDecimal("0.9");
        System.out.println(d5.multiply(d6));

        //除法
        BigDecimal d7 = new BigDecimal("1.0");
        BigDecimal d8 = new BigDecimal("0.2");
        System.out.println(d7.divide(d8));
        
    }
}

除法需要四舍五入设置一些参数
6 Date类

package com.kuang.cyclass.outerclass;

import java.util.Date;

public class demo04 {
    public static void main(String[] args) {
        //创建Date()对象
        Date d1 = new Date();

        //今天
        System.out.println(d1.toString());

        //昨天
        Date d2 = new Date(d1.getTime()- 60*60*24*1000);
        System.out.println(d2.toString());

        //方法 after before
        //就是看一天是否在另外一天的前后
        boolean b1 = d1.after(d2);
        System.out.println(b1);
        boolean b2 = d1.before(d2);
        System.out.println(b2);

        //compare比较 这里比较的是毫秒数 正负就代表大小
        int x = d1.compareTo(d2);
        System.out.println(x);
        
    }
}

7 Calender类

import java.util.Calendar;
public class demo05 {
    public static void main(String[] args) {
        //1 Calender的使用
        //想使用方法,必须这样实例化对象
        Calendar ca1 = Calendar.getInstance();
        System.out.println(ca1.getTime());
        System.out.println(ca1.getTimeInMillis());

        //2 获取时间信息
        //获取年
        int year = ca1.get(Calendar.YEAR);
        //获取月
        //老外的月份是0~11
        int month = ca1.get(Calendar.MONTH)+1;
        //获取日
        int day = ca1.get(Calendar.DAY_OF_MONTH);
        //获取小时
        int hour = ca1.get(Calendar.HOUR_OF_DAY);
        //获取分
        int minnute = ca1.get(Calendar.MINUTE);
        //获取秒
        int second = ca1.get(Calendar.SECOND);

        System.out.println(year+"年"+month+"月"+day+"日"+hour+"时"+minnute+"分"+second+"秒");

        //3 set修改时间信息
        Calendar c2 = Calendar.getInstance();
        //使用set方法把日改成5
        System.out.println(c2.getTime());
        c2.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(c2.getTime());

        //4 add方法修改时间
        Calendar c3 = Calendar.getInstance();
        System.out.println(c3.getTime());
        //使用add方法把小时增加
        c3.add(Calendar.HOUR_OF_DAY,1);
        System.out.println(c3.getTime());
        
    }
}

8 SimpleDateFormat类

public class demo06 {
    public static void main(String[] args) throws Exception{
        //格式化时间
        //由这个例子 去理解这个方法
        //等于是提供了一个方法,让时间作为字符串返回给开发人员使用
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

        //创建date 获取时间
        Date date = new Date();
        //1 把日期转成字符串
        String str2 = sdf1.format(date);
        String str = sdf.format(date);
        System.out.println(str);
        System.out.println(str2);

        //2 把字符串转成日期
        //转换要按照格式在进行
        Date date2 = sdf.parse("2020/12/26 16:00:23");
        System.out.println(date2);
      
    }
}

9 System类

public class demo07 {
    public static void main(String[] args) {

        //1. arraycopy() 数组复制

        int [] a ={1,4,5,7,3,2,5,6};
        int [] b = new int[8];
        
        System.arraycopy(a,0,b,0,8);
        for (int i : b) {
            System.out.print(i+" ");
        }
        System.out.println();

        //2. currentTimeMillis()方法 返回当前时间的毫秒 常用来计算程序的执行时间

        long strat = System.currentTimeMillis();
        for(int i = -999999999; i < 999999999;i++){
            for(int j = -999999999; j < 999996999; j++){
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("程序执行用时："+(end-strat));

        //3. gc()方法
        //提示jvm清理内存垃圾
        System.gc();

        //4. exit()方法
        //手动终止jvm
        System.exit(0);
        System.out.println("系统终止");
        //从这个系统终止没有被输出到屏幕上就知道jvm已经手动被停止
        
    }
}