java学习笔记(5) - 面向对象(5)

1. 包装类

• 包装类（Wrapper Class）： Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类(Wrapper Class)，包装类均位于java.lang包。

• 为了使用方便Java中将8中基本数据类型进行了封装：除了Integer和Character类以后，其它六个类的类名和基本数据类型一直，只是类名的第一个字母大写即可。

• boolean —> Boolean
• char —> Character
• byte—> Byte
• short—> Short
• long—> Long
• int —> Integer
• float—> Float
• double—> Double

作用:

1. 作为 和基本数据类型对应的类 类型存在，方便涉及到对象的操作。
2. 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

// TODO 包装类
Byte b = null;
Short s = null;
Integer i = null;
Long lon = null;
Float f = null;
Double d = null;
Character c = null;
Boolean bln = null;
// 可以认为用箱子将基本数据类型包装起来转换成对象

• 基本都是类似的,因此这里就取最有代表性的Integer来作例子

package chapter04;

public class DateType {
    public static void main(String[] args){
        // 包装类
        // 一 . 创建包装类
        // 1. new创建 (不推荐使用)
        int a = 10;
        Integer a1 = new Integer(a); // 不推荐使用,已经被淘汰

        // 2[重点]. valueOf创建 (也不推荐使用)
        Integer a2 = Integer.valueOf(a);// 也不推荐使用

        // 3. 自动装箱 (推荐使用) - valueOf的简写版本
        Integer a3 = a;

        // 二 . 包装类转换为基本类型
        // 1. 对应的类型转换(就不推荐使用)
        int aa = a1.intValue(); // 转换为 int 型数据

        // 2[重点]. 自动拆箱(推荐使用)
        int aaa = a1;

        // 三 . 再创建了包装类后,我们就可以使用包装类的一些方法进行面向对象的编程操作了
        // 1. 如 Integer 型数据转换为 String 型
        //parseInt方法： 数字字符串类型转成int类型
        String ss="123";
        int ii = Integer.parseInt(ss);
        System.out.println("字符类型转成整型："+ii);
        //toString方法：int类型转成数字字符串类型
        int ii2=123;
        String ss2 = Integer.toString(ii2);
        System.out.println("int类型转成数字字符串类型:"+ss);

        /*
        *  一、int 是基本类型，直接存数值；而integer引用数据类型。
           二、Int的声明不需要实例化，且变量声明后的初始值为0；Integer的是一个类，初始值为null，需要进行实例化，才能对变量数据进行处理。
           三、Integer类是int的包装类，实际开发中Integer被看成一个对象，可以进行数据转换等操作。
        * */
    }
}

包装类的常用方法:

（一）基本类型的最值

1、int类型

（1）最大值调用的方法 Integer.MAX_VALUE

（2）最小值调用的方法 Integer.MIN_VALUE

2、Long类型

（1）最大值调用的方法 Long.MAX_VALUE

（2）最小值调用的方法 Long.MIN_VALUE

3、其他基本数据类型同理

（二）十进制转其他类型的进制

1、十进制转二进制：Integer.toBinaryString(int i)

2、十进制转八进制: Integer.toOctalString(int i)

3、十进制转十六进制: Integer.toHexString(int i)

(三) 字符串转基本数据类型

1、字符串转整数

（1）Integer.valueOf(String s)

（2）Integer.parseInt(String s)

2、字符串转小数

（1）Double.valueOf(String s)

（2）Double.parseDouble(String s)

3、字符串转其他基本数据类型同理

（四）基本数据类型转字符串

1、整数转字符串：String.valueOf(int i) 或者自动拆箱

2、其他基本数据类型转字符串同理

（五）字符大小写转化

1、大写转小写：Character.toUpperCase(Char c)

2、小写转大写：Character.toLowerCase(Char c)

(六) 数值类型的比较

1、整数的比较：Integer.compare(int x,int y)

注：（1）如果前面的数大于后面的数，返回 1

（2）如果前面的数等于后面的数，返回 0

（3）如果前面的数小于后面的数，返回 -1

2、小数的比较: Double.compare(double x,double y)

3、其他基本数据类型的比较同理

代码展示:

package chapter04;

public class DateType {
    public static void main(String[] args){
        //int类型
        System.out.println("int类型的最大值：" + Integer.MAX_VALUE); // int类型的最大值：2147483647
        System.out.println("int类型的最小值：" + Integer.MIN_VALUE); // int类型的最小值：-2147483648
        //long类型
        System.out.println("long类型的最大值：" + Long.MAX_VALUE); // long类型的最大值：9223372036854775807
        System.out.println("long类型的最小值：" + Long.MIN_VALUE); // long类型的最小值：-9223372036854775808

        //进制之间转换
        System.out.println("---------------------");
        System.out.println("66转二进制为：" + Integer.toBinaryString(66));//转2进制 - 66转二进制为：1000010
        System.out.println("66转八进制为：" + Integer.toOctalString(66));//转8进制 - 66转八进制为：102
        System.out.println("66转十六进制为：" + Integer.toHexString(66));//转16进值 - 66转十六进制为：42

        //把字符串类型转化为基本数据类型
        System.out.println("------------------");
        String s1 = "123";
        int a11 = Integer.valueOf(s1);
        int a22 = Integer.parseInt(s1);
        System.out.println(a11); // 123
        System.out.println(a22); // 123

        String s2 = "456";
        double d1 = Double.valueOf(s2);
        double d2 = Double.parseDouble(s2);
        System.out.println(d1); // 456.0
        System.out.println(d2); // 456.0

        System.out.println("a1+d1=" + (a11 + d1)); //求和 - a1+d1=579.0
        System.out.println("a2+d2=" + (a22 + d2)); // a2+d2=579.0
        System.out.println("s1+s2=" + (s1 + s2));//拼接 - s1+s2=123456


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

        //把基本数据类型转化为字符串类型
        int i = 1;
        System.out.println(String.valueOf(i)); // 1
        System.out.println("-------------------");
        //转大小写
        char letter = 'a';

        //转大写
        char upper = Character.toUpperCase(letter);
        System.out.println(letter + "->" + upper); // a->A
        //转小写
        char lower = Character.toLowerCase(letter);
        System.out.println(letter + "->" + upper + "->" + lower); // a->A->a

        System.out.println("-----------------------");
        //double数据类型的比较
        double x = 2.2;
        double y = 2.3;
        //如果前面的数大于后面的数，返回1
        //如果前面的数等于后面的数，返回0
        //如果前面的数小于后面的数，返回-1

        System.out.println("比较大小：" + Double.compare(x, y)); // 比较大小：-1
    }
}

2. 日期类(第一类时间类)

• 官方文档

• 第一代日期类主要为使用Date,用于获取当前时间,同时提供内置方法让我们自定义(SimpleDateFormat)获取到的时间戳(默认是毫秒),同时提供一些方法来做时间的判断,例如某时间节点是否早于(before)另一个时间节点或者晚于(after)另一个时间节点

package chapter04;
import java.text.SimpleDateFormat; // 引入自定义时间戳的包
import java.util.Date; // 引入时间类

public class Date_oop {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // Date : 日期类
        // 时间戳 ： 毫秒
        System.out.println(System.currentTimeMillis()); // 获取当前时间戳 1688527602417 毫秒

        // Date : 日期类
        // Calendar : 日历类
        Date d = new Date();
        System.out.println(d); // Wed Jul 05 11:26:42 CST 2023 (原始时间)

        // Java格式化日期格式：
        // y (Y) -> 年 -> yyyy
        // m (M) -> MM : 月份，mm:分钟
        // d (D) -> dd : 一个月中的日期，D：一年中的日期
        // h (H) -> h : 12进制， HH：24进制
        // s (S) -> s : 秒，S :毫秒

        // Date -> String (时间类型转字符串类型)
        // 输出格式为 年-月-日 时-分-秒-毫秒 // 2023-07-05 11-26-42-417(成功输出自定义时间)
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss-SS");
        String dateFormatString = sdf.format(d); // 格式化时间
        System.out.println(dateFormatString);

        // String -> Date (字符串类型转回时间类型,切记一定要保持格式完整)
        String dateString = "2022-06-01 12-20-50-60";
        Date parseDate = sdf.parse(dateString); // 解析时间
        System.out.println(parseDate);// 输出回时间的原状态,未自定义状态 - Wed Jun 01 12:20:50 CST 2022

        // 根据时间戳构建指定的日期对象。
        //d.setTime(System.currentTimeMillis()); // 指定时间ms生成时间戳
        // 获取时间戳
        System.out.println(d.getTime()); // 时间对象获取当前时间戳 1688527677604

        System.out.println(parseDate.before(d)); // true 之前时间必定早于当前时间
        System.out.println(parseDate.after(d));// false 当前时间晚于当前时间
    }
}

3. 日历类(第二类时间类)

• 官方文档

• 是一个抽象类，也就是说我们无法通过new来将其实例化创建对象;它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

Calendar.YEAR //表示年份
Calendar.MONTH //表示月份
Calendar.DATE //表示当前时间为多少号（日历式的多少号）
Calendar.HOUR //表示小时（12小时制）
Calendar.HOUR_OF_DAY //表示小时（24小时制）
Calendar.MINUTE //表示分钟数
Calendar.SECOND //表示秒数
Calendar.MILLENSECOND //表示毫秒数
 
Calendar.WEEK_OF_MONTH //当前时间是所在当前月的第几个星期（日历式的第几周）
Calendar.WEEK_OF_YEAR //当前时间是所在当前年的第几个星期
    
//当前时间是所在当前月的第几个星期，以月份天数为标准，一个月的1号为第一周，8号为第二周
Calendar.DAY_OF_WEEK_IN_MONTH 
Calendar.DAY_OF_WEEK //一周七天中，当前时间是一周中的第几天
Calendar.DAY_OF_YEAR //表示一年中的第几天
Calendar.DAY_OF_MONTH //表示一个月中的第几天，结果等同于Calendar.DATE
 
Calendar.AM_PM //表示是上午还是下午
Calendar.SUNDAY //周日
Calendar.MONDAY //周一
Calendar.TUESDAY //周二
Calendar.WEDNSDAY //周三
Calendar.THURSDAY //周四
Calendar.FRIDAY //周五
Calendar.SATURDAY //周六

Calendar(日历类)中的常用方法

1. getInstance()创建Calendar类型的子类对象

/*
	首先需要引入 import java.util.Calendar;
	其次上面提到 Calender 是一个抽象类,因此我们不能通过new来实例化它的对象
*/
Calendar c= Calendar.getInstance();

2. get(int filed)根据日历字段，获取其对应的值

/**
  * Calendar类的方法get()
  * 获取日历字段
  */
 public static void calendarGet(Calendar calendar){
     //Calendar calendar =  Calendar.getInstance();//返回子类对象
    /* int year = calendar.get(Calendar.YEAR);
     System.out.println(year);*/
     System.out.println( calendar.get(Calendar.YEAR)+"年" + (calendar.get(Calendar.MONTH) +1)+"月" +
             calendar.get(Calendar.DAY_OF_MONTH)+"日" + calendar.get(Calendar.HOUR_OF_DAY)+"点" +
             calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒");
 } // 成功输出当前时间

3. set(int year,int month,int day)设置时间为指定的年，月，日;set(int field,int value),field要修改的字段,value`具体的数据

/**
* Calendar类的方法set()
* 设置日历字段
*/
public static void calendarSet(){
    Calendar calendar = Calendar.getInstance() ; //和操作系统时间一样
    //自己设置日历,传递了年月日
    //calendar.set(2021,5,30);
 
    //设置某一个字段
    calendar.set(Calendar.DAY_OF_MONTH,30);
    //调用calendarGet,输出日历
    calendarGet(calendar);
}

// ----------------------------------
Calendar c= Calendar.getInstance();
// 设置年月日
Calendar c=Calendar.getInstance();
c.set(2018, 2, 14);
year=c.get(Calendar.YEAR);
month=c.get(Calendar.MONTH);
date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");
//输出：2018年2月14日

4. add(int field,int value)设置偏移量,field要修改的字段,value具体的数据

/**
     * Calendar类的方法add()
     * 设置日历字段的偏移量
     */
public static void calendarAdd(){
    Calendar calendar = Calendar.getInstance() ; //和操作系统时间一样
    //日历向后,偏移180天
    calendar.add(Calendar.DAY_OF_MONTH,180);
    calendarGet(calendar);
}
// ------------------------------------
Calendar c= Calendar.getInstance();
//10年后的五天前
c.add(Calendar.YEAR, 10);
c.add(Calendar.DATE, -5);
year=c.get(Calendar.YEAR);
month=c.get(Calendar.MONTH)+1;
date=c.get(Calendar.DATE);
System.out.println(year+"年"+month+"月"+date+"日");

4. 本地日期类(第三代日期类)

• 官方文档

• LocalDate类的作用主要用于弥补前两代的不足如下:

1. 可变性：像日期和时间这样的类应该是不可变的
2. 偏移性：Date中的年份是从 1900开始的，而月份都是从0开始
3. 格式化：格式化只对Date有用，Calendar则不行
4. 此外，它们也不是线程安全的，不能处理闰秒问题【每隔2天，多出1s】

• 第三代日期类：有三个LocalDate【年月日】LocalTime【时分秒】 LocalDateTime【年月日时分秒】

package wrapper_.date_;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class LocalDateTime_ {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();//获取日期类对象
        LocalTime time = LocalTime.now();//获取时间类对象
        LocalDateTime dateTime = LocalDateTime.now();//获取日期时间对象

        //年
        int year = dateTime.getYear();
        System.out.println("年="+year);
        //月 获取月份有两种方式：
        // 方式一：
        Month month = dateTime.getMonth();//获取的返回是英文
        System.out.println("月="+month);
        // 方式二：
        int monthValue = dateTime.getMonthValue();
        System.out.println("月="+monthValue);
        // 日
        int dayOfMonth = dateTime.getDayOfMonth();
        System.out.println("日="+dayOfMonth);
        // 时
        int hour = dateTime.getHour();
        System.out.println("时="+hour);
        //分
        int minute = dateTime.getMinute();
        System.out.println("分="+minute);
        //秒
        int second = dateTime.getSecond();
        System.out.println("秒="+second);

        /**
         * 返回值：
         * 年=2022
         * 月=FEBRUARY
         * 月=2
         * 日=13
         * 时=18
         * 分=41
         * 秒=56
         */
    }
}

• Instant时间戳 【构造器是私有化，只能通过Instant.now()方法获取Instant对象】
• 类似于Date提供了一系列和Date转换的方式

Instant  --> Date
Date date = Date.from(instant);
Date ---> Instant
Instant instant = date.toInstant();

// 案例演示：
Instant  now = Instant.now();
System.out.println(now);
Date date = Date.from(now);
Instant instant = date.toInstant();

public static void main(String[] args) {
    //获取时间戳对象
    Instant instant = Instant.now();
    Date date = new Date();
    // Instant 转成 Date
    Date from = Date.from(instant);
    // Date 转成 Instant
    Instant toInstant = date.toInstant();
}

• LocalDateTime类中一些常用方法

MonthDay：检查重复事件

是否是闰年

增加日期的某个部分

使用plus方法测试增加时间的某个部分

使用minus方法测试查看一年前和一年后的日期

package wrapper_.date_;

import javax.swing.text.DateFormatter;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class LocalTimeFormatter02 {
    public static void main(String[] args) {
        // 使用DateTimeFormatter 对象进行日期格式化
        DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        LocalDateTime dateTime = LocalDateTime.now();
        // 增加 168 天后的日期
        LocalDateTime time1 = dateTime.plusDays(168);
        System.out.println("168天后的日期="+ofPattern.format(time1));

        // 减去 168 分钟的时间
        LocalDateTime dateTime1 = dateTime.minusMinutes(168);
        System.out.println("减去 168 分钟的时间"+ofPattern.format( dateTime1));
        /**
         * 返回值：
         * 168天后的日期=2022-07-31 19:34:03
         * 减去 168 分钟的时间2022-02-13 16:46:03
         */

    }
}