day08【常用API】课上

最新推荐文章于 2024-05-22 14:43:22 发布

娃娃哈哈

最新推荐文章于 2024-05-22 14:43:22 发布

阅读量124

点赞数

分类专栏： java 文章标签：字符串 jdk java

本文链接：https://blog.csdn.net/weixin_43525993/article/details/106837282

版权

java 专栏收录该内容

68 篇文章 2 订阅

订阅专栏

1.Object类(掌握)

在java中Object类是最顶层父类，所有类默认都继承Object.也就是说所有类都可以使用Obejct类中的方法。如果Object类中的方法体实现的功能不是我们的类需要的，我们需要在子类中重写该方法修改方法体，使用子类对象运行直接运行子类重写之后的方法。

1.该类属于java.lang包，不需要导包

1.1 toString()方法

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

代码演示：

package com.itheima.sh.object_01;
/*
    实体类：javabean
 */
public class Student {
    //私有化所有的成员变量
    private String name;
    private int age;
    //提供构造方法 无参的

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //get set

    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;
    }
    //重写toString方法

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

package com.itheima.sh.object_01;

public class Test01 {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student("张三",18);
//        System.out.println("姓名："+s.getName());
//        System.out.println("年龄："+s.getAge());
        //直接输出对象名 s
        /*
            com.itheima.sh.object_01.Student@1540e19d
            分析：
                1.直接输出对象s输出一串地址的原因是因为底层调用了Object类中的toString方法：
                  String toString() 返回该对象的字符串表示。
                  如果这里我们不调用，那么底层调用，我们在这里也可以直接调用。
                  Object类的toString() 方法源码：
                   public String toString() {
                        return getClass().getName() + "@" + Integer.toHexString(hashCode());
                    }
                    解释：
                        1）getClass().getName() ：在这里表示获取当前Student类的全名(包名.类名)
                                com.itheima.sh.object_01.Student
                            a:getClass()调用类Object类中的方法，获取当前调用该方法的类型
                            b:getName():获取所表示类型的类全名
                        2）Integer.toHexString(hashCode())：将对象的哈希值变为十六进制
               2.我们希望打印对象s的时候不在打印一串地址的时候，想打印成员变量内容，此时我们需要
               在子类重写toString即可。我们使用快捷键：alt+insert
         */
        System.out.println(s);//Student{name='张三', age=18}
    }
}

小结：

1.如果对于某个类来说输出对象不想看地址，那么就重写toString方法，直接输出内容。通过快捷键：alt+insert重写

1.2 equals方法

boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。 
    	参数：obj 表示其他某个对象 
    		此对象 表示调用equals方法的对象
    	    该方法表示判断调用的对象和参数传递的对象是否相等，在开发中一般我们判断两个引用类型的对象是否相等             都是判断对象表示内容是否相等，不是地址值
    	返回值：如果两个对象相等返回true，不相等返回false

代码演示：

package com.itheima.sh.object_01;

import java.util.Objects;

/*
    实体类：javabean
 */
public class Student {
    //私有化所有的成员变量
    private String name;
    private int age;
    //提供构造方法 无参的

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //get set

    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;
    }
    //重写toString方法

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals方法：alt+insert
    @Override
    public boolean equals(Object o) {
        //this 就是调用者s1  o接收的是参数即s2
        //这里在比较两个对象this和o的对象地址值是否相等，
        //如果两个对象地址值相等了，说明两个对象是同一个对象
        if (this == o) return true;
        /*
            1.判断o是否等于null，如果等于null直接返回false
            2.getClass() != o.getClass()
                前面的是this.getClass():获取调用对象的类型
                o.getClass() 参数对象的类型，如果两个类型不相等，直接返回false
         */
        if (o == null || getClass() != o.getClass()) return false;
        //能够执行到这里，说明两个对象类型肯定一致
        //这里在强制转换
        Student student = (Student) o;
        //比较Student类的属性是否相等
        //==左边的age是this.age 就是调用对象age
        //student.age表示参数的age
        return age == student.age &&
                //底层比较两个name的值是否相等
                Objects.equals(name, student.name);
    }
/*
    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }*/
}


package com.itheima.sh.object_01;
/*
    boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
    	参数：obj 表示其他某个对象
    		此对象 表示调用equals方法的对象
    	    该方法表示判断调用的对象和参数传递的对象是否相等，在开发中一般我们判断两个引用类型的对象是否相等             都是判断对象表示内容是否相等，不是地址值
    	返回值：如果两个对象相等返回true，不相等返回false
 */
public class Test02 {
    public static void main(String[] args) {
        //创建两个学生对象比较内容是否相等
        Student s1 = new Student("柳岩", 18);
        Student s2 = new Student("柳岩", 18);
        //使用对象调用方法比较上述对象s1 和 s2是否相等
        /*
            分析：
            1.问题
               我们发现即使s1和s2 的内容是相等的，但是比较的结果依然是false。
               通过debug发现原因出现在Object类的的equals方法那里了：
               public boolean equals(Object obj) {
                    return (this == obj);
                }
               this:就是调用者对象即s1
               obj:参数传递对象地址即s2
               发现源码底层使用 == 比较的是这两个对象地址值，那么永远是false
           2.解决问题：
              我们需要在子类重写Object类中的equals方法来比较两个对象内容
              使用快捷键：alt+insert
         */
        //Person p = new Person();
        boolean boo = s1.equals(s2);
        System.out.println("boo = " + boo);
    }
}

小结：

1.只要我们比较引用数据类型，那么需要使用equals方法来比较内容，如果当前类没有重写Object类的equals方法，我们需要在当前类使用alt+insert快捷键重写即可

2.重写之后的方法解释：

//重写equals方法：alt+insert
    @Override
    public boolean equals(Object o) {
        //this 就是调用者s1  o接收的是参数即s2
        //这里在比较两个对象this和o的对象地址值是否相等，
        //如果两个对象地址值相等了，说明两个对象是同一个对象
        if (this == o) return true;
        /*
            1.判断o是否等于null，如果等于null直接返回false
            2.getClass() != o.getClass()
                前面的是this.getClass():获取调用对象的类型
                o.getClass() 参数对象的类型，如果两个类型不相等，直接返回false
         */
        if (o == null || getClass() != o.getClass()) return false;
        //能够执行到这里，说明两个对象类型肯定一致
        //这里在强制转换
        Student student = (Student) o;
        //比较Student类的属性是否相等
        //==左边的age是this.age 就是调用对象age
        //student.age表示参数的age
        return age == student.age &&
                //底层比较两个name的值是否相等
                Objects.equals(name, student.name);
    }

1.3使用native修饰的方法(了解)

native本身表示本地的意思，使用该修饰符修饰的方法我们是无法查看源码的，因为他底层不是使用java代码实现的，是c或者c++实现的。

查找源码：ctrl+N

看某个类的成员：alt+7

public native int hashCode();

2.Objects类(了解)

1.位于java.util包下的，需要导包

2.属于jdk1.7才有的，表示工具类，工具类的构造方法全部要私有化。不让创建对象。工具类中的方法全部是静态的，直接使用类名调用

3.这个工具类主要防止空指针异常

package com.itheima.sh.obejcts_02;

import java.util.Objects;

public class Test01 {
    public static void main(String[] args) {
        //定义字符串
       /* String s1 = "abc";
        String s2 = "def";
        //判断两个字符串是否相等
        boolean boo = s1.equals(s2);//该equals方法是Stirng类重写之后的  比较内容
        System.out.println("boo = " + boo);//false*/
//        String s1 = null;
        String s1 = "abc";
        String s2 = "def";
        //判断两个字符串是否相等
//        boolean boo = s1.equals(s2);//这里s1是null的话就会报空指针异常
        /*
            从jdk7开始为了尽量避免空指针异常，诞生了工具类Objects来防止。
            常用方法：
                static boolean equals(Object a, Object b) 返回 true如果参数相等，彼此 false否则。
                    参数：
                        a:对象1
                        b:对象2
         */
        /*
            查看equals方法源码：
            public static boolean equals(Object a, Object b) {
                return (a == b) || (a != null && a.equals(b));
            }
            说明：
               1.a == b 比较两个对象是否相等，如果相等直接返回true 不相等向后面执行
               2.a != null判断a是否等于null，这里判断a是否等于null的原因是因为后面a是调用者，防止空指针异常
                如果等于null，则不执行后面内容
                如果不等于null，则执行后面内容。a.equals(b) 执行子类对象a所属的类的equals方法
         */
        boolean boo = Objects.equals(s1, s2);
        System.out.println("boo = " + boo);//false
    }
}

小结：

  查看equals方法源码：
            public static boolean equals(Object a, Object b) {
                return (a == b) || (a != null && a.equals(b));
            }
            说明：
               1.a == b 比较两个对象是否相等，如果相等直接返回true 不相等向后面执行
               2.a != null判断a是否等于null，这里判断a是否等于null的原因是因为后面a是调用者，防止空指                针异常
                如果等于null，则不执行后面内容
                如果不等于null，则执行后面内容。a.equals(b) 执行子类对象a所属的类的equals方法

3.Date类(掌握)

1.表示时间日期类，属于java.util包，需要导包

2.构造方法：

1.Date() 调用无参构造方法创建Date对象获取当前系统时间
2.Date(long date) 根据指定的毫秒值获取时间

3.方法：

 1.public long getTime() 把日期对象转换成对应的时间毫秒值。
 2.public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象

代码演示：

package com.itheima.sh.date_03;

import java.util.Date;

/*
    构造方法：
        1.Date() 调用无参构造方法创建Date对象获取当前系统时间
        2.Date(long date) 根据指定的毫秒值获取时间
    方法：
        Date类中的多数方法已经过时，常用的方法有：
        1.public long getTime()` 把日期对象转换成对应的时间毫秒值。
        2.public void setTime(long time)` 把方法参数给定的毫秒值设置给日期对象
 */
public class DateDemo01 {
    public static void main(String[] args) {
        //1.Date() 调用无参构造方法创建Date对象获取当前系统时间
        Date d = new Date();
        //d=Tue May 12 10:39:17 GMT+08:00 2020
        System.out.println("d="+d);
        //2.Date(long date) 根据指定的毫秒值获取时间
//        Date d2 = new Date(2171919198178L);
//        //d2 = Fri Oct 29 06:53:18 GMT+08:00 2038
//        System.out.println("d2 = " + d2);
        //public long getTime()` 把日期对象转换成对应的时间毫秒值。
//        long time = d.getTime();
//        System.out.println("time = " + time);
        // 2.public void setTime(long time)` 把方法参数给定的毫秒值设置给日期对象
        //将当前时间d更改为指定毫秒时间
        d.setTime(2171919198178L);
        System.out.println("d="+d);
    }
}

小结：

构造方法：

   1.Date() 调用无参构造方法创建Date对象获取当前系统时间
   2.Date(long date) 根据指定的毫秒值获取时间

方法：


   Date类中的多数方法已经过时，常用的方法有：
   1.public long getTime()` 把日期对象转换成对应的时间毫秒值。
   2.public void setTime(long time)` 把方法参数给定的毫秒值设置给日期对象

4.DateFormat类(理解)

4.1类的介绍

1.该类属于java.text包下的，需要导包

2.该类属于抽象类不能创建对象，可以通过创建他的子类(SimpleDateFormat )对象，然后可以使用该类(父类接收，多态)，也可以不多态

3.DateFormat类及其子类SimpleDateFormat称为日期格式化解析类：

1)格式化：日期 -> 文本就是将我们之前看不懂的 Date日期格式转换为看的懂的字符串形式

Tue May 12 10:39:17 GMT+08:00 2020 格式化之后：2020年05月12日 10:39:17

2)解析: 文本-> 日期就是将我们之前看懂的字符串时间换为看不懂的Date格式

"2020年05月12日 10:39:17" 解析后：Tue May 12 10:39:17 GMT+08:00 2020

4.2类的演示

DateFormat类是抽象类，不能创建对象，使用子类SimpleDateFormat创建，子类构造方法：

SimpleDateFormat(String pattern) 参数：pattern表示可以指定的日期格式
    	参数举例："yyyy年MM月dd日 HH时mm分ss秒"

标识字母（区分大小写）	含义
y year	年
M month	月
d day	日
H hour	时
m minute	分
s second	秒

代码演示：

package com.itheima.sh.date_03;

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

/*
    格式化：日期 -> 文本 就是将我们之前看不懂的	Date日期格式转换为看的懂的字符串形式
    解析: 文本-> 日期 就是将我们之前看懂的字符串时间换为看不懂的Date格式
 */
public class DateFormatDemo01 {
    public static void main(String[] args) throws ParseException {
        //1.格式化：日期 -> 文本 就是将我们之前看不懂的	Date日期格式转换为看的懂的字符串形式
        //创建Date对象
        Date d = new Date();
        //Tue May 12 11:07:24 GMT+08:00 2020
        System.out.println("d = " + d);
        //1.1创建日期格式化解析类的对象 SimpleDateFormat(String pattern) 参数：pattern表示可以指定的日期格式
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //1.2调用格式化方法对时间d进行格式化
        String str = df.format(d);
        //2020年05月12日 11时07分24秒
        System.out.println("str = " + str);
        //2.解析: 文本-> 日期 就是将我们之前看懂的字符串时间换为看不懂的Date格式
        //调用解析方法将上述字符串str解析为Date格式
        /*
            注意：对于parse(str)解析方法，要求参数str字符串中的时间格式必须满足创建子类对象时指定的时间格式，否则会报异常
         */
//        Date newDate = df.parse(str);//解决这里红色波浪线：按alt+enter
        Date newDate = df.parse("2020-05月12日 11时07分24秒");//解决这里红色波浪线：按alt+enter
        //Tue May 12 11:07:24 GMT+08:00 2020
        System.out.println("newDate = " + newDate);
    }
}

小结：

1.格式化：

格式化：日期 -> 文本 就是将我们之前看不懂的	Date日期格式转换为看的懂的字符串形式
     DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
      //1.2调用格式化方法对时间d进行格式化
      String str = df.format(d);//2020年05月12日 11时07分24秒

2.解析：

解析: 文本-> 日期 就是将我们之前看懂的字符串时间换为看不懂的Date格式
  DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
  Date newDate = df.parse("2020-05月12日 11时07分24秒");//解决这里红色波浪线：按alt+enter

4.3练习

1.练习一：字符串日期的格式转化

package com.itheima.sh.dateformat_04;

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

public class DateFormatTest01 {
    public static void main(String[] args) throws ParseException {
        /*
            练习一：字符串日期的格式转化
            键盘输入一个日期：2008年8月8日
            需求：变成"2008/8/8"的格式
            步骤：
            1.创建键盘录入的对象
            2.接收录入的时间
            3.创建日期格式化解析类的对象SimpleDateFormat("yyyy年MM月dd日");
            4.将录入的日期解析为Date对象
            5.创建日期格式化解析类的对象SimpleDateFormat("yyyy/MM/dd");
            6.将上述的Date格式化为"2008/8/8"的格式
            7.输出格式化后的内容
         */
        //1.创建键盘录入的对象
        Scanner sc = new Scanner(System.in);
        //2.接收录入的时间
        System.out.println("请输入时间(yyyy年MM月dd日):");
        String timeStr = sc.nextLine();
        //3.创建日期格式化解析类的对象SimpleDateFormat("yyyy年MM月dd日");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        //4.将录入的日期解析为Date对象
        Date date1 = sdf.parse(timeStr);
        //5.创建日期格式化解析类的对象SimpleDateFormat("yyyy/MM/dd");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");
        //6.将上述的Date格式化为"2008/8/8"的格式
        String str = sdf2.format(date1);
        //7.输出格式化后的内容
        System.out.println("str = " + str);
    }
}

2.求你来到这个世界多少天？

package com.itheima.sh.dateformat_04;

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

/*
    	键盘输入一个字符串类型的时间，打印来到世界多少天。
    	比如：
    		请输入你的出生时间：
    			1999-01-01
                       你来到这个世界已经8888天了
        分析：
        生日：现在时间-出生日期，如果想进行计算必须将录入的字符串和系统时间转换为毫秒值
        然后将转换的毫秒值进行运算，最后将差值转换为天数。1s=1000ms
        步骤：
        1.创建键盘录入的对象
        2.获取出生时间
        3.创建日期格式化解析类的对象 SimpleDateFormat("yyyy-MM-dd");
        4.将生日解析为Date格式
        5.将Date对象转换为毫秒
        6.创建Date对象获取当前系统时间
        7.将当前系统时间转换为毫秒
        8.将当前的时间的毫秒减去生日的毫秒，然后将差值转换为天数并输出
 */
public class DateFormatTest02 {
    public static void main(String[] args) throws ParseException {
        //1.创建键盘录入的对象
        Scanner sc = new Scanner(System.in);
        //2.获取出生时间
        System.out.println("请输入您的生日(yyyy-MM-dd):");
        String input_bir = sc.nextLine();
        //3.创建日期格式化解析类的对象 SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //4.将生日解析为Date格式
        Date date_bir = sdf.parse(input_bir);
        //5.将Date对象转换为毫秒
        long time_bir = date_bir.getTime();
        //6.创建Date对象获取当前系统时间
        Date date_today = new Date();
        //7.将当前系统时间转换为毫秒
        long time_today = date_today.getTime();
        //8.将当前的时间的毫秒减去生日的毫秒，然后将差值转换为天数并输出
        //(time_today - time_bir)/1000/60/60/24
        System.out.println("您出生了:"+(time_today - time_bir)/1000/60/60/24+" 天");
    }
}

5.Calendar类(理解)

1.该类位于java.util包，需要导包

2.属于抽象类，不能创建该类对象，所以我们创建子类(GregorianCalendar )对象：

1)直接使用new调用子类构造方法创建对象(了解)

2)使用Calendar类的静态方法获取子类对象：(建议使用，掌握)

static Calendar getInstance()

3.操作日历字段(YEAR MONTH…)的类

4.方法介绍：

方法名	说明
public static Calendar getInstance()	获取一个它的子类GregorianCalendar对象。
public int get(int field)	获取某个字段的值。field参数表示获取哪个字段的值，可以使用Calender中定义的常量来表示： Calendar.YEAR : 年 Calendar.MONTH ：月 Calendar.DAY_OF_MONTH：月中的日期 Calendar.HOUR：小时 Calendar.MINUTE：分钟 Calendar.SECOND：秒 Calendar.DAY_OF_WEEK：星期
public void set(int field,int value)	设置某个字段的值
public void add(int field,int amount)	为某个字段增加/减少指定的值
setTime(Date date)	把Date对象转成Calendar对象

代码演示1：

package com.itheima.sh.calendar_05;

import java.util.Calendar;

/*
    方法演示
     1.public static Calendar getInstance()获取子类对象
     2.public int get(MONTH)
        获取某个字段的值。field参数表示获取哪个字段的值， 可以使用Calender中定义的常量来表示： Calendar.YEAR : 年 Calendar.MONTH ：
       举例：get(Calendar.YEAR);
 */
public class CalendarDemo01 {
    public static void main(String[] args) {
        //1.public static Calendar getInstance()获取子类对象
        Calendar c = Calendar.getInstance();
        /*
            c = java.util.GregorianCalendar[time=1589255613229,areFieldsSet=true,areAllFieldsSet=true,
            lenient=true,zone=sun.util.calendar.ZoneInfo[id="GMT+08:00",offset=28800000,dstSavings=0,
            useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,
            ERA=1,YEAR=2020,MONTH=4,WEEK_OF_YEAR=20,WEEK_OF_MONTH=3,DAY_OF_MONTH=12,DAY_OF_YEAR=133,
            DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=2,AM_PM=0,HOUR=11,
            HOUR_OF_DAY=11,MINUTE=53,SECOND=33,MILLISECOND=229,ZONE_OFFSET=28800000,DST_OFFSET=0]
            说明：
            1.java中月份范围是 0 - 11  月份超过范围，年份+1
            2.DAY_OF_WEEK：一周的第几天，在java中一周的第一天是周日，最后一天是周六：
                1   2   3   4   5   6   7
                日  一  二   三  四  五  六
         */
//        System.out.println("c = " + c);
        /*
               2.public int get(MONTH)
                获取某个字段的值。field参数表示获取哪个字段的值， 可以使用Calender中定义的常量来表示： Calendar.YEAR : 年 Calendar.MONTH ：
               举例：get(Calendar.YEAR);
         */
        //获取年
        int year = c.get(Calendar.YEAR);
        System.out.println("year = " + year);
        //获取月份
        int month = c.get(Calendar.MONTH);
        System.out.println("month = " + month);//4对应的是5月
        System.out.println("现在是"+year+"年"+(month+1)+"月");
        //获取星期
        //Calendar.DAY_OF_WEEK：星期
        int week = c.get(Calendar.DAY_OF_WEEK);
        System.out.println("week = " + week);//3
        //调用自定义方法根据获取的数字来获取字符串对应的星期
        String dayWeek = getDayWeek(week);
        System.out.println("dayWeek = " + dayWeek);
    }

    public static String getDayWeek(int week) {
        //定义数组
        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return arr[week];
    }
}

代码演示2:

package com.itheima.sh.calendar_05;

import java.util.Calendar;

/*
    3.public void set(int field,int value)设置某个字段的值
                参数：
                    field：字段或者成员变量，就是Calendar类中的静态成员变量名
                    value:表示修改后的值
    4.public void add(int field,int amount) 为某个字段增加/减少指定的值
                    参数：
                         field：字段或者成员变量，就是Calendar类中的静态成员变量名
                         amount：如果是正数就增加，如果是负数就减少，amount表示增加或者减少的量
                    注意：如果使用add方法，月份超过范围，修改年数；
                          如果天数超过范围，修改月份
                          2020年5月12日
 */
public class CalendarDemo02 {
    public static void main(String[] args) {
        method_2();

    }

    private static void method_2() {
        //获取Calendar子类对象
        Calendar c = Calendar.getInstance();
        //4.public void add(int field,int amount) 为某个字段增加/减少指定的值
//        c.add(Calendar.YEAR,2);//在现在的年份上+2
        c.add(Calendar.MONTH, -6);

        int year = c.get(Calendar.YEAR);
        System.out.println("年：" + year);
        //获取月份
        int month = c.get(Calendar.MONTH) + 1;
        System.out.println("当前月份是:" + month);

    }

    //抽取方法快捷键：ctrl+alt+M
    private static void method_1() {
        //获取Calendar子类对象
        Calendar c = Calendar.getInstance();
        /*
            3.public void set(int field,int value)设置某个字段的值
                参数：
                    field：字段或者成员变量，就是Calendar类中的静态成员变量名
                    value:表示修改后的值
         */
        //修改年份
    /*    c.set(Calendar.YEAR,2030);
        //获取年份
        int year = c.get(Calendar.YEAR);
        System.out.println("年："+year);//年：2030*/
        int year = c.get(Calendar.YEAR);
//        System.out.println("年："+year);
        //修改月份
        c.set(Calendar.MONTH, 12);
        //获取月份
        int month = c.get(Calendar.MONTH) + 1;//java中的月份范围是0-11  那么4对应的是5月份
        /*
            如果月份设置不在0-11之间，那么
                如果是负数那么输出的是上一年的月份
                如果是正数那么输出的是后一年的月份
         */
        System.out.println("当前月份是:" + month);
    }
}

小结：

3.public void set(int field,int value)设置某个字段的值
参数：
field：字段或者成员变量，就是Calendar类中的静态成员变量名
value:表示修改后的值
4.public void add(int field,int amount) 为某个字段增加/减少指定的值
参数：
field：字段或者成员变量，就是Calendar类中的静态成员变量名
amount：如果是正数就增加，如果是负数就减少，amount表示增加或者减少的量
注意：如果使用add方法，月份超过范围，修改年数；
如果天数超过范围，修改月份
2020年5月12日

代码演示：

 private static void method_3() {
        //获取Calendar子类对象
        Calendar c = Calendar.getInstance();
        //获取年份
        int year = c.get(Calendar.YEAR);
        System.out.println("year = " + year);//2020
        //创建Date对象
        //将参数的毫秒转换为Date
        Date date = new Date(819181817181L);
        //date = Sun Dec 17 14:30:17 GMT+08:00 1995
        System.out.println("date = " + date);
        //5. void setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。
        //将当前对象c中表示的时间修改为date时间
        c.setTime(date);
        //获取年份
        int year2 = c.get(Calendar.YEAR);
        System.out.println("year2 = " + year2);//1995
        System.out.println(c);
    }

小结：Calendar类：

方法名	说明
public static Calendar getInstance()	获取一个它的子类GregorianCalendar对象。
public int get(int field)	获取某个字段的值。field参数表示获取哪个字段的值，可以使用Calender中定义的常量来表示： Calendar.YEAR : 年 Calendar.MONTH ：月 Calendar.DAY_OF_MONTH：月中的日期 Calendar.HOUR：小时 Calendar.MINUTE：分钟 Calendar.SECOND：秒 Calendar.DAY_OF_WEEK：星期
public void set(int field,int value)	设置某个字段的值 value是设置的新值
public void add(int field,int amount)	为某个字段增加/减少指定的值。amount 表示是在当前指定的字段上进行加或者减amount
setTime(Date date)	把Date对象转成Calendar对象

6.Math类(掌握)

1.属于java.lang 包下，不用导包

2.Math类表示数学类，描述和数学相关的方法

3.Math属于工具类：

1）方法全部是静态的，使用类名直接调用

2）构造方法私有化，不让创建对象

4.方法：

方法名	说明
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)	四舍五入取整

代码演示：

package com.itheima.sh.math_06;
/*
    1.public static int abs(int a)          获取参数a的绝对值 -10的绝对值是10
    2.public static double ceil(double a)    向上取整
    3.public static double floor(double a)   向下取整
    4.public static double pow(double a, double b)  获取a的b次幂
    5.public static long round(double a)            四舍五入取整
 */
public class MathDemo01 {
    public static void main(String[] args) {
        //1.public static int abs(int a)          获取参数a的绝对值 -10的绝对值是10
        System.out.println(Math.abs(-10));//10
        // 2.public static double ceil(double a)    向上取整
        System.out.println(Math.ceil(1.2));//2.0
        //3.public static double floor(double a)   向下取整
        System.out.println(Math.floor(1.2));//1.0
        //4.public static double pow(double a, double b)  获取a的b次幂
        System.out.println(Math.pow(2,3));//求2的3次幂  8.0
        //5.public static long round(double a)            四舍五入取整
        System.out.println(Math.round(1.4));//1
        System.out.println(Math.round(1.5));//2
    }
}

小结：

    1.public static int abs(int a)          获取参数a的绝对值 -10的绝对值是10
    2.public static double ceil(double a)    向上取整
    3.public static double floor(double a)   向下取整
    4.public static double pow(double a, double b)  获取a的b次幂
    5.public static long round(double a)            四舍五入取整

7.System类(掌握)

1.属于java.lang包，不需要导包

2.表示系统类，构造方法被私有化，直接使用类名调用静态方法

3.方法

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)
static void arrayCopy()	数组中元素的复制
static String lineSeparator()	返回与系统相关的行分隔符字符串。

4.代码演示：

package com.itheima.sh.system_07;

import java.util.Date;

/*
    1.public   static void exit(int status)终止当前运行的   Java   虚拟机，非零表示异常终止
        参数：给0即可
    2.public   static long currentTimeMillis()返回当前时间(以毫秒为单位)
    3.static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
          参数：
            src - 源数组。
            srcPos - 源数组中的起始位置。
            dest - 目标数组。
            destPos - 目标数据中的起始位置。
            length - 要复制的数组元素的数量。
    4.static String lineSeparator()返回与系统相关的行分隔符字符串。
 */
public class SystemDemo01 {
    public static void main(String[] args) {
        //1.public   static void exit(int status)终止当前运行的   Java   虚拟机，非零表示异常终止
//        System.exit(0);
//        System.out.println("哈哈");
        //2.public   static long currentTimeMillis()返回当前时间(以毫秒为单位)
//        Date d = new Date();
//        long time = d.getTime();
//        System.out.println("time = " + time);//1589267554383
//        long time2 = System.currentTimeMillis();
//        System.out.println("time2 = " + time2);//1589267554383 推荐使用
        /*
             3.static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
              从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
              参数：
                src - 源数组。
                srcPos - 源数组中的起始位置。
                dest - 目标数组。
                destPos - 目标数据中的起始位置。
                length - 要复制的数组元素的数量。
         */
        //定义源数组
       /* int[] srcArr = {1,2,3,4,5};
        //目标数组
        int[] destArr = {6,7,8,9,0};
        //需求：将源数组srcArr中的前三个数据复制到目标数组destArr的前三个位置 最后结果： int[] destArr = {1,2,3,9,0};
        //参数：srcArr 表示源数组 第一个0:源数组中的起始位置
        //第二个0表示目标数组的起始位置 3 表示复制元素个数
        System.arraycopy(srcArr,0,destArr,0,3);
        //遍历数组
        for (int i = 0; i < destArr.length; i++) {
            //1 2 3 9 0
            System.out.print(destArr[i]+" ");
        }*/
       /*
         4.static String lineSeparator()返回与系统相关的行分隔符字符串。
            window系统换行符：\r\n
            不同操作系统换行符是不一样的，那么java是跨平台(操作系统)，
            那么当前java代码拿到其他操作系统就不能换行
          我们可以使用方法：static String lineSeparator()可以获取不同操作系统的换行符
          属于jdk7后的
        */
       //获取当前系统的行分隔符
        String lineSeparator = System.lineSeparator();
//        System.out.print("张三\r\n柳岩");
        System.out.print("张三"+lineSeparator+"柳岩");
    }
}

小结：

1.public static void exit(int status)终止当前运行的 Java 虚拟机，非零表示异常终止
参数：给0即可
2.public static long currentTimeMillis()返回当前时间(以毫秒为单位)
3.static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
参数：
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
4.static String lineSeparator()返回与系统相关的行分隔符字符串。

娃娃哈哈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
day08【常用API】课上

1.Object类(掌握)在java中Object类是最顶层父类，所有类默认都继承Object.也就是说所有类都可以使用Obejct类中的方法。如果Object类中的方法体实现的功能不是我们的类需要的，我们需要在子类中重写该方法修改方法体，使用子类对象运行直接运行子类重写之后的方法。1.该类属于java.lang包，不需要导包1.1 toString()方法 String toString() 返回该对象的字符串表示。代码演示：package com.itheima.sh.object_01
复制链接

扫一扫