公告

昵称： ofanimon
园龄： 2年10个月
粉丝： 14
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

2022年4月(97)

阅读排行榜

03-常用API

今日内容

权限修饰符 ----->掌握
- 分类
- 权限
代码块(格式,位置,执行,使用场景)
- 构造代码块
- 静态代码块 ----->掌握
- 局部代码块
Object类 ----->掌握
时间日期类 ----->掌握
Math类(静态方法)
System类(静态方法)
BigInteger类
BigDecimal类 ----->建议掌握
Arrays类
包装类 ----->掌握

回到顶部

第一章权限修饰符

1.1 权限修饰符

概述

在java中提供了4个权限修饰符,使用不同的权限修饰符修饰,被修饰的内容就具有不同的访问权限
分类:
- public : 公共的
- protected: 受保护的
- (空的): 默认
- private: 私有的

不同权限的访问能力

			同一个类		同一个包		不同包的父子类			不同包的无关类
public   	√				√				√					√
protected	√				√				√					×
默认		   √			   √               ×                   ×
private     √               ×               ×                   ×

案例:

同一个包

package com.itheima.demo1_权限修饰符;
public class Person {

    public void method1(){
        System.out.println("public 修饰的method1方法");
    }

    protected void method2(){
        System.out.println("protected 修饰的method2方法");
    }

     void method3(){
        System.out.println("默认 修饰的method3方法");
    }

    private void method4(){
        System.out.println("private 修饰的method4方法");
    }

    // 同一个类
    public void method(){
        method1();
        method2();
        method3();
        method4();
    }

}

package com.itheima.demo1_权限修饰符;

public class Test {
    public static void main(String[] args) {
        // 创建Person对象
        Person p = new Person();
        p.method1();
        p.method2();
        p.method3();
        //p.method4();编译报错
    }
}

不同包

package com.itheima.demo2_权限修饰符;

import com.itheima.demo1_权限修饰符.Person;

public class Student extends Person {

    // 不同包的子类
    public void show(){
        method1();
        method2();
        //method3();// 编译报错
        //method4();// 编译报错
    }

}

package com.itheima.demo2_权限修饰符;

import com.itheima.demo1_权限修饰符.Person;

public class Test {
    public static void main(String[] args) {
        // 创建Person对象
        Person p = new Person();
        p.method1();
        // p.method2();// 编译报错
        // p.method3();// 编译报错
        // p.method4();// 编译报错
    }
}

开发中的使用

定义类一般使用public
定义成员方法一般使用public
定义成员变量一般使用private
定义构造方法一般使用public,也有可能用private

回到顶部

第二章代码块

2.1 构造代码块

格式: {}
位置: 类中方法外
执行: 每次调用构造方法之前都会执行一次
使用场景: 执行构造方法之前需要执行的代码就可以放在构造代码块中,eg: 统计该类创建的对象个数

案例:

public class Person {

    // 构造代码块
    {
        System.out.println("Person 构造代码块...");
    }

    // 构造方法
    public Person() {
        System.out.println("Person 构造方法...");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建Person对象
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

2.2 静态代码块

格式: static{}
位置: 类中方法外
执行: 随着类的加载而执行,并且只执行一次,优先于构造方法执行
使用场景: 只需要执行一次的代码就可以放在静态代码块中 eg: 加载驱动,加载配置文件....

案例:

public class Person {
    // 静态代码块
    static {
        System.out.println("Person 静态代码块...");
    }

    // 构造方法
    public Person() {
        System.out.println("Person 构造方法...");
    }

}

2.3 局部代码块

格式: {}
位置: 在方法中
执行: 调用方法,执行到局部代码块的位置才执行
使用场景: 主要用来提交释放内存,节省内存空间,但意义不大

案例:

package com.itheima.demo3_代码块.demo3_局部代码块;

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

        // 定义一个int类型的变量,并赋值
        int num1 = 10;
        System.out.println("num1:"+num1);

        // 局部代码块
        {
            int num2 = 20;
            System.out.println("num2:" + num2);
        }// 释放局部代码块中变量占用的内存空间

        // ...

    }
}

2.4 注意

静态代码块优先于构造代码块执行

构造代码块优先于构造方法执行

public class Person {
    static {
        System.out.println("Person 静态代码块...");
    }

    {
        System.out.println("Person 构造代码块...");
    }

    public Person() {
        System.out.println("Person 构造方法...");
    }
}

回到顶部

第三章 Object类

3.1 Object类的概述

概述: java.lang.Object类是java中所有类的父类\根类,也就是说java中所有的类都继承了Object类
- 继承Object类:
  - 直接继承Object类: public class Person /*extends Object*/{}
  - 间接继承Object类: public class Student extends Person{}
构造方法: public Object();
成员方法: Object类总共有11个成员方法,也就意味着java中所有类的都拥有这11个方法,但今天只讲2个成员方法
- public toString();返回该对象的字符串表示
- public boolean equals(Object obj); 判断2个对象是否相等;

3.2 toString方法

String toString() 返回该对象的字符串表示。

使用场景: 如果打印对象的时候不希望打印的是地址值,那么就重写toString方法

public class Person {

    String name;
    int age;

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

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

public class Test {
    public static void main(String[] args) {
        /*
            `String toString()  返回该对象的字符串表示。`
            1.java中所有类都拥有toString方法
            2.Object类的toString方法默认返回一个固定格式的字符串,格式: 类的全名+@+地址值
            3.打印对象其实打印的就是该对象调用toString方法返回的字符串
            4.如果打印对象的时候不希望打印的是地址值,那么就重写toString方法---alt+insert
         */
        // 创建Object类对象
        Object obj = new Object();
        System.out.println("obj对象:"+obj.toString());
        System.out.println("obj对象:"+obj);

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

        // 创建Person类对象
        Person p = new Person("张三",18);
        System.out.println("p对象:"+p.toString());
        System.out.println("p对象:"+p);


    }
}

3.3 equals方法

public boolean equals(Object obj)：判断2个对象是否相等。

使用:

Object类的equals方法默认比较的是地址值
如果希望比较的不是地址值,而是所有的属性值,那么就按alt+insert,选择equals() and hashCode()重写就行

import java.util.Objects;

public class Person {

    String name;
    int age;

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

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

    /*@Override
    public boolean equals(Object obj) {
        Person p = (Person)obj;
       return age==p.age && name.equals(p.name);
    }*/

    @Override
    public boolean equals(Object o) {
        // 如果2个对象的地址值相同,就直接返回true,结束方法
        if (this == o) return true;
        // 如果参数为null,或者2个对象的类型不一致,就直接返回false,结束方法
        if (o == null || getClass() != o.getClass()) return false;
        // 说明参数一定是Person类型----向下转型
        Person person = (Person) o;
        // 比较2个对象的所有属性是否相同
        return age == person.age &&
                Objects.equals(name, person.name);
        //  Objects.equals方法避免控制在异常,并且可以比较2个对象是否相等
    }


}

public class Test {
    public static void main(String[] args) {
        /*
            `public boolean equals(Object obj)：判断2个对象是否相等。`
            1.java中所有类都拥有equals方法
            2.Object类中的equals方法默认比较的是2个对象的地址值
            3.在开发中,往往认为2个同类型的对象的所有属性相同,这2个对象就是相等的
            4.如果希望比较的不是地址值,而是所有的属性值,那么就按alt+insert,选择equals() and hashCode()重写就行
         */
        // 创建Person类的对象
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("张三", 18);
        Person p3 = new Person(null, 18);

        // 调用从Object类继承过来的equals方法
        System.out.println("p1和p2是否相等: " + (p1 == p2));
        System.out.println("p1和p2是否相等: " + p1.equals(p2));
        System.out.println("p3和p2是否相等: " + p3.equals(p2));
    }
}

3.4 Objects类

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}
1.如果2个对象的地址值相同,后面就不执行了(逻辑或短路),而是直接返回true,结束方法
2.如果2个对象的地址值不同:
	2.1 如果a对象的地址值为空,逻辑与后面就不执行了(逻辑与短路),而是直接返回false,结束方法
    2.2 如果a对象的地址值不为空,执行a.equals(b),就是比较2个对象是否相等

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        String str1 = null;
        String str2 = "张三";
        String str3 = new String("张三");
        System.out.println(str2 == str3);// false
        System.out.println(str2.equals(str3));// true
        //System.out.println(str1.equals(str2));// 空指针异常
        System.out.println(Objects.equals(str1, str2));// false

    }
}

3.5 native方法

native本地方法的概述

在Object类的源码中定义了 native 修饰的方法， native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,所以大家不需要关心该方法如何实现的

当我们需要访问C或C++的代码时，或者访问操作系统的底层类库时，可以使用本地方法实现。

也就意味着Java可以和其它的编程语言进行交互。
本地方法的作用：就是当Java调用非Java代码的接口。方法的实现由非Java语言实现，比如C或C++。

Object类源码(部分)：

package java.lang;
/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {
	//本地方法
    private static native void registerNatives();
    //静态代码块
    static {
        registerNatives();
    }
    ......
    ......
}

回到顶部

第四章 Date类

3.5 Date类

Date类的概述
- java.util.Date类表示日期,内部精确到毫秒.表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。
- 0时区标准基准时间: 1970年1月1日00:00:00
- 东八区标准基准时间: 1970年1月1日08:00:00

Date类中的构造方法

public Date();创建当前系统时间对应的日期对象
public Date(long mills);距离标准基准时间指定偏移毫秒数对应的日期对象

案例:

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        //- `public Date();创建当前系统时间对应的日期对象`
        Date date1 = new Date();
        System.out.println("date1:" + date1);// Sun Aug 01 11:07:33 CST 2021

        //- `public Date(long mills);距离标准基准时间 指定偏移毫秒数 对应的日期对象`
        // 创建一个距离标准基准时间偏移1秒
        Date date2 = new Date(1000);
        System.out.println("date2:" + date2);// Thu Jan 01 08:00:01 CST 1970

        Date date3 = new Date(-1000);
        System.out.println("date3:" + date3);// Thu Jan 01 07:59:59 CST 1970
    }
}

Date类中的常用方法

public long getTime();获取当前日期对象距离标准基准时间的毫秒值
public boolean after(Date when) 判断此日期是否在指定日期之后
public boolean before(Date when) 判断此日期是否在指定日期之前

import java.util.Date;

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

        // 创建Date日期对象
        Date date1 = new Date();
        Date date2 = new Date(1000);

        //- `public long getTime();获取当前日期对象距离标准基准时间的毫秒值`
        System.out.println("date1距离标准基准时间的毫秒值:"+date1.getTime());// 1627787515695
        System.out.println("date2距离标准基准时间的毫秒值:"+date2.getTime());// 1000

        //- `public boolean after(Date when) 判断此日期是否在指定日期之后`
        System.out.println("date1是否在date2日期之后:"+date1.after(date2));// true

        //- `public boolean before(Date when) 判断此日期是否在指定日期之前`
        System.out.println("date1是否在date2日期之钱:"+date1.before(date2));// false
    }
}

回到顶部

第五章 DateFormat类

3.6 DateFormat类

DateFormat类的概述
- 概述: java.text.DateFormat 该类可以使得在Date对象与String对象之间进行来回转换.
  - 格式化: 按照指定的格式，把Date对象转换为String对象。
  - 解析: 按照指定的格式，把String对象转换为Date对象。
- 注意: DateFormat是一个抽象类,无法创建对象,应该使用其子类来实现Date和String之间的转换
SimpleDateFormat类
- 概述:java.text.SimpleDateFormat类继承DateFormat类,所以该类也可以实现Date和String对象之间的相互转化
- 构造方法:
  - public SimpleDateFormat(String pattern);创建日期格式化对象,并且指定日期格式;
  - 日期格式:
    - y:年
    - M:月
    - d:日
    - H:时
    - m:分
    - s:秒
    - ....
  - 常见的日期格式:
    - yyyy-MM-dd HH:mm:ss
    - yyyy年MM月dd日 HH:mm:ss
    - .....

DateFormat类中的常用方法

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

注意: 日期格式化对象中指定的日期要和解析的字符串日期格式一致,否则会报解析异常ParseException

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

public class Test {
    public static void main(String[] args) throws ParseException {
        // 创建日期格式化对象,指定日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //- `public String format(Date date)：将Date对象格式化为字符串。`
        // 创建Date日期对象
        Date date = new Date();

        // 把Date日期对象转化为String对象
        String strDate = sdf.format(date);
        System.out.println("strDate:" + strDate);// 2021-08-01 11:26:29

        //- `public Date parse(String source)：将字符串解析为Date对象。`
        String birthday = "1999-10-11 12:12:12";
        Date birthdayDate = sdf.parse(birthday);
        System.out.println("birthdayDate:" + birthdayDate);// Mon Oct 11 12:12:12 CST 1999

        // 注意:期格式化对象中指定的日期要和解析的字符串日期格式一致,否则会报解析异常ParseException**
        //String birthday2 = "1999年10月11日 12:12:12";
        //Date birthdayDate2 = sdf.parse(birthday2);// 报解析异常:ParseException
        //System.out.println("birthdayDate2:" + birthdayDate2);

    }
}

3.7 日期类练习

需求

键盘输入一个字符串类型的出生日期时间，打印你来到世界多少天?

分析

键盘录入出生日期时间
获取当前系统日期时间,并转化为距离标准基准时间的毫秒值
出生日期时间转化为Date日期,再获取出生日期时间距离标准基准时间的毫秒值
计算2个时间的毫秒值差,换算成天数,打印输出

实现

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

public class Test {
    public static void main(String[] args) throws ParseException {
        //- 键盘录入出生日期时间
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期,格式为yyyy-MM-dd:");
        String birthday = sc.nextLine();

        //- 获取当前系统日期时间,并转化为距离标准基准时间的毫秒值
        long nowTime = new Date().getTime();

        //- 出生日期时间转化为Date日期,再获取出生日期时间距离标准基准时间的毫秒值
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthday);
        long birthdayTime = birthdayDate.getTime();

        //- 计算2个时间的毫秒值差,换算成天数,打印输出
        System.out.println("来到世界:" + (nowTime - birthdayTime) / 1000 / 60 / 60 / 24 + "天");
    }
}

回到顶部

第六章 Calendar类

3.8 Calendar类

Calendar类的概述
- 概述: java.util.Calendar抽象类表示一个“日历类”，可以进行日期运算。
获取日历对象:
- 方式一: 通过创建Calendar类的子类对象,创建日期对象
- 方式二: 通过调用Calendar类的静态方法,获取日历对象 ------>掌握\推荐使用
  - public static Calendar getInstanse();

Calendar类的注意事项

日历对象中的月份是0-11, 0表示1月,依次类推, 11表示12月
日历对象中的星期是1-7, 1表示星期天,依次类推,7表示星期六

案例:


public class Test {
    public static void main(String[] args) {
        //- 方式一: 通过创建Calendar类的子类对象,创建日期对象
        GregorianCalendar calendar1 = new GregorianCalendar();
        System.out.println(calendar1);


        //- 方式二: 通过调用Calendar类的静态方法,获取日历对象  建议
        Calendar calendar2 = Calendar.getInstance();
        System.out.println(calendar2);
        /*
            java.util.GregorianCalendar[time=1627790765739,areFieldsSet=true,
            areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",
            offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],
            firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=7,WEEK_OF_YEAR=32,
            WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=213,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=1,
            AM_PM=1,HOUR=0,HOUR_OF_DAY=12,MINUTE=6,SECOND=5,MILLISECOND=739,ZONE_OFFSET=28800000,
            DST_OFFSET=0]

         */
    }
}

Calendar类的常用方法

public int get(int field) 获取某个字段的值。
public void set(int field,int value) 设置某个字段的值
public void add(int field,int amount) 为某个字段增加/减少指定的值
void setTime(Date date) 修改当前日历对象表示的时间。
public boolean after(Object when)判断当前日历对象是否在指定的日历对象之后
public boolean before(Object when) 判断当前日历对象是否在指定的日历对象之前

案例:


public class Test {
    public static void main(String[] args) {
        // 获取当前系统时间的日历对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);
        /*
            java.util.GregorianCalendar[time=1627791194998,areFieldsSet=true,areAllFieldsSet=true,
            lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,
            dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
            minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=7,WEEK_OF_YEAR=32,WEEK_OF_MONTH=1,
            DAY_OF_MONTH=1,DAY_OF_YEAR=213,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=0,
            HOUR_OF_DAY=12,MINUTE=13,SECOND=14,MILLISECOND=998,ZONE_OFFSET=28800000,DST_OFFSET=0]

         */
        //- `public int get(int field)  获取某个字段的值。`
        int year = calendar.get(Calendar.YEAR);
        System.out.println("year:" + year);

        int month = calendar.get(Calendar.MONTH);
        System.out.println("month:" + month);

        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("day:" + day);

        int day_of_year = calendar.get(Calendar.DAY_OF_YEAR);
        System.out.println("day_of_year:" + day_of_year);


        //- `public void set(int field,int value)  设置某个字段的值`
        // 修改Calendar对象的年字段为2025
        calendar.set(Calendar.YEAR, 2025);
        System.out.println("年:" + calendar.get(Calendar.YEAR));// 2025

        //- `public void add(int field,int amount)  为某个字段增加/减少指定的值`
        //  为Calendar对象的年字段+2年
        calendar.add(Calendar.YEAR,2);
        System.out.println("年:" + calendar.get(Calendar.YEAR));// 2027

        //  为Calendar对象的年字段-7年
        calendar.add(Calendar.YEAR,-7);
        System.out.println("年:" + calendar.get(Calendar.YEAR));// 2020

        //- `void setTime(Date date) 修改当前日历对象表示的时间。`
        // 需求: 获得1970-01-01 08:00:01 日历对象
        Date date = new Date(1000);
        calendar.setTime(date);
        System.out.println("年:"+calendar.get(Calendar.YEAR));
        System.out.println("月:"+calendar.get(Calendar.MONTH));
        System.out.println("日:"+calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println("时:"+calendar.get(Calendar.HOUR_OF_DAY));
        System.out.println("分:"+calendar.get(Calendar.MINUTE));
        System.out.println("秒:"+calendar.get(Calendar.SECOND));

        //- `public boolean after(Object when)判断当前日历对象是否在指定的日历对象之后`
        Calendar nowCalendar = Calendar.getInstance();
        System.out.println("当前日历对象是否在calendar日历对象之后: "+nowCalendar.after(calendar));// true

        //- `public boolean before(Object when) 判断当前日历对象是否在指定的日历对象之前`
        System.out.println("当前日历对象是否在calendar日历对象之前: "+nowCalendar.before(calendar));// false
    }
}

回到顶部

第七章 Math类

3.9 Math类

Math类的概述
- 概述: java.lang.Math(类): Math包含执行基本数字运算的方法的工具类。
- 特点:
  - Math类构造方法被私有修饰，不能创建对象。
  - 操作的时候,都是通过Math类名直接调用该类的静态方法即可。
Math类的常用方法
- public static int abs(int a) 获取参数a的绝对值
- public static double ceil(double a) 向上取整 (得到大于参数的最小整数)
- public static double floor(double a) 向下取整(得到小于参数的最大整数)
- public static double pow(double a, double b) 获取a的b次幂
- public static long round(double a) 四舍五入取整
- public static int max(int a, int b) 返回两个 int 值中较大的一个
- public static int min(int a, int b) 返回两个 int 值中较小的一个

案例代码

public class Test {
    public static void main(String[] args) {
        //- public static int abs(int a)                   获取参数a的绝对值
        System.out.println("-10的绝对值:" + Math.abs(-10));// 10
        System.out.println("10的绝对值:" + Math.abs(10));// 10

        //- public static double ceil(double a)            向上取整 (得到大于参数的最小整数)
        System.out.println("3.14向上取整:" + Math.ceil(3.14));// 4.0
        System.out.println("-3.14向上取整:" + Math.ceil(-3.14));// -3.0

        //- public static double floor(double a)           向下取整(得到小于参数的最大整数)
        System.out.println("3.14向下取整:" + Math.floor(3.14));// 3.0
        System.out.println("-3.14向下取整:" + Math.floor(-3.14));// -4.0


        //- public static double pow(double a, double b)   获取a的b次幂
        System.out.println("2的3次方:" + Math.pow(2, 3));// 8.0

        //- public static long round(double a)             四舍五入取整
        System.out.println("3.14四舍五入:" + Math.round(3.14));// 3
        System.out.println("3.54四舍五入:" + Math.round(3.54));// 4

        //- public static int max(int a, int b)            返回两个 int 值中较大的一个
        //- public static int min(int a, int b)            返回两个 int 值中较小的一个
        System.out.println("10和20的最大值:" + Math.max(10, 20));// 20
        System.out.println("10和20的最小值:" + Math.min(10, 20));// 10
    }
}

回到顶部

第八章 System

3.10.1 System类

System类的概述
- 概述: java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。
- 特点:
  - System类构造方法被私有修饰，不能创建对象
  - 直接通过System类名调用该类的静态方法
System类的常用方法
- public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
- public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值;

案例代码

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        //- `public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止`
        System.out.println("开始");
        System.out.println("执行");
        // 提前结束程序的运行---终止jvm
        //System.exit(0);
        //System.out.println("结束");

        //- `public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值;`
        System.out.println(System.currentTimeMillis());
        System.out.println(new Date().getTime());
    }
}

3.10.2 练习

需求

在控制台输出1-10000，计算这段代码执行了多少毫秒

分析

在输出之前,获取当前系统时间距离标准基准时间的毫秒值
循环输出
在输出之后,获取当前系统时间距离标准基准时间的毫秒值
计算2个时间差,打印输出

实现


public class Test_练习 {

    public static void main(String[] args) {
        //- 在输出之前,获取当前系统时间距离标准基准时间的毫秒值
        long start = System.currentTimeMillis();

        //- 循环输出
        for (int i = 0; i < 10000; i++) {
            System.out.println("i:" + i);
        }

        //- 在输出之后,获取当前系统时间距离标准基准时间的毫秒值
        long end = System.currentTimeMillis();

        //- 计算2个时间差,打印输出
        System.out.println("总共花了:" + (end - start) + "毫秒");
    }

}

回到顶部

第九章 BigInteger类

3.11 BigInteger类

BigInteger类的概述
- 概述: java.math.BigInteger 表示一个超大的整数
BigInteger类的构造方法
- public BigInteger(String value); 根据字符串内容创建一个超大的整数对象
- 注意: 字符串参数一定要传整数的字符串

BigInteger类成员方法

public BigInteger add(BigInteger value) 加法运算
public BigInteger subtract(BigInteger value) 减法运算
public BigInteger multiply(BigInteger value) 乘法运算

public BigInteger divide(BigInteger value) 除法运算

import java.math.BigInteger;

public class Test {

    public static void main(String[] args) {
        //int num1 = 2212345678;// 编译报错,因为右边的数据超过了int类型表示的数据范围
        //long numL = 2212345678L;// 编译不报错,因为数据在long类型表示的数据范围
        //long numL = 221234567822123456782212345678L;// 编译报错,因为右边的数据超过了long类型表示的数据范围

        // 创建BigInteger对象表示超大的整数
        BigInteger b1 = new BigInteger("221234567822123456782212345678");
        BigInteger b2 = new BigInteger("100000000000000000000000000000");

        //- `public BigInteger add(BigInteger value)  		加法运算  `
        BigInteger res1 = b1.add(b2);
        System.out.println("res1:" + res1);

        //- `public BigInteger subtract(BigInteger value)  		减法运算 `
        BigInteger res2 = b1.subtract(b2);
        System.out.println("res2:" + res2);

        //- `public BigInteger multiply(BigInteger value)  		乘法运算  `
        BigInteger res3 = b1.multiply(b2);
        System.out.println("res3:" + res3);

        //- `public BigInteger divide(BigInteger value)  		除法运算`
        BigInteger res4 = b1.divide(b2);
        System.out.println("res4:" + res4);// 2
    }

}

回到顶部

第十章 BigDecimal类

3.12 BigDecimal类

BigDecimal类的概述

概述: java.math.BigDecimal类,表示一个超大的小数,并且可以解决小数运算的精度问题

小数运算精度问题演示:

public class Test1_概述 {
    public static void main(String[] args) {
        // 小数运算的精度问题
        System.out.println(0.09 + 0.01);// 期望的是:0.10,实际不是
        System.out.println(1.0 - 0.32);//  期望的是:0.68,实际不是
        System.out.println(1.015 * 100);// 期望的是:101.5,实际不是
        System.out.println(1.301 / 100);// 期望的是:0.0131,实际不是
    }
}

BigDecimal类构造方法
- BigDecimal(double val) 将double类型的数据封装为BigDecimal对象,不推荐使用,因为使用这个依然还是有精度问题
- BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal

BigDecimal类常用方法

public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算
案例:

import java.math.BigDecimal;

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

      //- `public BigDecimal add(BigDecimal value)  		加法运算  `
      BigDecimal b1 = new BigDecimal("0.09");
      BigDecimal b2 = new BigDecimal("0.01");
      BigDecimal res1 = b1.add(b2);
      System.out.println("res1:" + res1);// 0.10


      //- `public BigDecimal subtract(BigDecimal value)  		减法运算 `
      BigDecimal b3 = new BigDecimal("1.0");
      BigDecimal b4 = new BigDecimal("0.32");
      BigDecimal res2 = b3.subtract(b4);
      System.out.println("res2:" + res2);// 0.68

      //- `public BigDecimal multiply(BigDecimal value)  		乘法运算  `
      BigDecimal b5 = new BigDecimal("1.015");
      BigDecimal b6 = new BigDecimal("100");
      BigDecimal res3 = b5.multiply(b6);
      System.out.println("res3:" + res3);// 101.500


      //- `public BigDecimal divide(BigDecimal value)  		除法运算`
      BigDecimal b7 = new BigDecimal("1.301");
      BigDecimal b8 = new BigDecimal("100");
      BigDecimal res4 = b7.divide(b8);
      System.out.println("res4:" + res4);// 0.01301



      // `BigDecimal(double val)`  将double类型的数据封装为BigDecimal对象,**不推荐使用,因为使用这个依然还是有精度问题**
     /* BigDecimal b1 = new BigDecimal(0.09);
      BigDecimal b2 = new BigDecimal(0.01);
      BigDecimal res1 = b1.add(b2);
      System.out.println("res1:" + res1);*/


      // 小数运算的精度问题
      //System.out.println(0.09 + 0.01);// 期望的是:0.10,实际不是
      //System.out.println(1.0 - 0.32);//  期望的是:0.68,实际不是
      //System.out.println(1.015 * 100);// 期望的是:101.5,实际不是
      //System.out.println(1.301 / 100);// 期望的是:0.0131,实际不是
      //System.out.println(0.2 + 0.3);// 没有精度问题
  }

}

注意:
- 如果使用上面的除法运算的方法,遇到除不尽的就会报数学运算异常,得使用下面重载的方法
- public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 除法运算
  - 参数1: 除数
  - 参数2: 精确的位数
  - 参数3: 取舍的模式 RoundingMode.HALF_UP: 四舍五入
```
BigDecimal b9 = new BigDecimal("20");
BigDecimal b10 = new BigDecimal("3");
BigDecimal res5 = b9.divide(b10,2, RoundingMode.HALF_UP);
System.out.println("res5:" + res5);// 6.67
```

回到顶部

第十一章 Arrays类

3.13 Arrays类

Arrays类概述
- java.util.Arrays类：该类包含用于操作数组的各种静态方法（如排序和搜索）。
Arrays类常用方法
- public static void sort(int[] a)：按照数字顺序排列指定的数组升序
- public static String toString(int[] a)：返回指定数组的内容的字符串表示形式

案例:

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        // 创建int类型的数字,并初始化
        int[] arr = {45,23,54,32,7,53};

        //- `public static String toString(int[] a)：返回指定数组的内容的字符串表示形式`
        System.out.println("排序之前的数组:" + Arrays.toString(arr));

        //- `public static void sort(int[] a)：按照数字顺序排列指定的数组 升序`
        Arrays.sort(arr);
        System.out.println("排序之后的数组:" + Arrays.toString(arr));

    }
}

回到顶部

第十二章包装类

3.13 包装类

包装类的概述

概述: 为了更好的维护基本类型数据，java为基本类型创建了对应的引用类型，这些类称为包装类

分类:

| 基本类型 | 对应的包装类（位于java.lang包中） |
|   byte   |               Byte                |
|  short   |               Short               |
|   int    |               Integer             |
|   long   |               Long                |
|  float   |               Float               |
|  double  |              Double               |
|   char   |             Character             |
| boolean  |              Boolean              |

Integer类的使用---->了解

概述: int类型对应包装类,包装一个对象中的原始类型 int 的值
构造方法
- public Integer(int value) 根据 int 值创建 Integer 对象(过时)
- public Integer(String s) 根据 String 值创建 Integer 对象(过时)
静态方法
- public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例
- public static Integer valueOf(String s) 返回保存指定String值的 Integer 对象

代码:

public class Test {
    public static void main(String[] args) {
        //- 构造方法
        //  - public Integer(int value)  根据 int 值创建 Integer 对象(过时)
        //  - public Integer(String s)  根据 String 值创建 Integer 对象(过时)
        Integer i1 = new Integer(10);
        Integer i2 = new Integer("20");

        //- 静态方法
        //  - public static Integer valueOf(int i)  返回表示指定的 int 值的 Integer   实例
        //  - public static Integer valueOf(String s)  返回保存指定String值的 Integer 对象
        Integer i3 = Integer.valueOf(10);
        Integer i4 = Integer.valueOf("20");

        System.out.println("i1:"+i1);
        System.out.println("i2:"+i2);
        System.out.println("i3:"+i3);
        System.out.println("i4:"+i4);

    }
}

拆箱和装箱

装箱: 把基本类型转换为对应的包装类类型---->包装类的构造方法\valueOf静态方法可以实现
拆箱: 把包装类类型转换为对应的基本类型---->包装类的 xx类型Value() 非静态方法实现

案例:

public class Test {
    public static void main(String[] args) {
        // 把基本类型----->对应的包装类类型--------->装箱
        Integer i1 = new Integer(10);

        // 包装类类型----->对应的基本类型 ------------>拆箱
        int num = i1.intValue();
        System.out.println("num:" + num);
    }
}

自动装箱和自动拆箱-------->重点掌握
- 自动装箱: 基本类型自动转换为对应的包装类类型---->直接把基本类型的值赋值给对应的包装类类型变量
- 自动拆箱: 包装类类型自动转换为对应的基本类型---->直接把包装类的对象赋值给对应的基本类型的变量
```
//- 自动装箱
Integer i5 = 10;

//- 自动拆箱
int num5 = i5;
System.out.println("i5:"+i5);
System.out.println("num5:"+num5);
```
  - 注意: 自动装箱和自动拆箱的时候一定要类型一一对应

基本类型与字符串之间的转换------->重点掌握

基本类型-->字符串:

方式一: 基本类型的数据 + 空的字符串("")
方式二: 字符串的静态方法public static String valueOf(基本类型的值);

案例:

public class Test1 {
    public static void main(String[] args) {
        //基本类型-->字符串:
        //- **方式一:   基本类型的数据 + 空的字符串("")**
        String str1 = 100 + "";

        //- 方式二:   字符串的静态方法`public static String valueOf(基本类型的值);`
        String str2 = String.valueOf(100);
        System.out.println("str1:" + str1);
        System.out.println("str2:" + str2);
    }
}

字符串-->基本类型:
- 方式一: 通过包装类的静态方法valueOf(String s)得到包装类对象,然后包装类对象自动拆箱为基本类型--->除了Character包装类之外,所有包装类都有这个方法
- 方式二: 通过包装类的静态方法parseXXX类型(String s)得到对应的基本类型--->除了Character包装类之外,所有包装类都有这个方法
```
// 字符串-->基本类型:
// 方式一
int num1 = Integer.valueOf("100");

// 方式二
int num2 = Integer.parseInt("100");
System.out.println("num1:"+num1);
System.out.println("num2:"+num2);
```

回到顶部

总结

必须练习:
	1.理解各个权限修饰符的权限
    2.掌握代码块的使用--->特别是静态代码块
    3.熟练掌握几个api
        3.1 Object类的2个方法,
		3.2 Date与String之间的转换--->SimpleDateFormat
        3.3 BigDecimal类的使用
        3.4 Arrays类的toString方法
        3.5 System类的2个方法
        3.6 Calendar类的常用方法
    4.自动装箱和自动拆箱
    5.基本类型和字符串之间的转换
            
- 能够说出每种权限修饰符的作用
  			 同一个类		同一个包		不同包的父子类			不同包的无关类
    public   	√				√				√					√
    protected	√				√				√					×
    默认		   √			   √               ×                   ×
    private     √               ×               ×                   ×    
            
- 能够说出Object类的特点
   Object类是java中所有类的父类\根类,所有类都用有Object类中的11个方法
            
- 能够重写Object类的toString方法
    alt+insert--->toStrig()
    如果打印对象的时候不希望打印的是地址值,那么就重写toString方法
            
- 能够重写Object类的equals方法
   Object类的equals方法默认比较的是地址值
   如果希望比较的不是地址值,而是所有的属性值,那么就按alt+insert,选择equals() and hashCode()重写就行
   alt+insert---> equals() and hashCode()
            
- 能够使用日期类输出当前日期
    public Date();

- 能够使用将日期格式化为字符串的方法
   SimpleDateFormat: public String format(Date date);

- 能够使用将字符串转换成日期的方法
    SimpleDateFormat: public Date parse(String date);

- 能够使用Calendar类的get、set、add方法计算日期
  public int get(int field)  获取某个字段的值。
  public void set(int field,int value)  修改某个字段的值。
  public void add(int field,int value)  增加或者减少某个字段的值。
    
- 能够使用Math类对某个浮点数进行四舍五入取整
   public static long round(double a)             四舍五入取整
    
- 能够使用System类获取当前系统毫秒值
  public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值;

- 能够说出BigDecimal可以解决的问题
    小数运算精度问题,表示超大的小数
    
- 能够说出自动装箱、自动拆箱的概念
   - 自动装箱: 基本类型自动转换为对应的包装类类型---->直接把基本类型的值赋值给对应的包装类类型变量
   - 自动拆箱:  包装类类型自动转换为对应的基本类型---->直接把包装类的对象赋值给对应的基本类型的变量

- 能够将基本类型转换为对应的字符串
     基本类型的数据 + 空的字符串("")
       
- 能够将字符串转换为对应的基本类型
      包装类的静态方法:  parseXXX类型(String s)

posted on 2022-04-24 23:39 ofanimon 阅读(39) 评论(0) 编辑收藏举报

刷新页面返回顶部

（评论功能已被禁用）

相关博文：

· 16-复习

· 01-复习回顾、继承、抽象类、模板设计模式

· 常见Api练习

· 第二十二节 API（时间，包装类，练习）

· 【Object类、常用API】

阅读排行：
· 使用C#创建一个MCP客户端
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现

搜索

常用链接

最新随笔

我的标签

随笔分类

随笔档案

阅读排行榜

今日内容

第一章 权限修饰符

1.1 权限修饰符

概述

不同权限的访问能力

开发中的使用

第二章 代码块

2.1 构造代码块

2.2 静态代码块

2.3 局部代码块

2.4 注意

第三章 Object类

3.1 Object类的概述

3.2 toString方法

3.3 equals方法

3.4 Objects类

3.5 native方法

第四章 Date类

3.5 Date类

第五章 DateFormat类

3.6 DateFormat类

3.7 日期类练习

需求

分析

实现

第六章 Calendar类

3.8 Calendar类

第七章 Math类

3.9 Math类

第八章 System

3.10.1 System类

3.10.2 练习

需求

分析

实现

第九章 BigInteger类

3.11 BigInteger类

第十章 BigDecimal类

3.12 BigDecimal类

第十一章 Arrays类

3.13 Arrays类

第十二章 包装类

3.13 包装类

总结

第一章权限修饰符

第二章代码块

第十二章包装类