java基礎之常用類1-有解無憂

java基礎

以下內容為本人的學習筆記，如需要轉載，請宣告原文鏈接

java常用類：

1.內部類

2.Object類

3.Object類常用方法

4.包裝類

5.String類

6.BigDecimal類

1、內部類

分類：

內部類：成員內部類，靜態內部類，區域內部類，匿名內部類
概念：在一個類的內部再定義一個完整的類（類中類）
特點：

編譯之后可生成獨立的位元組碼檔案；
內部類可直接訪問外部類的私有成員，而不破壞封裝
可為外部類提供必要的內部功能組件

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區域內部類

定義在外部類方法中，作用范圍和創建物件僅限于當前方法；
- 區域內部類前綴不能加任何訪問修飾符（如，public，protect...),作用范圍在方法里
- 區域內部類和區域變數屬于同一級別
- 靜態方法不能訪問非靜態的成員，因為靜態屬性是類的屬性，不是單個成員的屬性
- 區域內部類不能定義靜態變數，但可以定義靜態常量
區域內部類訪問外部類當前方法中的區域變數時，因無法保障變數的生命周期與自身相同，變數必須修飾為final；
限制類的使用范圍，

　　 區域內部類訪問區域變數：

- 　　訪問區域變數,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匿名內部類

沒有類名的區域內部類（一切特征都與區域內部類相同）；
必須繼承一個父類或者實作一個介面；
定義類、實作類、創建物件的語法合并，只能創建一個該類的物件；

優點：減少代碼量；
缺點：可讀性較差，

示例：

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類

超類、基類，所有類的直接或間接父類，位于繼承樹的最頂層；
任何類，如沒有書寫extends顯示繼承某個類，都默認直接繼承Object類，否則為間接繼承；
Object類中所呼叫的方法，是所有物件都基本的方法；
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()方法覆寫（重寫）步驟

比較兩個參考是否指向同一個物件；
判斷obj是否為null；
判斷兩個參考指向的實際物件型別是否一致；
強制型別轉換；
依次比較各個屬性值是否相同，

//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：譯：最終確定，把(計劃、旅行、專案等)最后定下來;定案

當物件被判定為垃圾物件時，有JVM自動呼叫此方法，用以標記垃圾物件，進入回收佇列；
垃圾物件：沒有有效參考（沒有被賦予變數等）指向此物件時，為垃圾物件；
垃圾回收：由GC銷毀垃圾物件，釋放資料存盤空間；
自動回識訓制：JVM的記憶體耗盡，一次性回收所有垃圾物件；
手動回識訓制：使用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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/509574.html

標籤：其他

上一篇：python中組合資料的操作

下一篇：day42-反射01