类的概述.

Object类

• object是一个超类、基类，所有的直接或间接父类，位于及成熟的最顶层
• 任何类，如果没有数学extens显示继承某个类，都默认直接继承Object类，否则为间接继承
• Object类中所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  • 作为参数，可以接受任何对象
  • 作为返回值，可以返回任何对象

[Object包](java.lang包【Object类】 - myseries - 博客园 (cnblogs.com))

getClass（）方法

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

package com.ar.chapter2;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaaaa",20);
        Student s2 = new Student("bbbbb",22);
        //判断s1和s2是不是同一个类型
        Class class1= s1.getClass();
        Class class2= s2.getClass();
        if (class1==class2){
            System.out.println("同类型");
        }else {
            System.out.println("非同类");
        }
    }
}

package com.ar.chapter2;

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

    public Student(String s, int i) {
        super();
        this.name =name;
        this.age = age;
    }

    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;
    }
}

输出

同类型

hashCode（）方法

• public int hashCode（）{}
• 返回该对象的哈希码值
• 哈希码是根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
• 一般情况下相同镀锡返回相同哈希码

//其余用的上面的代码
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());

460141958
1163157884

toString方法

• public String toString（）{}
• 返回该对象的字符串表示（表现形式）
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值

//toString
System.out.println(s1.toString());
System.out.println(s2.toString());
//可重写

com.ar.chapter2.Student@1b6d3586 //16进制的hashCode
com.ar.chapter2.Student@4554617c

equals

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

System.out.println(s1.equals(s2));

比的是地址

equals（）方法覆盖步骤

1. 比较两个引用是否指向同一个对象
2. 判断obj是否为null
3. 判断两个引用指向的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同

   @Override
    public boolean equals(Object obj) {
//        1. 比较两个引用是否指向同一个对象
        if (this==obj){
            return true;
        }
//        2. 判断obj是否为null
        if (this==null){
            return false;
        }
//        3. 判断两个引用指向的实际对象类型是否一致
        //if (this.getClass()==obj.getClass())
        //instanceof 判断对象是否是某种类型
        if (obj instanceof Student) {
//        4. 强制类型转换
            Student 是 = (Student) obj;
//        5. 依次比较各个属性值是否相同
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }

finalize()方法

• 当对象被判定为垃圾对象是，有jvm自动调用此方法，用以标记垃圾对象，进入回收队列
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象
• 垃圾回收：有GC销毁垃圾对象，释放数据存储空间
• 自动回收机制：jvm的内存耗尽，一次性回收所有垃圾对象
• 手动回收机制：使用System.gc（）；通知jvm执行垃圾回收

包装类

什么是包装类

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KAC5d4Ew-1637123736477)(C:\Users\17730\AppData\Roaming\Typora\typora-user-images\image-20211115115122825.png)]

类型转换与装箱、拆箱

//类型转换 装箱  基本类型转换成引用类型
        //基本类型jdk1.5之前
       int num1 = 10;
       //使用Integer创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        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);

//jdk1.5之后，提供了自动装箱和拆箱
 int age=20;
 //自动装箱
 Integer integer4=age;
 System.out.println("自动装箱");
 System.out.println(integer4);
 //自动拆箱
 int age1=integer4;
 System.out.println("自动拆箱");
 System.out.println(age1);

输出

拆箱
10
10
装箱
100
自动装箱
20
自动拆箱
20

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

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

//boolean字符串形式转换成基本类型 ”true“--->true  非"true"--->false
String str2="true";
boolean b=Boolean.parseBoolean(str2);
System.out.println(b);

”true“—>true 非"true"—>false

整数缓冲区

• java预先创建了256个常用的整数包装类型对象
• 在实际应用当中，对已创建的对象进行复用

//面试题
Integer integer1 = new Integer(100);//在栈里，比较栈的位置
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);//false
Integer integer3=100;//自动装箱，比较的是数字的大小
Integer integer4=100;
System.out.println(integer3==integer4);//true
Integer integer5=200;//200超过-127~128之间
Integer integer6=200;
System.out.println(integer5==integer6);//false

String概述

• 字符串是常量，创建后不可改变

• 字符串字面值村数字啊字符串池中，可以共享。

  //存储位置：字符串池中
  String name="Hello";
  name= "阿娆";//并没有改或删去Hello的位置，而是又开了一个空间给了阿娆，但是Hello成了个垃圾
  String name2="阿娆";//去字符串池中找到了阿娆，所以没有开新的。
  System.out.println(name==name2);
  true
  

• String s2=new String(“Hello”);//产生了两个对象，堆、栈中各存储一个

//演示字符串的另一种创建方法 new String()方式
String str = new String("阿娆好漂亮");//常量池没有方法区再来一个，堆里也会有一个,栈也会有
String str2= new String("阿娆好漂亮");
System.out.println(str==str2);
false

常用方法

• public int length：返回字符串的长度
• public char charAt（int index） 根据下标获取字符
• public boolean contains（String str）：判断当前字符串中是否包含str

String content="阿娆好漂亮";
System.out.println(content.length());//5
System.out.println(content.charAt(0));//阿
System.out.println(content.charAt(content.length()-1));//亮角标从0开始
System.out.println(content.contains("娆"));//true

• public char[] toCharArray()：将字符串转换成数组
• public int IndexOf(String str):查找str首次出现下标，存在，则返回改下标，不存在，返回-1
• public int lastIndexOf(String str):查找字符串在当前字符串中最后依次出现的下标索引

System.out.println(Arrays.toString(content.toCharArray()));//[阿, 娆, 好, 漂, 亮]
System.out.println(content.indexOf("好漂亮"));//2
System.out.println(content.indexOf("娆",1));//1
System.out.println(content.lastIndexOf("娆"));//1

• public String trim（）：去掉字符串前后的空格
• public String toUpperCase（）：将小写转换成大写
• public String toLowerCase（）：将大写转换成小写
• public boolean endWith（String str）：判断字符串是否以str结尾
• public boolean startWith（String str）：判断字符串是否以str开头

String a="   Hello,  World   ";
System.out.println(a.trim());
System.out.println(a.toLowerCase());
System.out.println(a.toUpperCase());
System.out.println(a.startsWith("H"));
System.out.println(a.endsWith("H"));
Hello,  World
   hello,  world   
   HELLO,  WORLD   
false
false

• public String replace（char oldChar ，char newChar）：将旧字符串替换成新字符串
• public String[] split （String str）:根据str做拆分

System.out.println(content.replace("阿娆", "r"));
String say="ab.cd.ef.gh.lm.no.";
String[] arr=say.split("[.]");
System.out.println(arr.length);
for (String string : arr){
    System.out.println(string);
}
r好漂亮
6
ab
cd
ef
gh
lm
no

• 补充

String s1="hello";
String s2="HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//true
String s3= "abc";//97
String s4="xyz";//120
System.out.println(s3.compareTo(s4));//-23

可变字符串

• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全

StringBuffer s1=new StringBuffer();
//1.append()追加
s1.append("阿娆最漂亮" );
System.out.println(s1.toString());
s1.append(20);
System.out.println(s1.toString());
//2.insert()添加
s1.insert(2,"阿娆呀");//第一个是数组下标
System.out.println(s1.toString());
//replace()替换，可指定位置
s1.replace(3,6,"Hello");
System.out.println(s1.toString());
//4.delete 删除
s1.delete(3,8);
System.out.println(s1.toString());
//清空
s1.delete(0,s1.length());
System.out.println(s1.toString());

• StringBuildr：可变长字符串，JDK5.0提供，运行效率比StringBuffer快、线程不安全

//验证，String来算时间
public static void main(String[] args) {
    //开始时间
    long start=System.currentTimeMillis();
    String string="";
    for (int i=0; i<999999;i++){//yysy我等不及了换成999了
        string+=i;
    }
    System.out.println(string);
    long end = System.currentTimeMillis();
    System.out.println(end-start);//
}

//200000+

//验证，用StringBuffer来验证

    public static void main(String[] args) {
        //开始时间
        long start=System.currentTimeMillis();
        StringBuffer sb=new StringBuffer();
        for (int i=0; i<999999;i++){
            sb.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);//
    }
}

//94s

BigDecimal的使用

double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);

0.09999999999999998

精度问题，这个要额理解，

BigDecimal精度更高哦

• 位置 ：java.math中
• 作用：精确计算

        BigDecimal bigDecimal1 = new BigDecimal("1.0");
        BigDecimal bigDecimal2 = new BigDecimal("0.9");
        BigDecimal r=bigDecimal1.subtract(bigDecimal2);
        System.out.println(r);
        System.out.println(bigDecimal1.add(bigDecimal2));
        System.out.println(bigDecimal1.multiply(bigDecimal2));

0.1
1.9
0.90

Date类

Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

1. 构造方法

Date 类有如下两个构造方法。

• Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
• Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。

import java.util.Date;

这两个构造方法的使用示例如下：

Date date1 = new Date();    // 调用无参数构造函数System.out.println(date1.toString());  
// 输出：Wed May 18 21:24:40 CST 2016Date date2 = new Date(60000);    
// 调用含有一个long类型参数的构造函数System.out.println(date2);    
// 输出：Thu Jan 0108:01:00 CST 1970

Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。

Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。 因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟的时间为 1970 年 1 月 1 日 00:01:00 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:00 CST 1970。

2. 常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SWw1rgSY-1637123736480)(C:\Users\17730\AppData\Roaming\Typora\typora-user-images\image-20211117114737304.png)]

Calender类

Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。

创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

Calendar c = Calendar.getInstance();

当创建了一个 Calendar 对象后，就可以通过 Calendar 对象中的一些方法来处理日期、时间。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5grQTWNI-1637123736481)(C:\Users\17730\AppData\Roaming\Typora\typora-user-images\image-20211117114921941.png)]

SimpleDateFormat类

1、为什么要使用SimpleDateFormat？

在Java中，如果我们想获取当前时间，一般会使用Date类的无参构造函数，如下所示，我们获取到当前时间并输出：

Date currentTime = new Date();
System.out.println(currentTime); // 输出：Wed Nov 17 12:17:06 CST 2021   运行时的时间

此时我们会发现， 输出的格式并不是我们预期的格式，一般情况下，我们希望的格式都是类似于2021-11-17，2021-11-17 12:14:06，2021/11/17这样的，此时我们就需要用到java.text.SimpleDateFormat来自定义格式。

2.使用format()方法将日期转换为字符串

使用format()方法，我们可以将日期类型转换为自己自定义的字符串格式，如2019-02-18，2019/02/18，2019-02-18 10:24:30等，自定义格式如下表所示：

格式 释义 举例
yyyy 年 2019
MM 月 02
dd 日 18
HH 小时(24小时制) 13，下午一点
mm 分钟 53
ss 秒 42
SSS 毫秒 629

package com.ar.chapter4;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo08 {
    public static void main(String[] args) {  Date currentTime = new Date();
    System.out.println(currentTime);  // Wed Nov 17 12:20:23 CST 2021
    SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd");
    SimpleDateFormat simpleDateFormat3 = new SimpleDateFormat("yyyy/MM/dd");
    System.out.println(simpleDateFormat1.format(currentTime)); // 输出2021-11-17 12:20:23.506
    System.out.println(simpleDateFormat2.format(currentTime)); // 输出2021-11-17
    System.out.println(simpleDateFormat3.format(currentTime)); // 输出2021/11/17
    }
}
Wed Nov 17 12:20:23 CST 2021
2021-11-17 12:20:23.506
2021-11-17
2021/11/17

3.使用parse()方法将字符串转换为日期
在实际开发过程中，我们经常需要将字符串转换为日期类型，以进行后续操作，此时可以使用parse()

方法，但需要注意：如果字符串与指定的格式不匹配，会报java.text.ParseException异常。

package com.ar.chapter4;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo08 {
    public static void main(String[] args) {
   try {
      SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
     String strDate1 = "2021-11-17 12:20:23.506";
     String strDate2 = "2021-11-17 ";
     Date date1 = simpleDateFormat1.parse(strDate1);
     System.out.println(date1);
     Date date2 = simpleDateFormat1.parse(strDate2);
     System.out.println(date2);
    } catch (ParseException e) {
       e.printStackTrace();
   }
    }
}

Wed Nov 17 12:20:00 CST 2021
java.text.ParseException: Unparseable date: "2021-11-17 "
at java.text.DateFormat.parse(DateFormat.java:366)
at com.ar.chapter4.Demo08.main(Demo08.java:13)

Process finished with exit code 0

由此我们可以看到，strDate1格式匹配能正常转换为Date类型，而strDate2由于格式不匹配，抛出java.text.ParseException，正是因为如此，以上的代码才必须包括在try,catch语句中，否则IDEA会提示错误，代码也编译不通过

Sysrem类

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

  [](Java System类详解 (biancheng.net))

  } catch (ParseException e) {
  e.printStackTrace();
  }
  }
  }

Wed Nov 17 12:20:00 CST 2021
java.text.ParseException: Unparseable date: "2021-11-17 "
	at java.text.DateFormat.parse(DateFormat.java:366)
	at com.ar.chapter4.Demo08.main(Demo08.java:13)

Process finished with exit code 0

由此我们可以看到，strDate1格式匹配能正常转换为Date类型，而strDate2由于格式不匹配，抛出java.text.ParseException，正是因为如此，以上的代码才必须包括在try,catch语句中，否则IDEA会提示错误，代码也编译不通过

## Sysrem类

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

  []([Java System类详解 (biancheng.net)](http://c.biancheng.net/view/904.html))