Javase进阶-day03-面向对象_常用API

最新推荐文章于 2024-11-16 17:49:09 发布

Java林同学

最新推荐文章于 2024-11-16 17:49:09 发布

阅读量330

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_45263618/article/details/125764067

版权

这篇博客主要介绍了Java中的面向对象特性，深入讲解了Object类的toString和equals方法，以及Date类和DateFormat类的使用。还涵盖了Calendar类的重要成员方法，并分享了解决日期格式化问题的经验。同时，提到了BigDecimal类、System类和Arrays类的相关内容。

摘要由CSDN通过智能技术生成

学习目标

能够说出Object类的特点
	是所有类的祖宗类,任意的一个类都直接或者间接的继承了Object类,都可以使用Object类中的方法
	Animal extends Object:直接继承  	Animal:默认继承Object
	Cat extends Animal:间接继承
能够重写Object类的toString方法
	alt+insert,选择toString
能够重写Object类的equals方法
	alt+insert,选择equals and hashCode
能够使用日期类输出当前日期
	import java.util.Date;
	Date date = new Date();
	sout(date);//Mon Apr 27 15:55:03 CST 2020
能够使用将日期格式化为字符串的方法:Date==>String(符合模式的)
	//1.创建SimpleDateFormat对象,构造方法中传递指定的模式   
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    //2.调用SimpleDateFormat对象中的方法format根据构造方法中传递的模式,把日期格式化为符合模式的字符串
    Date date = new Date();
    System.out.println(date);//Wed Mar 18 11:50:38 CST 2020
    String s = sdf.format(date);
    System.out.println(s);// 2020年03月18日 11时51分32秒
能够使用将字符串转换成日期的方法:String(符合模式的)==>Date
	//1.创建SimpleDateFormat对象,构造方法中传递指定的模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	//2.调用SimpleDateFormat对象中的方法format根据构造方法中传递的模式,把日期格式化为符合模式的字符串
	Date date =  sdf.parse("2000-12-12");
    System.out.println(date);//Tue Dec 12 00:00:00 CST 2000
能够使用Calendar类的get、set、add方法计算日期
	int get(int field) 获取给定日历字段的值。
    void set(int field, int value) 将给定的日历字段设置为给定值。
    void add(int field, int amount)  把日历字段增加|减少指定的值(正数:增加,负数:减少)
能够使用System类获取当前系统毫秒值
	static long currentTimeMillis() 返回以毫秒为单位的当前时间。
	long log = System.currentTimeMillis();
能够使用Arrays类的sort方法
	//static void sort(Object[] a) 根据元素的自然顺序对指定对象数组按升序进行排序。
	// int[] arr1 = {5,1,4,2,3};
	//Arrays.sort(arr1);
	//[1, 2, 3, 4, 5]
能够使用Arrays类的toString方法
	//static String toString(Object[] a) 对数组进行遍历,把数组中的元素组合成一个字符串返回
	//String s = Arrays.toString(arr); [1, 2, 3, 4, 6, 7, 8, 9, 10]

一.代码块(了解)

1.概述

代码块:被{ }包裹的一块代码
1.局部代码块:写在方法中的代码块

作用:可以改变变量的作用域
变量的作用域:在{
    }所在的范围内有效
定义一个变量,只想使用一次,可以写在局部代码块中,使用完毕会立即消失

2.构造代码块:写在成员位置(类中,方法外)的代码块

特点:
	构造代码块优先于构造方法执行,每创建一次对象,都会执行一次构造代码块!
	构造代码块!
	Student类的空参数构造方法!
	构造代码块!
	Student类的满参数构造方法!
作用:
	1.可以给成员变量赋初始化值
	2.可以把构造方法中共性的内容,提取到构造代码块中,提高代码的复用性
		需求:无论使用哪个构造方法创建对象,都先打印10次"我想有一个女同桌!"
	3.可以给final修饰的变量赋值:构造代码块也是在创建对象前执行

3.静态代码块:写在成员位置(类中,方法外),被static修饰的代码块

特点:只执行一次,优先执行
	a.静态成员优先于非静态成员加载到静态区中,优先于构造代码块和构造方法执行
	b.静态成员属于类,不属于某一个对象,无论创建多少次对象,只执行一次
作用:
	a.可以给静态的成员,赋初始化值
	b.在项目启动的时候,可以做一些初始化的设计
需求:
	假如我们在类中定义了一个长度为10的“静态的数组”，
	但需要为每个元素初始化为1-100的随机数，怎么初始化？

2.使用

package com.itheima.demo01;

/*
    代码块:被{ }包裹的一块代码
 */
public class Demo01 {
   
    public static void main(String[] args) {
   
        /*
            1.局部代码块:写在方法中的代码块
            作用:可以改变变量的作用域
            变量的作用域:在{ }所在的范围内有效
            定义一个变量,只想使用一次,可以写在局部代码块中,使用完毕会立即消失
         */
        int a = 10;
        {
   
            int b = 20;
            System.out.println(b);
        }
        //System.out.println(b);//Cannot resolve symbol 'b'
        //System.out.println(c);//Cannot resolve symbol 'c'
        System.out.println(a);
        System.out.println("--------------------------");
        Person p1 = new Person();
        System.out.println(p1.getName()+"\t"+p1.getAge());
        Person p2 = new Person("小明",18);
        System.out.println(p2.getName()+"\t"+p2.getAge());
        System.out.println("-----------------------");
        //遍历Person类的静态数组arr
        for (int i = 0; i < Person.arr.length; i++) {
   
            System.out.println(Person.arr[i]);
        }
        System.out.println("---------------");
        System.out.println("bb:"+Person.bb);
    }
}

package com.itheima.demo01;

import java.util.Random;

public class Person {
   
    private String name;
    private int age;
    final int aa;
    static int bb;

    /*
        2.构造代码块:写在成员位置(类中,方法外)的代码块
        特点:
            构造代码块优先于构造方法执行,每创建一次对象,都会执行一次构造代码块!
            Person p1 = new Person();
            Person p2 = new Person("小明",18);
            构造代码块!
            Person类的空参数构造方法!
            构造代码块!
            Person类的满参数构造方法!
        作用:
            1.可以给成员变量赋初始化值
            2.可以把构造方法中共性的内容,提取到构造代码块中,提高代码的复用性
                需求:无论使用哪个构造方法创建对象,都先打印10次"我想有一个女同桌!"
            3.可以给final修饰的变量赋值:构造代码块也是在创建对象前执行
     */
    {
   
        System.out.println("构造代码块!");
        //1.可以给成员变量赋初始化值
        this.name = "张三";
        this.age = 18;
        //2.可以把构造方法中共性的内容,提取到构造代码块中,提高代码的复用性
        /*for (int i = 1; i <= 10; i++) {
            System.out.println("我想有一个女同桌!"+i);
        }*/
        //3.可以给final修饰的变量赋值:构造代码块也是在创建对象前执行
        aa = 10;
    }

    /*
        3.静态代码块:写在成员位置(类中,方法外),被static修饰的代码块
        特点:只执行一次,优先执行
            a.静态成员优先于非静态成员加载到静态区中,优先于构造代码块和构造方法执行
            b.静态成员属于类,不属于某一个对象,无论创建多少次对象,只执行一次
        作用:
            a.可以给静态的成员,赋初始化值
            b.在项目启动的时候,可以做一些初始化的设计
        需求:
            假如我们在类中定义了一个长度为10的“静态的数组”，
            但需要为每个元素初始化为1-100的随机数，怎么初始化？
     */
    static int[] arr = new int[10];

    static {
   
        System.out.println("静态代码块!");
        //a.可以给静态的成员,赋初始化值
        bb = 100;
        //b.在项目启动的时候,可以做一些初始化的设计
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
   
            arr[i] = r.nextInt(100)+1;
        }
    }

    public Person() {
   
        /*for (int i = 1; i <= 10; i++) {
            System.out.println("我想有一个女同桌!"+i);
        }*/
        System.out.println("Person类的空参数构造方法!");
    }

    public Person(String name, int age) {
   
        /*for (int i = 1; i <= 10; i++) {
            System.out.println("我想有一个女同桌!"+i);
        }*/
        System.out.println("Person类的满参数构造方法!");
        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;
    }
}

二.Object类

1.Object类介绍(了解)

java.lang.Object 注意:lang包中的类无需导包可以直接使用
类 Object 是类层次结构的根类(最顶层的类祖宗类)。
每个类都使用 Object 作为超类。任何一个类都直接或者间接的继承了Object类
所有对象（包括数组）都实现这个Object类的方法。任何一个类都可以使用Object类中的方法

2.Object类的toString方法(重点)

package com.itheima.demo02toString;

import java.util.ArrayList;
import java.util.Random;

/*
    String toString() 返回该对象的字符串表示。
    Object类中toString方法的底层源码(了解):
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        1.getClass().getName():使用反射技术获取类的全类名(包名+类名)
            "com.itheima.demo02toString.Person"
        2."@"字符串的@符号,原样输出,起到分割的作用
        3.hashCode():Object类的方法,可以获取对象的哈希值,哈希值是操作系统给我们返回的一个十进制的整数
        4.Integer.toHexString(hashCode()):把十进制的整数转换为十六进制(0-9 a-f)
        组合在一起:"com.itheima.demo02toString.Person@140e19d"==>对象在堆内存中的地址值
 */
public class Demo01ToString {
   
    public static void main(String[] args) {
   
        //创建Person对象
        Person p1 = new Person("迪丽热巴",18);
        //Person类默认继承了Object类,所以可以使用继承自Object类中的toString方法
        String s = p1.toString();
        System.out.println("s:"+s);//s:com.itheima.demo02toString.Person@140e19d 重写后:Person{name='迪丽热巴', age=18}
        //注意:直接打印对象名,默认会调用对象的toString方法
        System.out.println(p1);//com.itheima.demo02toString.Person@140e19d 重写后:Person{name='迪丽热巴', age=18}

        /*
            以后看一个类是否重写的toString方法,打印对象名
                类重写类toString方法,打印的就不是地址值
                类没有重写toString方法,打印地址值
         */
        Random r = new Random();
        System.out.println(r);//java.util.Random@17327b6 类没有重写toString方法

        String str = new String("abc");
        System.out.println(str);//abc 类重写类toString方法

        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        System.out.println(list);//[aa, bb] 类重写类toString方法
    }
}

package com.itheima.demo02toString;

//ctrl+鼠标左键:进入到类中|方法中
public class Person extends Object{
   
    private String name;
    private int age;

    /*
        Object类的toString方法,打印对象名,打印对象的地址值有意义吗?没有意义
        重写Object类的toString方法,打印对象的属性值(name,age)
        快捷键:alt+insert==>选择toString
     */
    @Override
    public String toString() {
   
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
   
    }

    public Person(String name, int age) {
   
        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;
    }
}

重点记忆

1.直接打印对象的名字,会默认调用对象的toString方法

2.Object类的toString方法,默认打印对象的地址值

3.重写toString方法快捷键 alt+insert==>toString方法打印对象的属性

3.Object类中的equals方法(重点)

package com.itheima.demo03equals;

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

    /*
        Object类的equals方法,默认比较两个对象的地址值,没有意义(地址值肯定不同)
        重写equals方法,比较两个对象的属性值(name,age)
        快捷键:alt+inert==>选择equals() and hashCode()
        方法中的this:调用方法的对象p1
        方法的参数o:传递的参数p2
     */
    @Override
    public boolean equals(Object o) {
   
        //if语句目的:两个对象的地址相同,说是同一个对象,直接返回true,可以提高效率
        if (this == o){
   
            return true;
        }
        /*
            o == null==>传递的参数是null,使用p1和null比较地址值肯定不同,直接返回false,可以提高效率
            getClass() != o.getClass():使用反射技术,判断o(p2)是否为Person类型,不是Person类型直接返回false,可以提高效率
                等价于!(o instanceof Person):判断某个对象是否属于某种数据类型
         */
        /*if (o == null || !(o instanceof Person)){
            return false;
        }*/
        if (o == null || getClass() != o.getClass()){
   
            return false;
        }

        /*
            Object o = p2 = new Person("李四",18);
            多态: 父类的类型变量指向了子类的对象
            多态弊端:不能使用子类特有的成员变量和成员方法
         */
        Person person = (Person) o;

        //先比较两个人的年龄是否相同,不相同直接返回false
        if (this.age != person.age){
   
            return false;
        }
        //this.name.equals(person.name) "张三".equals("李四"):String类重写了equals,比较的字符串的内容是否相同
        return this.name != null ? this.name.equals(person.name) : person.name == null;
    }

    public Person() {
   
    }

    public Person(String name, int age) {
   
        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;
    }
}

package com.itheima.demo03equals;

import java.util.Random;

/*
    boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
    equals方法的底层源码:
        public boolean equals(Object obj) {
            return (this == obj);
        }
        this是谁:哪个对象调用的方法,方法中的this就是哪个对象
        obj:传递的参数
        ==:比较运算符
        基本数据类型:==号比较的是值 10==20
        引用数据类型:==号比较的是