java基礎之常用類1

 java基礎

 以下內容為本人的學習筆記，如需要轉載，請聲明原文鏈接  https://www.cnblogs.com/lyh1024/p/16732224.html

java常用類：

1.內部類

2.Object類

3.Object類常用方法

4.包裝類

5.String類

6.BigDecimal類

1、內部類

• 分類：

  內部類：成員內部類，靜態內部類， 局部內部類，匿名內部類

• 概念：在一個類的內部再定義一個完整的類（類中類）

• 特點：

1. 編譯之後可生成獨立的位元組碼文件；

2. 內部類可直接訪問外部類的私有成員，而不破壞封裝

3. 可為外部類提供必要的內部功能組件

public class Body{
    private String name;
    //內部類
    class Header{
        public void show(){
            //訪問外部類私有成員
        System.out.println(name)
        }
    }
}

1.1成員內部類

• 在類的內部定義，與實例變數、示例方法同級別的類；

• 外部類的一個實例部分，創建內部類對象時，必須先創建外部類對象：

　　　　Outer out = new Outer();

　　　　out.Inner in = out.new Inner();　　　　　//創建內部類對象時，要加外部類首碼

• 當外部類、內部類存在重名屬性時，會優先訪問內部類屬性；

• 成員內部類不能定義靜態成員，但是能定義靜態常量。

示例：

public class Outer{
    private String name="張三";
    private int age = 20;
    
    //內部類 
    class Inner{
        private String address = "北京";
        private String phone="110";
        private String name = "李四";
        
        //方法
        public void show(){
            //列印外部類的屬性，內部類屬性和外部類的屬性名字相同(重名時)：Outer.this
            System.out.println(Outer.this.name);
            System.out.println(age);
            
            //列印內部類中的屬性
            System.out.println(this.address);
            System.out.println(phone);
        }
    
    }
}
​
public class TestOuter{
    public static void main(String [] agrs){
        //1創建外部類對象
  //      Outer outer = new Outer();
        //2創建內部類對象，要加外部類對象首碼
  //      outer.Inner inner = outer.new Inner()
            
          //1,2合併為一句
        Inner inner = new Outer().new Inner();
        inner.show();
    }
}

1.2靜態內部類

(靜態內部類，在內部類基礎上加static,級別相當於外部類，給外部類使用)

• 不依賴（先創建）外部類對象，可直接創建或通過類名訪問，可聲明靜態成員

• 只能直接訪問外部類的靜態成員（實例成員需實例化外部類對象）

　　　　Outer.Inner inner = new Outer.Inner();

　　　　Outer.Inner.show();

示例：

public class Outer {
​
    private String name ="小米";
    private int age = 19;
​
    //靜態內部類
    static class Inner{
        private String name = "計緣";
        private int age =11;
        static private String address = "廣東";
        public void show(){
            //1.調用外部類的屬性，先創建外部類對象，因為靜態內部類與外部類屬於同一級別
            Outer outer = new Outer();
            //2.調用外部類的屬性
            System.out.println(outer.name);
            //3.調用靜態內部類的屬性
            System.out.println(name);
            //4.調用靜態內部類的靜態屬性，類名.屬性名
            System.out.println(Inner.address);
        }
​
​
    }
}
//測試
public class TestOuter {
    public static void main(String[] args) {
        //直接創建靜態內部類對象
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}
​

1.3局部內部類

1. 定義在外部類方法中，作用範圍和創建對象僅限於當前方法；

   • 局部內部類首碼不能加任何訪問修飾符（如，public，protect...),作用範圍在方法里

   • 局部內部類和局部變數屬於同一級別

   • 靜態方法不能訪問非靜態的成員，因為靜態屬性是類的屬性，不是單個成員的屬性

   • 局部內部類不能定義靜態變數，但可以定義靜態常量

2. 局部內部類訪問外部類當前方法中的局部變數時，因無法保障變數的生命周期與自身相同，變數必須修飾為final；

3. 限制類的使用範圍。

　　  局部內部類訪問局部變數：

• • 　　訪問局部變數,JDK1.7要求變數是常量final，JDK1.8會自動為局部變數添加final；

  • 　　因為局部變數在方法完成後會消失，但是局部內部類不會消失，可是局部內部類會使用到一個將要消失的局部變數？所以要讓局部變數為常量。

public class Outer {
​
    private String name = "計緣";
    private int age = 42;
​
    public void show(){
        String address = "廣東";
        class Inner{
            private String name = "尹兆先";
            private int age = 43;
​
            public void show2(){
                //訪問外部類的屬性，Outer.this可省略
                System.out.println(Outer.this.name);
                System.out.println(age);
​
                //訪問內部類的屬性
                System.out.println(name);
                //訪問局部變數,JDK1.7要求變數是常量final，JDK1.8會自動為局部變數添加final
                System.out.println(address);
            }
        }
        //不能在main方法里創建局部內部類對象，
        // 在main方法里調用外部類的show方法是不能調用局部內部類的，因為
        // 上面只做了聲明，沒有調用。
        // 要調用局部內部類的方法要在上一級方法（跟局部內部類同一級上）創建局部內部類對象並調用方法
        Inner inner = new Inner();
        inner.show2();
    }
}
​
​
//測試
public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
​

1.4匿名內部類

1. 沒有類名的局部內部類（一切特征都與局部內部類相同）；

2. 必須繼承一個父類或者實現一個介面；

3. 定義類、實現類、創建對象的語法合併，只能創建一個該類的對象；

• 優點：減少代碼量；

• 缺點：可讀性較差。

示例：

public interface Usb {
    public void service();
}
​
​
public class Mouse implements Usb{
​
    public void service(){
        System.out.println("滑鼠正在工作中...");
    }
}
​
​
public class TestUsb {
    public static void main(String[] args) {
        //創建介面類型的變數,多態
//        Usb usb = new Mouse();
//        usb.service();
​
        //局部內部類，main方法也是方法里
//        class Fan implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("連接電腦成功，風扇開始工作...");
//            }
//        }
//
//        //使用局部內部類創建對象
//         Usb usb = new Fan();
//          usb.service();
//
​
        //使用匿名內部類優化(相當於創建了一個局部內部類)
        Usb usb = new Usb(){//第二個Usb位置可以是介面，抽象類，父類，在方法體里可以重寫方法
            public void service() {
                System.out.println("連接電腦成功，風扇開始工作...");
            }
        };
        usb.service();
    }
}
​

2、Object類

1. 超類、基類，所有類的直接或間接父類，位於繼承樹的最頂層；

2. 任何類，如沒有書寫extends顯示繼承某個類，都預設直接繼承Object類，否則為間接繼承；

3. Object類中所調用的方法，是所有對象都基本的方法；

4. Object類型可以存儲任何對

• 作為參數，可接受任何對象。

• 作為返回值，可返回任何對象。

3、Object類常用方法

3.1getClass()方法

• 　　public final Class<?> getClass(){}
• 　　返回引用中存儲的實際對象類型；
• 　　應用：通常用於判斷兩個引用中實際存儲對象類型是否一致。

示例：

public class Student {
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    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;
    }
}
​
​
​
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
​
        //判斷s1和s2是不是同一個類型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2屬於同一個類型");
        }else{
            System.out.println("s1和s2不屬於同一個類型");
        }
​
    }
}
​

3.2hashCode()方法

• 　public int hashCode(){}
• 　返回該對象的哈希碼值；
• 　哈希值根據對象的地址或字元串或數字使用hash演算法（系統底層提供）計算出來的int類型的數值；
• 　一般情況下相同對象返回相同哈希碼。

示例：

   Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());      //s1.hashCode()!=s2.hashCode()
        Student s3 = s1;
        System.out.println(s3.hashCode());      //s1.hashCode()=s3.hashCode()
 

3.3 toString()方法

• public String toStrin(){};
• 返回該對象的字元串表示；
• 可以根據程式需求覆蓋該方法，如：展示對象各個屬性的值。

 System.out.println(s1.toString());
     System.out.println(s2.toString());//預設名字+返回哈希值的十六進位

重寫toString：

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

3.4equals()方法

• public boolean equals （Object obj）{}
• 預設(源碼)實現為（this == obj）[比較兩個對象是否相同]，比較兩個對象地址是否相同；
• 可進行覆蓋（重寫後），比較兩個對象的內容是否相同
• equals是Object類的方法，預設為比較地址，跟'=='一樣，String類中重寫equals方法，比較的是值。

  //判斷兩個對象是否相等
        System.out.println(s1.equals(s2));//false
        Student s6 = new Student("小米", 12);
        Student s7 = new Student("小米", 12);
        System.out.println(s6.equals(s7));//false

equals()方法覆蓋（重寫）步驟

1. 比較兩個引用是否指向同一個對象；

2. 判斷obj是否為null；

3. 判斷兩個引用指向的實際對象類型是否一致；

4. 強制類型轉換；

5. 依次比較各個屬性值是否相同。

//Student類里  
public boolean equals(Object obj) {
        //1.判斷兩個對象是否是同一個引用
        if (this == obj) {
            return true;
        }
        //2.判斷obj是否null
        if (obj == null) {
            return false;
        }
        //3.判斷是否是同一個類型
//        if (this.getClass() == obj.getClass()) {
//
//        }
        //instanceof 判斷對象是否是某種類型
        if (obj instanceof Student) {
            //4.強制類型轉換
            Student s = (Student) obj;
            //5.比較熟悉
            if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                return true;
            }
        }
        return false;
    }

tips： instanceof比較的是前面的實際類型是不是後面對象實際類型的子類或同類，是的話返回true，否則返回false；作比較時，在true的情況下還要強制轉換為同類

3.5finalize（）方法

　　　finalize：譯：最終確定，把(計劃、旅行、項目等)最後定下來;定案

1. 當對象被判定為垃圾對象時，有JVM自動調用此方法，用以標記垃圾對象，進入回收隊列；

2. 垃圾對象：沒有 有效引用（沒有被賦予變數等） 指向此對象時，為垃圾對象；

3. 垃圾回收：由GC銷毀垃圾對象，釋放數據存儲空間；

4. 自動回收機制：JVM的記憶體耗盡，一次性回收所有垃圾對象；

5. 手動回收機制：使用System.gc()；通知JVM執行垃圾回收。（說是手動，其實還是JVM自動回收，只不過是被人為的告訴JVM一聲）。

//Student類里
         protected void finalize() throws Throwable{
        System.out.println(this.name+"對象被回收了...");
    }
    
//TestStudent類里
        new Student("aaa",32);
        new Student("bbb",32);
        new Student("ccc",32);
        new Student("ddd",32);
        new Student("eee",32);
        System.gc();
        System.out.println("回收垃圾");
 
 

 2022-09-26  20:06:06