java基礎之常用類1

 java基礎


 以下內容為本人的學習筆記,如需要轉載,請聲明原文鏈接  


 

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

 

 

 

 

 

 

 

 

 

 

Tags: