常用类

文章目录

- 常用类

1.成员内部类

在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
- A a = new a();
- A.B b= new A().new B();
当外部类、内部类存在重名属性时，会优先访问内部类属性
成员变量不能定义静态成员

// 外部类
public class NeiBuLei01 {

    private String name = "番茄";
    private int age = 62;

    //内部类
    class Test{
        private String name = "李四";
        //private final static int age = 60;//成员内部类里不能定义静态成员、可以包含静态常量(final)
         public void show(){
             System.out.println(name); //李四
             //打印外部类属性 此时有重名属性name
             System.out.println(NeiBuLei01.this.name);//张三
             System.out.println(age);//62

         }
    }



}

测试类

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

        //创建外部类对象
        NeiBuLei01 neiBuLei01 = new NeiBuLei01();
        //创建内部类对象
        NeiBuLei01.Test test = neiBuLei01.new Test();
        test.show();
        System.out.println("==============================");
        //一步到位
        NeiBuLei01.Test test2 = new NeiBuLei01().new Test();

        test2.show();


    }
}

2.静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
只能直接访问外部类的静态成员(实例化需要实例化外部类对象)

//外部类
public class JingTaiNeiBuLei {
    private String name = "张三";
    private int age = 16;

    //静态内部类;和外部类相同
    static class Inner{
        private String address = "广东";
        private String phone = "111";
        //静态成员
        private static int age = 17;

        public void show(){
            //调用外部类的属性呢
            //1.创建外部类对象
            JingTaiNeiBuLei jingTaiNeiBuLei = new JingTaiNeiBuLei();
            //2.调用外部类的属性
            System.out.println(jingTaiNeiBuLei.name);
            System.out.println(jingTaiNeiBuLei.age);
            //3.调用静态内部类的属性和方法
            System.out.println(this.address);
            System.out.println(this.phone);
            //4.调用静态内部类的属性
            System.out.println(Inner.age);

        }
    }
}

测试类

public class Test01 {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        JingTaiNeiBuLei.Inner inner = new JingTaiNeiBuLei.Inner();
        //调用方法
        inner.show();
    }
}

3.局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final

//外部类
public class JuBuNeiBuLei {
    //实例变量
    private String name = "番茄";
    private int age = 17;

    //方法
    public void show(){
        //定义局部变量：注意不能加任何访问修饰符
        String address1 = "深圳";

        //局部内部类:注意不能加任何访问修饰符
        class Inner{
            private String name = "小明";
            private String address = "广东";
            private int phone = 110;

            //方法
            public void show2(){
                //打印外部类属性
                System.out.println(JuBuNeiBuLei.this.name);
                System.out.println(age);//相当于JuBuNeiBuLei.this.age

                //打印内部类的属性
                System.out.println(this.name);
                System.out.println(this.address);
                System.out.println(this.phone);

                //打印局部变量  jdk1.7要求必须常量final、jdk1.8自动添加final
                System.out.println(address1);


            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();

    }
    }

public class Test02 {
    public static void main(String[] args) {
        JuBuNeiBuLei juBuNeiBuLei = new JuBuNeiBuLei();
        juBuNeiBuLei.show();

    }
}

4.匿名内部类

没有类名的局部类(一切特征都与局部内部类相同)
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点:

减少代码量
缺点:

可读性较差

public interface Usb {
    void show();
}

public class NiMingNeiBuLei implements Usb{

    @Override
    public void show() {
        System.out.println("接口实现成功");
    }
}

public class Test03 {
    public static void main(String[] args) {
        Usb niMingNeiBuLei = new NiMingNeiBuLei();
        niMingNeiBuLei.show();
        System.out.println("==========================");


        //局部内部类
        class Fen implements Usb{

            @Override
            public void show() {
                System.out.println("局部内部类接口实现成功");
            }
        }
        //使用局部内部类创建对象
        Usb usb = new Fen();
        usb.show();
        System.out.println("=====================================");


        //使用匿名内部类优化
        Usb usb1 = new Usb() {
            @Override
            public void show() {
                System.out.println("匿名内部类接口实现成功");
            }
        };
        usb1.show();
    }
}

5.Object类

类层次的根类
所有类都直接或间接的继承该类
所有子类都默认访问父类的无参构造方法

Object类的常用方法

方法	说明
Object clone()	创建与该对象的类相同的新对象
boolean equals(Object)	比较两个对象是否相等。默认比较的是地址值
void finalize()	当垃圾回收器确定不存在对该对象的更多引用时，对象的圾回收器调用该方法
Class getClass()	返回一个对象运行时的实例类（.class文件）
int hashCode()	返回该对象的散列码值(对象的内存地址)
void notify()	激活等待在该对象的监视器上的一个线程
void notifyAll()	激活等待在该对象的监视器上的全部线程
String toString()	返回该对象的字符串表示，默认返回运行时类名+@+对象的hashCode的16进制数
void wait()	在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待

Object的第一个方法：getClass()

public final Class<?> getClass(){}
返回引用类型中存储的实际对象
应用：通常用于判断两个引用中实际存储对象类型是否一致

public class ObjectDeGetClass {
    private String name;
    private int age;

    public ObjectDeGetClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public ObjectDeGetClass() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Test04 {
    public static void main(String[] args) {
        ObjectDeGetClass objectDeGetClass = new ObjectDeGetClass("番茄",21);
        ObjectDeGetClass objectDeGetClass1 = new ObjectDeGetClass("西红柿",26);
        Class class1 = objectDeGetClass.getClass();
        Class class2 = objectDeGetClass1.getClass();
        if(class1==class2){ //是相同的
            System.out.println("他们的类型是相同的"); 
        }else{
            System.out.println("他们的类型是不相同的");
        }
    }
}

Object的第二个方法：hashCode()

public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或者字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

//hashCode方法
System.out.println(objectDeGetClass.hashCode());
System.out.println(objectDeGetClass1.hashCode());  //跟objectDeGetClass.hashCode()不一样
ObjectDeGetClass objectDeGetClass2 = objectDeGetClass;
System.out.println(objectDeGetClass2.hashCode()); //跟objectDeGetClass.hashCode()一样

Object的第三个方法：toString()方法

public String toString(){}
返回改对象的字符串表示(表现形式)

可以根据程序需求覆盖该方法，如：展示对象各个属性值

//toString方法
System.out.println(objectDeGetClass.toString());//ObjectDeGetClass{name='番茄', age=21}
System.out.println(objectDeGetClass1.toString());//ObjectDeGetClass{name='西红柿', age=26}

Object的第四个方法：equals()方法

public boolean equals(Object obj){}
默认实现为(this == obj) , 比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同

equals()方法覆盖步骤

比较两个引用是否指向同一个对象
判断Object是否为null
判断两个引用指向的实际对象类型是否一致
强制类型转换

以此比较各个属性值是否相同

//equals()方法
System.out.println(objectDeGetClass.equals(objectDeGetClass1));//false

ObjectDeGetClass objectDeGetClass3 = new ObjectDeGetClass("小明",21);
ObjectDeGetClass objectDeGetClass4 = new ObjectDeGetClass("小明",21);
System.out.println(objectDeGetClass3.equals(objectDeGetClass4));//false 重写equals方法后让其为true

finalize()方法

Java提供了一种在对象即将被销毁时执行资源释放的方法
在Java中，我们创建对象，但是我们不能销毁对象
JVM运行一个称为垃圾收集器的低优先级特殊任务来销毁不再引用的所有对象
垃圾回收器给我们一个机会，在对象被销毁之前执行清理代码
垃圾对象:没有有效引用指向对象时，为垃圾对象
垃圾回收:由GC销毁垃圾对象，释放数据存储空间
自动回收机制:JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制:使用System.gc():通知JVM执行垃圾回收

@Override
protected void finalize() throws Throwable {
    System.out.println(this.name+"对象被回收了");
    super.finalize();
}

6.包装类

什么是包装类？

基本数据类型

所对应的

引用数据类型
Object可统一所有数据，包装类的默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

7.类型转换与装箱、拆箱

8种包装类提供不用类型间的转换方式
- Number父类中提供的6个共性方法
  1. parseXXX( )
    静态方法
  2. valueOf( )
    静态方法
**注意：**需保证类型兼容，否则抛出NumberFormatException异常

package Demo24;

/**
 * @author fanqie
 * @date 2021/3/19 -16:26
 * 装箱和拆箱
 */
public class ZhuangXiangHeChaiXiang {
    public static void main(String[] args) {
        //基本转换:装箱，基本类型转成引用类型的过程

        //基本类型
        int num = 11;

        //使用Integer类创建对象
        Integer integer1 = new Integer(num);
        Integer integer2 = Integer.valueOf(num);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        //基本转换:拆箱，引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        System.out.println("============================");
        //在jdk5之后,提供自动拆箱和装箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);

        System.out.println("=================");
        //基本类型和字符串之间转换
        //1.基本类型和字符串之间转换
        int n1 = 255;
        //1.1使用+号
        String s1= n1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1,16);//f
        System.out.println(s1);//255
        System.out.println(s2);//ff

        //2.字符串转换为基本类型
        String str = "150";
        //使用Integer.parseXXX()
        int n2 = Integer.parseInt(str);
        System.out.println(n2);//150

        //boolean字符串形式转成基本类型"true"----->true 非"true" ------------false
        String str2 = "true";
        String str3 = "true22";
        boolean b1 = Boolean.parseBoolean(str2);
        boolean b2 = Boolean.parseBoolean(str3);
        System.out.println(b1);//true
        System.out.println(b2);//false
    }
}

8.整数缓冲区

Java预先创建了256个常用的证书包装类型对象
在实际应用当中，对已创建的对象进行复用

package Demo24;

/**
 * @author fanqie
 * @date 2021/3/26 -15:26
 * 整数缓冲区
 */
public class Integer_HuanChongQu {
    public static void main(String[] args) {
        //面试题
        Integer a = new Integer(100);
        Integer b = new Integer(100);
        System.out.println(a==b);//false

        // 相当于调用 Integer.valueOf(100);
        Integer c = 100;//自动装箱
        Integer d = 100;
        System.out.println(c==d);//true

        Integer e = 200;//自动装箱
        Integer f = 200;
        System.out.println(e==f);//false
        // 因为缓存区数组 [-128, 127] 在这之内地址一样

    }


}

9.String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享
String s = "Hello";
产生一个对象，字符串池中存储
String s = new String("Hello");
产生两个对象，

堆、池

各一个

常用方法

package Demo24;

import java.util.Arrays;
import java.util.Locale;

/**
 * @author fanqie
 * @date 2021/3/26 -15:37
 * String
 */
public class string_01 {
    public static void main(String[] args) {
        String  name = "hello";
        name = "zhangsan";

        //字符串的另一种创建方式
        String str = new String("java");
        String str1 = new String("java");
        System.out.println(str == str1);//false
        System.out.println(str.equals(str1));//true

        //字符串方法的使用
        // 1. length(); 返回字符串长度
        // 2. charAt(int index); 返回某个位置的字符
        // 3. contains(String str); 判断是否包含某个字符串

        System.out.println("==============字符串方法的使用==================");
        String a = "java是世界上java最好的编程语言,java真香";
        System.out.println(a.length());
        System.out.println(a.charAt(10));
        System.out.println(a.charAt(a.length()-1));//最后一个
        System.out.println(a.contains("好"));//true

        // 4. toCharArray(); 返回字符串对应数组
        // 5. indexOf(); 返回子字符串首次出现的位置
        // 6. lastIndexOf(); 返回字符串最后一次出现的位置

        System.out.println("==============字符串方法的使用2==================");
        System.out.println(a.toCharArray());
        System.out.println(Arrays.toString(a.toCharArray()));
        System.out.println(a.indexOf("java"));//0
        System.out.println(a.indexOf("java",4));//从索引4开始找 返回8
        System.out.println(a.lastIndexOf("java"));//最后出现的位置 20


        // 7. trim(); //去掉字符串前后空格
        // 8. toUpperCase(); toLowerCase(); 转换大小写
        // 9. endWith(str); startWith(str);  判断是否以str 结尾、开头
        System.out.println("==============字符串方法的使用3==================");
        String content = " hello word ";
        System.out.println(content.trim());//"hello word"
        System.out.println(content.toUpperCase());//" HELLO WORD "
        System.out.println(content.toLowerCase());//" hello word "
        String content2 = "hello.java";
        System.out.println(content2.endsWith("java"));//true
        System.out.println(content2.startsWith("hello"));//true


        // 10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
        // 11. split(); 对字符串拆分
        System.out.println("==============字符串方法的使用4==================");
        System.out.println(content2.replace("java","php"));//hello.php

        String say = "java is the best  programing language,java xiang";
        String [] arr = say.split("[ ,]+");
        System.out.println(arr.length);
        for (String s : arr) {
            System.out.println(s);
        }

        // 补充两个equals/compareTo();比较大小
        // compareTo(); 两字符不同时比较字符字典序的ascii码
        // 字符相同时比较长度 返回差值
        System.out.println("===============补充===================");
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true 忽略大小写的比较

        String s3 = "abc";//97
        String s4 = "xzy";//120
        System.out.println(s3.compareTo(s4));//-23

        





    }
}

案例演示

需求：

已知String str = “this is a text”;
将str中的单词单独获取
将str中的text替换成practice
在text前面插入一个easy
将每个单词的首字母改为大写

package Demo24;

import java.util.Arrays;

/**
 * @author fanqie
 * @date 2021/3/26 -15:37
 * String
 */
public class string_02 {
    public static void main(String[] args) {
       /*
       1. 已知String str = "this is a text";
       2. 将str中的单词单独获取
       3. 将str中的text替换成practice
       4. 在text前面插入一个easy
       5. 将每个单词的首字母改为大写
        */

        String str = "this is a text";
        //1. 将str中的单词单独获取
        System.out.println("----------1.将str中的单词单独获取------------------");
        String[] arr = str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }

        //2.将str中的text替换成practice
        System.out.println("-------------2.将str中的text替换成practice---------------");
        String str2 = str.replace("text", "practice");
        System.out.println(str2);

        //3.在text前面插入一个easy
        System.out.println("-------------3.在text前面插入一个easy---------------");
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);

        //4.将每个单词的首字母改为大写90000000安士·东方新城2
        System.out.println("-------------4.将每个单词的首字母改为大写---------------");
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            char upperfirst = Character.toUpperCase(first);
            String cccc = upperfirst + arr[i].substring(1);
            System.out.println(cccc);


        }
    }
}

10.可变字符串

StringBuffer : 可变长字符串，运行效率慢、线程安全
StringBuilder : 可边长字符串、运行快、线程不安全
效率都比String高且节省内存

package Demo24;

/**
 * @author fanqie
 * @date 2021/3/31 -14:35
 * StringBuffer和StringBuilder的使用
 * StringBuffer : 可变长字符串，运行效率慢、线程安全
 * StringBuilder : 可边长字符串、运行快、线程不安全
 * 效率都比String高且节省内存
 */
public class StringBuffer_Builder {
    public static void main(String[] args) {
        StringBuffer sb =new StringBuffer();
        // StringBuffer 和 StringBuilder 用法一致,建议用StringBuilder
        // 1. append(); 追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());
        sb.append("java不错");
        System.out.println(sb.toString());

        // 2. insert(); 添加、插入
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());

        // 3.replace(); 替换
        sb.replace(0,5,"hello");// 左闭右开
        System.out.println(sb.toString());

        // 4. delete(); 删除
        sb.delete(0,5);// 左闭右开
        System.out.println(sb.toString());

        // 5. 清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

package Demo24;

import java.math.BigDecimal;

/**
 * @author fanqie
 * @date 2021/3/31 -15:18
 * BigDecimal
 */
public class BigDecimal_01 {
    public static void main(String[] args) {
        BigDecimal big1 = new BigDecimal("20.0");
        BigDecimal big2 = new BigDecimal("3.0");

        // 减法
        BigDecimal r1 = big1.subtract(big2);
        System.out.println(r1);

        // 加法
        BigDecimal r2 = big1.add(big2);
        System.out.println(r2);

        // 乘法
        BigDecimal r3 = big1.multiply(big2);
        System.out.println(r3);

        // 除法
        //除不尽时 x填保留位数 后面为四舍五入之意
        //BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"), x, BigDecimal.ROUND_HALF_UP);
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"), 2, BigDecimal.ROUND_HALF_UP);
        System.out.println(r4);

        BigDecimal r5 = big1.divide(big2,2, BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}

11.Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

package Demo24;

import java.util.Date;

/**
 * @author fanqie
 * @date 2021/3/31 -15:59
 * Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
 * 时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns
 */
public class Date_01 {
    public static void main(String[] args) {
        // 1 创建Date对象
        Date date1 = new Date();
        System.out.println(date1.toString()); //WED Sept 02 22:25:23 CST 2020
        System.out.println(date1.toLocaleString()); // 已过时 但也能用 2020-9-2

        // 创建昨天的
        Date date2 = new Date(date1.getTime() - (60*60*24*1000));
        System.out.println(date2.toLocaleString());

        // 2 方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1); //true
        boolean b2 = date1.before(date2);
        System.out.println(b2); //false

        // 比较compareTo();
        int d = date1.compareTo(date1);
        System.out.println(d); // 多的为1 少的为 -1

        // 比较是否相等 equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3); // false
    }
    }

12.Calendar

Calendar提供了获取或设置各种日历字段的方法
构造方法
protected Calendar();
由于是protected 所以无法直接创建
其他方法

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒
int get(int field)	返回给定日历字段的值。字段比如年、月、日
void setTime(Date date)	用给定的date设置此日历时间
Date getTime()	返回一个date表示此日历的时间
void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMilles()	毫秒为单位返回该日历的时间值

package Demo24;

import java.util.Calendar;

/**
 * @author fanqie
 * @date 2021/3/31 -16:02
 * Calendar提供了获取或设置各种日历字段的方法
 * 构造方法 `protected Calendar();` 由于是protected 所以无法直接创建
 */
public class Calendar_01 {
    public static void main(String[] args) {
        // 1. 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toString());//Wed Mar 31 16:11:06 CST 2021
        System.out.println(calendar.getTime().toLocaleString());//2021-3-31 16:11:35
        System.out.println(calendar.getTimeInMillis());

        // 2. 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);

        // 获取月 从 0 - 11
        int month = calendar.get(Calendar.MONTH);

        // 日 两种方法: DAY_OF_MONTH 和 DATE
        int month1 = calendar.get(Calendar.DAY_OF_MONTH);
        int day = calendar.get(Calendar.DATE);
        System.out.println(day);//31

        // 小时
        //HOUR是12小时 HOUR_OF_DAY是24小时
        int hour1 = calendar.get(Calendar.HOUR);
        System.out.println(hour1);//4
        int hour = calendar.get(Calendar.HOUR_OF_DAY);

        // 分钟
        int minute = calendar.get(Calendar.MINUTE);

        // 秒
        int second = calendar.get(Calendar.SECOND);

        System.out.println(year+"年"+(month+1)+"月"+month1+"日"+hour+":"+minute+":"+second);//2021年3月31日16:23:30

        // 3. 修改时间
        Calendar calendar2 =  calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);//修改了日
        System.out.println(calendar2.getTime().toLocaleString());//2021-3-5 16:25:39

        // 4. add修改时间
        //calendar2.add(Calendar.HOUR, x); // x为正就加 负就减
        calendar2.add(Calendar.HOUR,1);//增加了一个小时
        System.out.println(calendar2.getTime().toLocaleString());//2021-3-5 17:26:59

        // 5. 补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);//最大值（月）
        int mum = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);//最小值 (月)
        System.out.println(max);//31
        System.out.println(mum);//1

    }

}

13.SimpleDateFormat

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期→文本）、解析（文本→日期）
常用的时间模式字母

字母	日期或时间	示例
y	年	2019
08	年中月份	08
d	月中天数	10
H	一天中小时（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	356

package Demo24;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author fanqie
 * @date 2021/3/31 -16:30
 * - SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
 * - 进行格式化（日期→文本）、解析（文本→日期）
 * - 常用的时间模式字母
 */
public class SimpleDateFormat_01 {
    public static void main(String[] args) throws Exception {
        // 1. 创建对象 y年 M 月
        //SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // 2. 创建Date
        Date date = new Date();

        // 格式化date（日期→字符串）
        String str = simpleDateFormat.format(date);
        System.out.println(str);

        // 解析（字符串→时间）
        Date date1 = simpleDateFormat.parse("2020/05/01");
        System.out.println(date1);



    }
}

14.System类

主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回毫秒值
static void gc();	建议jvm赶快启动垃圾回收期器回收垃圾
static void exit(int status);	退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出

package Demo24;

/**
 * @author fanqie
 * @date 2021/4/1 -15:07
 * System类的使用
 * 主要用于获取系统的属性数据和其他操作，构造方法私有的
 */
public class System_02 {
    private String name;
    private int age;

    public System_02() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public System_02(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "System_02{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("回收了"+name+""+" "+age);
    }
}

package Demo24;

/**
 * @author fanqie
 * @date 2021/4/1 -15:07
 * System类的使用
 * 主要用于获取系统的属性数据和其他操作，构造方法私有的
 */
public class System_02 {
    private String name;
    private int age;

    public System_02() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public System_02(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "System_02{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("回收了"+name+""+" "+age);
    }
}

原文链接：https://blog.csdn.net/hjh3132778226/article/details/115551340

常用类

文章目录

1.成员内部类

测试类

2.静态内部类

测试类

3.局部内部类

4.匿名内部类

5.Object类

Object类的常用方法

Object的第一个方法：getClass()

Object的第二个方法：hashCode()

Object的第三个方法：toString()方法

Object的第四个方法：equals()方法

equals()方法覆盖步骤

finalize()方法

6.包装类

什么是包装类？

7.类型转换与装箱、拆箱

8.整数缓冲区

9.String类

常用方法

案例演示

10.可变字符串

11.Date类

12.Calendar

13.SimpleDateFormat

14.System类

你可能也喜欢