公告

今日内容

权限修饰符 ----->掌握
- 分类
- 权限
代码块(格式,位置,执行,使用场景)
- 构造代码块
- 静态代码块 ----->掌握
- 局部代码块
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 阅读(36) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部