Java 基礎-- 10 Object類，包裝類

Object類
java.lang.Object類是Java語言中的根類，即所有類的父類。Object中所有方法子類都可以使用。在對象實例化的時候，最終找的父類就是Object。
如果一個類沒有特別指定父類，那麼默認則繼承自Object類。例如：

public class MyClass /*extends Object*/ {
  	// ...
}

根據JDK源代碼及Object類的API文檔，Object類當中包含的方法有11個。今天我們主要學習其中的2個：

public String toString()：返回該對象的字符串表示。
public boolean equals(Object obj)：指示其他某個對象是否與此對象“相等”。

toString方法
toString方法返回該對象的字符串表示，其實該字符串內容就是對象的類型+@+內存地址值。而在開發中，經常需要按照對象的屬性得到相應的字符串表現形式，因此也需要重寫它。

public String toString()

參數：無參
返回值：返回該對象的字符串表示。
equals方法
public boolean equals(Object obj)：指示其他某個對象是否與此對象“相等”。
返回值：true 表示兩個對象比較內容相同,false 表示兩個對象比較內容不相同
參數：obj將與調用該方法的對象進行比較

調用成員方法equals並指定參數爲另一個對象，則可以判斷這兩個對象是否是相同的。這裏的“相同”有默認和自定義兩種方式。
equals方法能夠進行對象的內容比較，判斷內容是否相同。自定義類使用時，一般都進行重寫該方法。

我們重寫可以自己手動完成，也可以使用IDEA自動生成。
Objects工具類
在比較兩個對象的時候，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));  
}

在進行兩個對象進行比較內容時，我們可以藉助Objects工具類的equals方法。

日期時間類
java.util.Date類表示特定的瞬間，精確到毫秒。
1年12月 1天24小時， 1小時60分，1分60秒，1秒1000毫秒
日期類Date

Date擁有多個構造函數，有些已經過時，但是其中有未過時的構造函數可以把毫秒值轉成日期對象。

1. public Date()：生成一個當前系統時間的毫秒時刻的Date對象
2. public Date(long date)：指定毫秒值生成Date對象
   參數long date表示自從標準基準時間（稱爲“曆元（epoch）”，即1970年1月1日00:00:00 GMT）以來的指定毫秒數。

tips: 由於我們處於東八區，所以我們的基準時間爲1970年1月1日8時0分0秒。

例如：

import java.util.Date;
public class Demo01Date {
    public static void main(String[] args) {
        // 創建日期對象，把當前的時間
        System.out.println(new Date()); // 當前系統時間
        // 創建日期對象，把當前的毫秒值轉成日期對象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

tips:在使用println方法時，會自動調用Date類中的toString方法。Date類對Object類中的toString方法進行了覆蓋重寫，所以結果爲指定格式的字符串。

Date類中的多數方法已經過時，常用的方法有：

public long getTime() 把日期對象轉換成對應的時間毫秒值。

public class Deom02Date{
	public static void main(String[] args){
		Date d2 = new Date(0);
		System.out.println(d2);//Thu Jan 01 08:00:00 CST 1970
    long t2 = d2.getTime();
    System.out.println("t2 = " + t2);//t2=0
  }
}

日期類Date表示時間的瞬間，精確到毫秒，通過空參構造方法可以構建當前系統時間的日期對象。
DateFormat類
java.text.DateFormat 是日期/時間格式化子類的抽象類，我們通過這個類可以幫我們完成日期和文本之間的轉換,也就是可以在Date對象與String對象之間進行來回轉換。

格式化：按照指定的格式，從Date對象轉換爲String對象。
解析：按照指定的格式，從String對象轉換爲Date對象。

由於DateFormat爲抽象類，不能直接使用，所以需要使用其子類java.text.SimpleDateFormat來創建對象。這個類需要一個模式（格式）來指定格式化或解析的標準。構造方法爲：

public SimpleDateFormat(String pattern):使用給定的格式進行創建格式化對象。

參數：String pattern代表日期時間的自定義格式。
pattern常用的格式規則爲：
y:年
M：月
d：日
h時
m：分
s：秒
S：毫秒
創建SimpleDateFormat對象的代碼如下：

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class Demo02SimpleDateFormat {
    public static void main(String[] args) {
        // 對應的日期格式如：2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

DateFormat類的常用方法有：

public String format(Date date)：將日期Date對象格式化爲字符串。
public Date parse(String source)：將字符串解析爲日期Date對象。

使用format方法的代碼爲：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date對象轉換成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 創建日期格式化對象,在獲取格式化對象時可以指
       定風格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2020年03月01日
    }
}

parse方法

使用parse方法的代碼爲：

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

public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2020年3月1日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2020
    }
}

藉助DateFormat的子類SimpleDateFormat類,能夠實現日期和字符串之間可以相互轉化了。
創建格式化對象的時候，需要指定格式。能夠屬性常見的字母格式，比如y代表年等
要實現日期轉字符串：format
要實現字符串轉日期：parse

案例：請使用日期時間相關的API，計算出一個人已經出生了多少天。
分析：要解決這個很簡單，我只需要知道當前時間和出生時間的差值就可以了。

步驟

獲取當前時間對應的毫秒值
獲取自己出生日期對應的毫秒值：藉助DateFormat類
兩個時間相減（當前時間– 出生日期）

代碼實現：

 public static void main(String[] args) throws Exception {
        // 1. 獲取當前日期
        Date todayDate = new Date();

        //2. 獲取出生日期
        // 字符串輸入獲取出生日期，藉助SimpleDateFormat類解析爲日期
        System.out.println("請輸入出生日期 格式 YYYY-MM-dd");
        // 鍵盤輸入獲取出生日期字符串
        String birthdayString = new Scanner(System.in).next();
        //解析生日日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthdayString);//字符串轉成日期對象

        //3. 求時間差（當前時間– 出生日期）
        // 獲取兩個日期的毫秒值進行相減（當前日期毫秒值 – 出生日期毫秒值）
        long todaySecond = todayDate.getTime();//當前時間毫秒值
        long birthdaySecond = birthdayDate.getTime();//生日毫秒值
        long secone = todaySecond - birthdaySecond;//求差值
        if (secone < 0) {
            System.out.println("還沒出生呢");
        } else {
            System.out.println(secone / 1000 / 60 / 60 / 24);//毫秒轉化爲天
        }
    }

日曆類Calendar
Calendar爲抽象類，由於各個國家語言，時區不同，自定義Calendar子類是非常複雜的，因此Calendar類在創建對象時並非直接創建，而是通過靜態方法直接獲取，如下：

Calendar靜態方法

public static Calendar getInstance()：使用默認時區和語言環境獲得一個日曆
例如：

import java.util.Calendar;
public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }    
}

常用方法：
根據Calendar類的API文檔，常用方法有：

public int get(int field)：返回給定日曆字段的值。
public void set(int field, int value)：將給定的日曆字段設置爲給定值。
public abstract void add(int field, int amount)：根據日曆的規則，爲給定的日曆字段添加或減去指定的時間量。
public Date getTime()：返回一個表示此Calendar時間值（從曆元到現在的毫秒偏移量）的Date對象。

Calendar類中提供很多成員常量，代表給定的日曆字段：
YEAR年

MONTH月（從0開始，可以+1使用）

DAY_OF_MONTH月中的天（幾號）

HOUR時（12小時制）

HOUR_OF_DAY時（24小時制）

MINUTE分

SECOND秒

DAY_OF_WEEK週中的天（周幾，週日爲1，
可以-1使用）

System類：
java.lang.System類中提供了大量的靜態方法，可以獲取與系統相關的信息或系統級操作
currentTimeMillis獲取時間毫秒值
System類中靜態方法獲取當前時間毫秒值：public static long currentTimeMillis()

實際上，currentTimeMillis方法就是獲取當前系統時間與1970年01月01日00:00點之間的毫秒差值

import java.util.Date;
public class SystemDemo {
    public static void main(String[] args) {
       	//獲取當前時間毫秒值
        System.out.println(System.currentTimeMillis()); 
    }
}

我們可以藉助以上學習的方法來計算程序的執行時間，如驗證for循環打印數字1-9999所需要使用的時間（毫秒），如下：

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗時毫秒：" + (end - start));
    }
}

arraycopy方法數組拷貝
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：將數組中指定的數據拷貝到另一個數組中。

數組的拷貝動作是系統級的，性能很高。System.arraycopy方法具有5個參數，含義分別爲：

練習鞏固

將src數組中前3個元素，複製到dest數組的前3個位置上，

複製元素前：src數組元素{1,2,3,4,5}，dest數組元素{6,7,8,9,10}

複製元素後：src數組元素{1,2,3,4,5}，dest數組元素{1,2,3,9,10}

import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
      //複製元素前：src數組元素{1,2,3,4,5}，dest數組元素{6,7,8,9,10}
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);//元素拷貝
      //複製元素後：src數組元素{1,2,3,4,5}，dest數組元素{1,2,3,9,10}
  
    }
}

StringBuilder類：
由於String類的對象內容不可改變，所以每當進行字符串拼接時，總是會在內存中創建一個新的對象。例如：

public class Demo01String {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中對String類有這樣的描述：字符串是常量，它們的值在創建後不能被更改。

根據這句話分析我們的代碼，其實總共產生了三個字符串，即"Hello"、“World"和"HelloWorld”。引用變量s首先指向Hello對象，最終指向拼接出來的新字符串對象，即HelloWord 。

由此可知，如果對字符串進行拼接操作，每次拼接，都會構建一個新的String對象，既耗時，又浪費空間。爲了解決這一問題，可以使用java.lang.StringBuilder類。

StringBuilder是可變字符序列，它是一個類似於 String 的字符串緩衝區（容器），通過某些方法調用可以改變該字符序列的長度和內容。

根據StringBuilder的API文檔，常用構造方法有2個：

public StringBuilder()：構造一個空的StringBuilder容器。
public StringBuilder(String str)：構造一個StringBuilder容器，並將字符串添加進去。

public class Demo02StringBuilder {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用帶參構造
        StringBuilder sb2 = new StringBuilder("itcast");
        System.out.println(sb2); // itcast
    }
}

StringBuilder常用的方法有2個：

public StringBuilder append(…)：添加任意類型數據的字符串形式，並返回當前對象自身。
public String toString()：將當前StringBuilder對象轉換爲String對象。
** append方法：**
public StringBuilder append(…):
參數：多種重載形式，可以接收任意類型的參數
返回值：還是本StringBuilder對象

該方法調用後返回值爲自身，可以直接在調用方後繼續調用拼接其他數據，這種寫法稱位鏈式編寫。

任何數據作爲參數都會將對應的字符串內容添加到StringBuilder中。例如

public class Demo03StringBuilder {
	public static void main(String[] args) {
		//創建對象
		StringBuilder builder = new StringBuilder();
		//public StringBuilder append(任意類型)
		StringBuilder builder2 = builder.append("hello");
		//對比一下
		System.out.println("builder:"+builder);
		System.out.println("builder2:"+builder2);
		System.out.println(builder == builder2); //true
	    // 可以添加 任何類型
		builder.append("hello");
		builder.append("world");
		builder.append(true);
		builder.append(100);
		// 在我們開發中，會遇到調用一個方法後，返回一
		個對象的情況。然後使用返回的對象繼續調用方法。
    // 這種時候，我們就可以把代碼現在一起，如append
    方法一樣，代碼如下
		//鏈式編程
		builder.append("hello").append("world").append(true).append(100);
		System.out.println("builder:"+builder);
	}
}

備註：StringBuilder已經覆蓋重寫了Object當中的toString方法。
** toString方法**
通過toString方法，StringBuilder對象將會轉換爲不可變的String對象。如：

public class Demo16StringBuilder {
    public static void main(String[] args) {
        // 鏈式創建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 調用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

String和StringBuilder是可以相互轉化的

StringBuilder和String的相互轉化：
    StringBuilder轉String:  toString
    String轉StringBuilder： 直接使用構造方法就可以將
    String數據轉爲StringBuilder

包裝類
Java提供了兩個類型系統，基本類型與引用類型，使用基本類型在於效率，然而很多情況，會創建對象使用，因爲對象可以做更多的功能，如果想要我們的基本類型像對象一樣操作，就可以使用基本類型對應的包裝類，如下：
基本類型數據與對應的包裝類型對象之間，來回轉換的過程稱爲”裝箱“與”拆箱“

裝箱：從基本類型轉換爲對應的包裝類對象。

拆箱：從包裝類對象轉換爲對應的基本類型。

比如，用Integer對象與 int基本數據之間的轉化：

裝箱：基本數值---->包裝對象

Integer i = new Integer(4);//使用構造函數函數
Integer iii = Integer.valueOf(4);//使用包裝類中的valueOf方法

拆箱：包裝對象---->基本數值

int num = i.intValue();

自動裝箱與自動拆箱：
由於我們經常要做基本類型與包裝類之間的轉換，從Java 5（JDK 1.5）開始，基本類型與包裝類的裝箱、拆箱動作可以自動完成。例如：

Integer i = 4;//自動裝箱。相當於Integer i = 
Integer.valueOf(4);
i = i + 5;//等號右邊：將i對象轉成基本數值(自動拆箱) 
i.intValue() + 5;
//加法運算完成後，再次裝箱，把基本數值轉成對象。

基本類型與字符串之間的轉換
基本類型轉換爲String

基本類型轉換String總共有三種方式，常見的三種方式：

基本類型直接與空字符串用加號連接相連接即可,如：34+""
轉換爲包裝類型對象，調用toString方法
包裝類型的靜態方法toString

int i1 = 100;
//第一種方式
String str1 = i1 + "";
//第二種方式
Integer i2 = Integer.valueOf(i1);
String str2 = i2.toString();
//第三種方式
String str3 = Integer.toString(i1);

String轉換成基本類型
除了Character類之外，其他所有包裝類都具有parseXxx靜態方法可以將字符串參數轉換爲對應的基本類型：

public static byte parseByte(String s)：將字符串參數轉換爲對應的byte基本類型。
public static short parseShort(String s)：將字符串參數轉換爲對應的short基本類型。
public static int parseInt(String s)：將字符串參數轉換爲對應的int基本類型。
public static long parseLong(String s)：將字符串參數轉換爲對應的long基本類型。
public static float parseFloat(String s)：將字符串參數轉換爲對應的float基本類型。
public static double parseDouble(String s)：將字符串參數轉換爲對應的double基本類型。
public static boolean parseBoolean(String s)：將字符串參數轉換爲對應的boolean基本類型。

代碼使用（僅以Integer類的靜態方法parseXxx爲例）如：

public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");
    }
}

注意:如果字符串參數的內容無法正確轉換爲對應的基本類型，則會拋出java.lang.NumberFormatException異常。

Java 基礎-- 10 Object類，包裝類

DAPPER 事務 TRANSACTION

Java基礎 -- 11 Collection、泛型

IBM X3650M4硬盤故障處理，硬盤指示燈沒有亮起

Java基礎 --08 接口、多態

Java基礎--02 流程控制語句、方法

Java基礎 --06 String類、static關鍵字、Arrays類、Math類

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結