java程式設計–孫鑫java無難事Lesson5《java常用包、資料類型與參考型別、函數參數傳遞、複製機制》

java程式設計--孫鑫java無難事Lesson5《java常用包、資料類型與參考型別、函數參數傳遞、複製機制》

本節要點:

1.Java的常用包

2.“==”和“equals”的用法

3.基礎資料型別 (Elementary Data Type)與參考型別

4.String和StringBuffer

5.對象的複製（clone）

詳細內容:
1.Java的常用包
java.applet：包含一些用於建立Java小應用程式的類。
java.awt：包含一些用於編寫與平台無關的圖形介面(GUI)應用程式的類。
java.io：包含一些用作輸入輸出(I/O)處理的類。
java.lang：包含一些Java語言的基本類與核心類，如String、Math、Integer、System和Runtime，提供常用的功能，這個包中的所有類是被隱式匯入的。

java.net：包含用於建立網路連接的類，與java.io同時使用完成與網路有關的讀寫。

java.util：包含一些工具 + 生產力類和資料結構類。

2.“==”和“equals”的用法--變數與對象值相等的判定方法
(1)參考型別
在Java中，boolean、byte、short、int、long、char、float、double這八種是基礎資料型別 (Elementary Data Type)，其餘的都是參考型別。
(2)變數與對象值相等的判定
“==”是比較兩個變數的值是否相等，“equals”是比較兩個物件變數所代表的對象的內容是否相等。
測試代碼:
//變數和對象值相等的判定
String str1=new String("abc");
String str2=new String("abc");
String str3=new String("abc");
if(str1==str2)
  System.out.println("str1==str2");
else
      System.out.println("str1!=str2");//str1!=str2  ==比較兩個變數的值
 if(str1==str3)
       System.out.println("str1==str3");
   else
       System.out.println("str1!=str3");//str1!=str3  ==比較兩個變數的值
    if(str1.equals(str2))
        System.out.println("str1==str2");//str1==str2  equals比較兩個變數所引用的對象是否相等
     else
           System.out.println("str1!=str2");
3.基礎資料型別 (Elementary Data Type)與參考型別--記憶體模型簡析

(1)基礎資料型別 (Elementary Data Type)的記憶體配置

記憶體配置過程:

a.聲明引用變數，分配棧記憶體，引用變數值為null
b.new操作符在堆記憶體中分配空間返回堆記憶體位址

c.將堆記憶體位址賦給引用變數

基礎資料型別 (Elementary Data Type)記憶體配置如:

語句num=null;切斷與原數組關聯如:

(2)對象的記憶體配置

分配過程見:

(3)函數調用時的記憶體模型

在Java中，傳參時，都是以傳值的方式進行。
對於基礎資料型別 (Elementary Data Type)，傳遞的是資料的拷貝；對於參考型別，傳遞的引用的拷貝。

a.基礎資料型別 (Elementary Data Type)資料交換

基礎資料型別 (Elementary Data Type)的資料交換並不會實際交換兩個資料，因為參數傳遞時，將會在函數中拷貝一分原資料的副本，而不是操作原資料。

//測試代碼及記憶體模型如下圖所示:

b.參考型別的資料交換

參考型別的資料交換將真正實現兩個資料的交換，因為實際上是對同一對象的操作。

//測試代碼及記憶體模型如下圖所示：

4.String和StringBuffer的特性和使用
(1)String的"+"和"+=",是java中唯一被重載的操作符;在java中不允許程式員重載操作符。
字串可以和任意類型變數相加.
(2)String是一個常量,可以理解為將一個堆中對象的地址賦給這個String對象來引用，因此String類的值將保留對象的地址引用而不能改變。為什麼使用這種機制?
這種機制能夠避免像語句:
String str1=new String("abc");//分配堆記憶體並將地址賦給引用變數str1
str1="bcd";//重新分配堆記憶體
這樣將會造成記憶體浪費，因此java避免更改String中的內容，要更改其內容，可以換用StringBuffer類。在大量處理字串的程式中使用StringBuffer類。
(3)插入、刪除等其他動作  可以參見api協助文檔
//String類測試代碼
//字串使用
String str1=new String("abc");
int i=3;
float f=1.5f;
char ch='f';
boolean b=false;
//System.out.println(str1+i+f+ch+b);//ok  String類允許任意類型相加  abc31.5ffalse
StringBuffer  sb=new StringBuffer();
sb.append(str1).append(i).append(f).append(ch).append(b);
//System.out.println(sb.toString());//ok
sb.delete(4,8);//4-7error  計算索引時 包含前一個索引 但不包含後一個(結束索引)索引
sb.insert(4,"InsertTest");//插入字串
 System.out.println(sb);//ok  自動調用toString
5.複製(clone)機制--解決參考型別的資料保護
(1)複製機製作用
在函數中傳遞參數時，傳遞參考型別的參數時可能導致原資料的更改，為了避免原資料的更改，採用複製(clone)機制。複製機制拷貝原對象的一份資料，而不對原資料直接進行操作。
(2)實現複製機制
複製機制的實現需要在衍生類別中實現Cloneable介面、覆蓋基類的clone()方法，並聲明為public並且衍生類別的clone()方法中調用super.clone()。
為什麼要調用super.clone()?
在運行時刻，Object中的clone()識別出你要複製的是哪一個對象，然後為此對象分配空間，並進行對象的複製，將原始對象的內容一一複製到新對象的儲存空間中。
//測試代碼
class Student  implements Cloneable
{
    int age;
    String name;
    Student(String name,int age )
    {
        this.name=name;
        this.age=age;
    }
    //淺層次的拷貝
    public Object clone()
    {   
        Object o =null;
        try
        {
            o=super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        return  o;
    }
}
//main函數中
//對象複製  
Student stu1=new Student("zhangsan",18);
Student stu2=(Student)stu1.clone();//複製後不影響原對象的資料
stu2.name="LiSi";
stu2.age=20;//不會修改stu1的資料
System.out.println("stu1.name="+stu1.name+" stu1.age="+stu1.age);
//運行結果
stu1.name=zhangsan stu1.age=18
(3)複製機制引發的問題---深層次複製
//測試代碼
class professor
{
    int age;
    String name;
    professor(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
}
class Student  implements Cloneable
{
    int age;
    String name;
    professor p;//參考型別
    Student(String name,int age,professor p)
    {
            this.name=name;
        this.age=age;
        this.p=p;
    }
    //淺層次的拷貝
    public Object clone()
    {   
        Object o =null;
        try
        {
            o=super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        return  o;
    }
}
//main函數中
professor p=new professor("WangWu",50);
Student stu1=new Student("zhangsan",18,p);
Student stu2=(Student)stu1.clone();
stu2.p.name="Zhaoer";
stu2.p.age=44;//會修改stu1.p的資料  
System.out.println("stu1.p.name="+stu1.p.name+" stu1.p.age="+stu1.p.age);
//運行結果
stu1.p.name=Zhaoer stu1.p.age=44
說明複製的時候仍然修改了原對象stu1的資料,解決方案:讓professor實現Cloneable介面和clone方法
//更改後的測試代碼
class professor implements Cloneable
{
    int age;
    String name;
    professor(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    //支援複製
    public Object clone()
    {   
        Object o =null;
        try
        {
            o=super.clone();//必須調用 複製的不是基類對象而是運行時識別複製的對象
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        return  o;
    }
    
}
class Student  implements Cloneable
{
    int age;
    String name;
    professor p;//參考型別
    Student(String name,int age,professor p)
    {
        this.name=name;
        this.age=age;
        this.p=p;
    }
    //深層次的拷貝
    public Object clone()
    {   
        Student s =null;
        try
        {
            s=(Student)super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        s.p=(professor)s.p.clone();//複製參考型別的成員變數
        return  s;
    }
    
}
//main函數中
professor p=new professor("WangWu",50);
Student stu1=new Student("zhangsan",18,p);
Student stu2=(Student)stu1.clone();
stu2.p.name="Zhaoer";
stu2.p.age=44;//不會修改stu1.p的資料  
System.out.println("stu1.p.name="+stu1.p.name+" stu1.p.age="+stu1.p.age);
//運行結果
stu1.p.name=WangWu stu1.p.age=50
這說明沒有修改stu1的資料。
6.main函數中的命令列參數
//擷取命令列參數
for(int i=0;i<args.length;i++)
   System.out.println(args[i]);