隨堂筆記8

多型

1. 多型就是方法重寫，詳見筆記7方法重寫

2. 注意點

   1. 屬性沒有多型

   2. 父類和子類有聯絡 （型別轉換異常）ClassCastException

   3. 存在條件：繼承關係，方法需要重寫，父類引用指向子類 #Father f1=new Son()；

   4. 不能重寫的方法

      1. static 方法，屬於類，不屬於例項

      2. final常量

      3. private 私有的

instanceof和型別轉換

1. instanceof判斷物件和類是否有父子關係

2. 物件型別看new關鍵詞後邊的型別（區分與方法的呼叫）

   import com.yyl.demo03.Person;
   import com.yyl.demo03.Student;
    
   import com.yyl.demo03.Teacher;
   ​
   public class Application {
     public static void main(String[] args) {
       //Object>String
       //Object>Person>Student
       //Object>Person>Teacher
       Person person=new Student();
       System.out.println(person instanceof Person);
       System.out.println(person instanceof Object);
    
       System.out.println(person instanceof Student);
       System.out.println(person instanceof Teacher);
       //System.out.println(person instanceof String);編譯報錯
      }
   }

型別轉換

1. 型別可以自動從高轉到低

2. 強制轉換

   import com.yyl.demo03.Person;
   import com.yyl.demo03.Student;
   ​
   public class Application {
     public static void main(String[] args) {
    
        //低轉高可以自動轉換student->Person
       Person student=new Student();
       //無法呼叫student.go();能呼叫的方法看最左邊的定義，物件的類看最右邊的定義
       Student student1=(Student)student;//強制轉換為student型別
       student1.go();
       //或者((Student) student).go();
      }
   }

3. 子類自動轉化為父類，可能會丟失一些函式

static

1. static修飾符修飾的變數或者函式可以直接類呼叫：類名+函式名（變數名）

2. 程式碼塊

3. static最先緩衝，所以內部不能呼叫非static資料

抽象類

1. 在一個類之前加abstract關鍵字就變為抽象類

2. 在一個函式之前加abstract關鍵字變為抽象方法，抽象方法只有方法名字，沒有方法實現

3. 抽象類的子類都必須有重寫該函式的方法

4. java類單繼承，但介面可以多繼承

5. 注意

   1. 抽象類不能例項化，不能new一個物件 ~約束

   2. 抽象方法只能在抽象類中

   3. 抽象類中可以有普通方法

   4. 抽象方法只是一種約束

介面

1. 關鍵詞：interface #public interface 類名{ }

2. 介面中全部為抽象方法

3. 介面中的定義都是抽象的public（預設為public abstract,可以省略該部分）

4. 實現介面的類關鍵詞implements+介面名多個介面用逗號隔開

5. 實現介面的類，就必須重寫介面的方法

6. 可以利用介面實現多繼承

7. 介面中可以定義常量，int a=99；預設省略public static final

   //介面1
   public interface UserService {
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
   }

   //介面2
   public interface TimeService {
     void timer();
   }

   //實現類
   //類可以實現介面，通過 implements+介面
   public class UserServiceImpl implements UserService,TimeService{//完整版
   //快捷鍵alt+insert
     @Override
     public void timer() {
   ​
      }
   ​
     @Override
     public void add(String name) {
   ​
      }
   ​
     @Override
     public void delete(String name) {
   ​
      }
   ​
     @Override
     public void update(String name) {
   ​
      }
   ​
     @Override
     public void query(String name) {
   ​
      }
   }

8. 介面小節

   1. 約束

   2. 定義一些方法，讓不同的人去實現

   3. public abstract

   4. public static final（可省略）（只能宣告常量）

   5. 介面不能被例項化，介面中沒有構造方法

   6. implements可以實現多個介面，類中必須實現（重寫）介面中所有方法

n種內部類

public class Outer {
  private int a=1;
  public void out(){
    System.out.println("這是外部類方法");
   }
  public class Inner{
    public void in(){
      System.out.println("這是內部類方法");
     }
    public void visit(){//獲得外部類的私有屬性
      System.out.println(a);
     }
   }
}

public class Application {
  public static void main(String[] args) {
   Outer s1=new Outer();
   s1.out();
   //通過外部類來例項化內部類
   Outer.Inner s2=s1.new Inner();
   s2.in();
   s2.visit();
   }
}

=======================================================================================

匿名類

public class Test {
  public static void main(String[] args) {
    //沒有名字初始化，不用將例項儲存到變數中
    new Apple().eat();
    new UserService(){
      @Override
      public void hello() {//重寫hello介面的函式
​
       }
     };
   }
}
​
class Apple{
  public void eat(){
    System.out.println("1");
   }
}
interface UserService{
  void hello();
}

異常機制

1. 異常的種類

2. 異常的捕獲

3. 要捕獲多個異常要從小到大捕獲

   public class demo01 {
     public static void main(String[] args) {
       int a=1;
       int b=0;
   ​
       try{//try監控區域
         System.out.println(a/b);
         //new demo01().a();
         if(b==0){//主動丟擲異常 throw throws
           throw new ArithmeticException();//主動丟擲異常
          }
        }catch(ArithmeticException e){//catch捕獲異常括號內為捕獲異常的型別，最高階為Throwable
         System.out.println("程式出現異常，變數b不能為0");
         e.printStackTrace();//列印錯誤棧資訊(和原本錯誤提示相同)
         System.exit(0);
        }catch(Error e){
         System.out.println("Error");
        }
       catch(Throwable e) {
         System.out.println("Throwable");
        }finally {//處理善後工作
         System.out.println("Final");
        }//可以不要finally
   ​
      }
     public void a(){
       b();
      }
     public void b(){
       a();
      }
   }

4. 一般用在方法內丟擲異常，方法處理不了異常可以進行異常上拋

5. 所有異常都需要被捕獲，否則程式停止

public class Test {
  public static void main(String[] args) {
    //可以讓程式發生不停止，繼續執行
    try {
      new Test().test(1,0);
     } catch (ArithmeticException e) {
      e.printStackTrace();
     }
   }
  //假設方法無法處理這個異常，方法上丟擲異常
  public void test(int a,int b) throws ArithmeticException{
    if(b==0){//throw
      throw new ArithmeticException();
     }
   }
}

自定義異常

//測試異常
public class Test {
  //可能會存在異常的方法
  static void test(int a) throws MyException{
    System.out.println("傳入的數為"+a);
    if(a>10){
      throw new MyException(a);//丟擲
     }
   }
​
  public static void main(String[] args) {
    try {
      test(11);
     } catch (MyException e) {//可以增加一些處理異常的程式碼
      System.out.println("My Exception=>"+e);
     }
   }
}

//自定義異常
//首先繼承異常類
public class MyException extends Exception{
  //傳遞數字
  private int detail;
​
  public MyException(int detail) {
    this.detail = detail;
   }
  //toString
​
  @Override
  public String toString() {//異常的列印資訊
    return "MyException{" +
        "detail=" + detail +
        '}';
   }
}