技術標籤：# JAVASE

• 本質: 以類的方式組織程式碼，以物件的方式組織（封裝）資料

• 三大特性: 封裝、繼承、多型

  1.使用new關鍵字建立的時候，除了分配記憶體空間之外，
  還會給建立好的物件進行預設的初始化以及對類中構造器的呼叫
  2. 類中的構造器，在進行建立物件時必須呼叫:
  …特點: 必須和類的名字相同 || 必須沒有返回型別，也不寫void

• 方法呼叫

  1.static修飾的方法是在類載入之後就已經存在了
  2.普通方法是例項化後才存在
  3.普通方法在一個類中可以互相呼叫

• 繼承

  1.快捷鍵CTRL+H檢視繼承關係
  2.子類可以繼承父類的全部public修飾的屬性和方法
  

  3.所有的類都繼承Object類 子類構造器呼叫this()(在有參構造器中，並且必須是在第一行，所以不能和super(同時出現在同一個構造器中))
  4.子類的構造器的第一行隱藏了super();必須放在第一行
  5.super必須出現在子類的方法或者構造方法中
  6.super可以直接呼叫在父類中被protected和public修飾的屬性和方法

• 重寫

  1.重寫在繼承間發生在方法上，必須是public的非靜態的
  2.如果是父子類之間的靜態方法相同，呼叫時只是呼叫各自的方法
  3.如果是父子類之間的非靜態方法相同(重寫)，則只是呼叫子類的方法
  因為重寫了父類的方法，所以呼叫的時候只能呼叫重寫

  後的方法
  4.修飾符，範圍可以擴大但不能縮小，public-protected-default-private
  5.丟擲的異常，範圍可以縮小，但是不能擴大
  [email protected] // 註解: 理解為有功能的註釋

• 多型

  /**
       * 注意事項
       * 1. 多型是方法的多型，和屬性無關
       * 2. 父類和子類，有聯絡，型別轉換異常
       *
       */
      public static void main(String[] args) {
          // 多型的表現
          Cat cat = new Cat();
          Animal animal =
   
   new Cat();
          Object o = new Cat();
          // 都有run方法，因為子類重寫了，所以都呼叫子類的方法
          cat.run();
          animal.run();
          // 而sing方法只有子類有，所以只有子類型別的物件可以呼叫
          cat.sing();
      }
  

• InstanceOf和型別轉換

  	public static void main(String[] args) {
          // 1. instanceof比較是否存在父子關係，物件 類
          // 就看new出的物件是否可以是類的例項
          Object dog = new Dog();
          System.out.println(dog instanceof Animal1);
          System.out.println(dog instanceof Object);
          System.out.println(dog instanceof Dog);
  
          Animal1 animal1 = new Animal1();
          System.out.println(animal1 instanceof Animal1);
          System.out.println(animal1 instanceof Object);
          System.out.println(animal1 instanceof Dog);
  
          // 2. 型別轉換
          /**
           * 父類: 高; 子類: 低
           * 向低轉換需要強制轉換
           * 向高轉換可以自動轉（子類可能會丟失自己的一些方法）
           */
      }
  

• 抽象類

  	/**
       * 1. 抽象類不能new，若有非抽象的子類繼承，必須實現其中的抽象方法，若沒有實現，則也是抽象類
       * 2. 抽象方法必須宣告在抽象類中
       * 3. 抽象類中可以有普通方法，可以沒有抽象方法
       */
  	   abstract class Person3{
  	   public abstract void run();	// 抽象方法宣告
  	   public void a() {}
  
  

• 介面

  // 類可以實現介面，必須實現其中的方法
  public interface Inters {
  	// 可以定義常量，如下定義
  	// public static final不用寫就行
      public static final int age = 10;
      // 定義方法，不能實現
      public abstract void run();
      // public abstract以後不用寫就行
      void go();
  }
  

• 內部類

  public class 成員內部類 {
      // 4. 匿名內部類，比如 new Person().方法名，沒有起變數名
      
      private int id = 10;
      public void outer() {
          // 3. 區域性內部類
          class partInner {
  
          }
      }
  
      public static void main(String[] args) {
          成員內部類 outer = new 成員內部類();
          // 例項化內部類的方式
          Inner inner = outer.new Inner();
          inner.in();
      }
      // 1. 成員內部類 || 2. 然後加上修飾符static就是靜態內部類，不能訪問外部類的私有屬性了
      public class Inner {
          public void in() {
              System.out.println("成員內部類方法in" + id);
          }
      }
  }
  

• 異常

  	// throw一般用在方法中丟擲異常，
      // 處理不了，throws是向上丟擲異常
      public void test(int i, int j) throws ArithmeticException {
          if (j == 0) {
              throw new ArithmeticException();
          }
      }