学习Java的第九天

佳简诚锄

 关注

阅读 101

2022-05-01

Object类

概述

java.lang.Object类是类层次结构的根类，每个类都使用Object作为超类（父类）。所有对象(包括数组)都实现这个类的方法。

重写tostring

每个类都继承了Object类，则每个类都有tostring且默认打印该类地址

public class Person {
    public int age;
    public String name;
    public int Id;

    //重写tostring
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", Id=" + Id +
                '}';
    }
    //构造
    public Person() {
        System.out.println("无参构造");
    }

    public Person(int age, String name, int id) {
        this.age = age;
        this.name = name;
        Id = id;
    }

    //get set
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }
}

public class Main {
    public static void main(String[] args) {
        Person per =new Person(22,"lin",12);

        //没有重写tostring，则打印该类地址
        //tostring 返回值为String类型
        System.out.println(per.toString());
        System.out.println(per); //默认调用tostring

        Random r = new Random();
        System.out.println(r.toString());  //Random未重写tostring

        Scanner s = new Scanner(System.in);
        System.out.println(s.toString());  //Scanner重写了tostring
        
        
    }
}

重写equals

源码
    public boolean equals(Object obj){
    	return (this==obj);
}

/*
	Object obj:可以为任意参数
	== : 比较运算符
		 基本数据类型:比较的是值
		 引用数据类型:比较的地址
	this : 谁调用则是谁


*/

//未重写
public class Main {
    public static void main(String[] args) {
        Person per =new Person(22,"lin",12);
        Person per1 = new Person();
        
        System.out.println(per1.equals(per));
        
        //将per的值赋予per1
        per1=per;
        System.out.println(per1.equals(per));

        //用运算符==，判断
        System.out.println(per==per1);
        
        
        
    }
}

当我们重写equals是会发现，因为参数列表Object obj ，所以存在多态问题，即对象无法使用子类特有的内容，则解决方案为向下转型，将Object强转为子类

//重写后
public boolean equals(Object o) {
        //判断参数是否为本身
        if (this == o) return true;
        //判断传入的参数是否为空
        //getClass() != o.getClass() 使用了反射技术，等效于 o instanceof Person,判断子类是否为Person
        if (o == null || getClass() != o.getClass()) return false;
        //向下转型
        Person person = (Person) o;
        return age == person.age && Id == person.Id && name.equals(person.name);
    //运用了工具name.equals(person.name);
}

objects.equals

//源码
public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
}

String str1 = "lin";
String str2 = "li";
String str3 = null;

boolean b = str1.equals(str2); //false
boolean b = str1.equals(str3); //空指针异常
boolean b = Objects.equals(str1,str3); //false

/*
Objects.equals 可以容忍空指针进行比较
*/

Date类

表示特定的瞬间，精确到毫秒

毫秒值的作用：将日期转化为毫秒值进行计算，即当前时间到时间原点一共经历了多少毫秒

日期转化为毫秒

//时间原点
1970 年 1 月 1 日 00:00:00;
//英国格林威治标准
//由于中国在东八区所以会加八个小时

public class Main {
    public static void main(String[] args) {
        //获取当前时间到时间原点的毫秒值
      System.out.println(System.currentTimeMillis());
        //打印当前时间到时间原点的毫秒值
      test3(); 
        //打印当前时间的日期
      test();
    }
    //利用无参构造
    public static void test(){
        Date date = new Date();
        //按照中国标准输出日期
        System.out.println(date);
    }
    
    public static void test3(){
        Date date = new Date();
        //将当前日期转化为毫秒值
        long time = date.getTime();
        System.out.println(date);
    }
}

毫秒值转化为日期

//利用有参构造
public static void test2(long da){
        Date date = new Date(da);
        //将毫秒值转化为日期
        System.out.println(date);
}

DateFormat类（抽象类）

  • 格式化输出日期和时间
  • 是Format的子类
  • 作用：格式化（日期->文本），解析（文本->日期）

格式化

利用SimpleDateFormat（子类）中的format进行格式化

public class Dome1 {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();
        System.out.println(sdf.format(date));
    }
}

解析

利用SimpleDateFormat中的parse进行格式化

public static void test1() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.parse("2022-05-01 09:20:07"));
    
    //parse中的格式要与构造方法中的格式一致
}

//会出现异常，需要加throws ParseException签名

案例

public class Dome2 {
    public static void main(String[] args) throws ParseException {
        //获取出生日期
        Scanner scanf = new Scanner(System.in);
        System.out.println("请输入你的出生日期：");
        System.out.println("格式为：yyyy-MM-dd");
        String strDate = scanf.next();
        //解析
        SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd");
        
        Date time = date.parse(strDate);//不要写出”strDate“

        //转化为毫秒值
        long time1 = time.getTime();
        //获取当前日期
        long time2 = System.currentTimeMillis();
        //计算
        long cal=time2-time1;
        //输出
        System.out.println(cal/1000/60/60/24+"天");
}

Calender类（抽象类）

Calender类无法直接创建对象，其中有一个静态方法为getInstance()，该方法返回一个Calender类的子类对象

static Calender getInstance();
//使用默认时区和语言环境获得一个日历

public class Dome3 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
    }

}

常用方法

public int get (int field);
//返回给定日历字段的值

public void set (int field,int value);
//将给定的日历字段设置为给定值

public abstract void add (int field,int amount);
//根据日历规则，为给定的日历字段添加或减去指定的时间量

public Date getTime();
//返回一个此Calender类的子类，将日历转化为Date对象

get

/*
public int get (int field);

参数 field 可用 Clender. 去访问静态成员变量
*/

public class Dome3 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH)+1;//西方的月份 0~11月
        int date = cal.get(Calendar.DATE);

        System.out.println(year+"-"+month+"-"+date);


    }

}

set

/*
public void set (int field,int value);
也可利用重载方法，同时设置年月日
*/

public class Dome3 {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR,9999);
        int year=cal.get(Calendar.YEAR);
        System.out.println(year);
    }
}

System类

public static long currentTimeMillis();
//返回毫秒为单位的当前时间
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
//将数组中指定的数据拷贝到另一个数组中

src - 源数组
srcPos - 源数组起始位置
dest - 目标数组
destPos - 目标数组起始位置
length - 要复制的元素个数

arraycopy

public class Main {
    public static void main(String[] args) {
        int[] num ={23,44,67,88,43,89,490};
        int[] numCopy= {0,0,0,0,0,1,0,0,0,};
        System.arraycopy(num,1,numCopy,1,4);
        System.out.println(Arrays.toString(num));
        System.out.println(Arrays.toString(numCopy));
    }

}

//目标数组必须不为空，且长度要足够
//用工具类去打印

StringBuilder类

与String类区别：

  1. String 字符串为常量，在创建后不能改变，字符串底层是被final修饰的数组（private final byte[] value）;字符串相加，会有多个字符串，占用空间多，效率低下

  2. 字符串缓冲区，StringBuilder的底层也是数组，但是没有被final修饰，可以改变。（byte[] value = new byte[16]）;初始长度为16字符

构造方法

public class Main {
    public static void main(String[] args) {
        StringBuilder str1 = new StringBuilder();
        System.out.println("str1:"+str1);

        StringBuilder str2 = new StringBuilder("林");
        System.out.println("str2:"+str2);
    }
}

append

//public StringBuilder append(){
	//
	return this;

}
public class Main {
    public static void main(String[] args) {
        StringBuilder str1 = new StringBuilder();
        System.out.println("str1:"+str1);

        StringBuilder str2 = new StringBuilder("林");
        System.out.println("str2:"+str2);

        str1 = str2.append("你好");//可不用接收返回值
        System.out.println("str1:"+str1);
        System.out.println("str2:"+str2);
    }
}
//append返回值是他本身，所以相同

补充：链式编程:一个方法的返回值是一个对象，可以根据对象继续调用方法

str1.append("lin").append(22).toUpperCase();

StringBuilder&toString

String与StringBuilder相互转化

  • String -> StringBuilder：使用StringBuilder的构造方法

  • StringBuilder->String :使用toString方法

public class Test {
    public static void main(String[] args) {
        //String -> StringBuilder
        String str1 = "hello";
        StringBuilder str2 = new StringBuilder(str1);
        str2.append(11);

        System.out.println(str2);
        System.out.println(str1);

        //StringBuilder->String
        String str3=str2.toString();
        System.out.println(str3);

    }
}

扩展

  1. str1.equals(str2).var 自动生成
  2. 加异常签名 ，选中方法名按ali+回车键

相关推荐

学习第九天

以沫的窝 122 0 0

JAVA学习笔记：第九天

8052cf60ff5c 213 0 0

第九天

谷中百合517 176 0 0

rust学习（第九天）

静鸡鸡的JC 169 0 0

JS学习第九天

_LEON_ 93 0 0

打卡学习第九天

仲秋花似锦 138 0 0

LeetCode学习-第九天

Mhhao 165 0 0

学习Android的第九天

ixiaoyang8 16 0 0

第九天打卡

七千22 53 0 0

HCIP第九天

西街小学的王 80 0 0

精彩评论（0）

0 0 举报