面向物件 oop 2

1.繼承

1.繼承的本質是對某一批類的抽象 .

2.extends的意思是 "擴充套件". 子類是父類的擴充套件

3.Java中只有單繼承 ，沒有多繼承

1.繼承是類和類之間的一種關係. 除此之外，類和類之間的關係還有依賴，組合.聚合的關係.

2.繼承關係的兩個類，一個為子類(派生類)，一個為父類(基類)。子類繼承父類，使用關鍵字extends來表示

3.子類和父類之間，從意義上講應該具有"is a"的關係

在java中，所有的類都預設直接或間接繼承object類

如果父類是私有 private 像繼承就要呼叫

1.Supen詳解

super注意點

1.super呼叫父類的構造方法，必須在構造方法的第一個

2.super必須只能出現在子類的方法或構造器方法中

3.super 和 this 不能 同時呼叫 構造方法

this

代表物件不同：

this：本身呼叫者這個物件

super：代表父親類物件的應用

前提

this ：沒有繼承也可以使用

super：只能在有繼承條件才可以使用

構造方法

this();本類的構造

super();父類的構造

先執行父類的 在執行子類的 相當於在子類的無參上隱藏了一個super 指向父類的無參

2.方法的重寫

重寫：需要有繼承關係，子類重寫父類的方法

1.方法名必須相同

2.引數列表 列表必須相同

3.修飾符：範圍可以擴大但不能縮小

4.丟擲的異常：範圍.可以被縮小，但不能擴大

5.靜態的方法和非靜態的方法區別很大

6.重寫只能重寫非靜態 有static是靜態不能重寫

重寫.子類的方法和父類要一致：方法體不同！

重寫 CTRL+o

2.多型

多型注意事項：

1.多型是方法的多型，屬性沒有多型

2.父親和子類，有聯絡 型別轉換異常！ classcastException

3.存在條件：繼承關係，方法需要重寫，父類引用指向子類物件！

1. instancedof和 型別轉換

package com.Java.oop4;
public class Application {
  public static void main(String[] args) {
    Object object= new Student();
    System.out.println(object instanceof Student);//true
    System.out.println(object instanceof Object);//true
    System.out.println(object instanceof Teacher);//false
    System.out.println(object instanceof Person);//true
    System.out.println(object instanceof String);//false
    System.out.println("==========================");
     Student student= new Student();
    System.out.println(student instanceof Student);//true
    System.out.println(student instanceof Object);//true
    //System.out.println(student instanceof Teacher);//編譯報錯
    System.out.println(student instanceof Person);//true
    //System.out.println(student instanceof String);//編譯報錯
    System.out.println("==========================");
    Person person= new Student();
    System.out.println(person instanceof Student);//true
    System.out.println(person instanceof Object);//true
    System.out.println(person instanceof Teacher);//false
    System.out.println(person instanceof Person);//true
   //System.out.println(person instanceof String);//編譯報錯
   }
}
 

package com.Java.oop4;
public class Application {
  public static void main(String[] args) {
    //型別之間的轉化；父  子
   //高           低
    Person JPG = new Student();
    //student 將這個物件轉換為Student型別，我們就可使用Student型別的方法了！
     ((Student)JPG).son();
   }
}

1.父類引用指向子類的物件

2.把子類轉換為父類，向上轉型：

3.把父親轉換為子類，向下轉型： 強制轉換

4.方便方法的呼叫，減少重複的程式碼！簡介

2. static

package com.Java.Static;
//static
public class Student {
   private static int age;//靜態的變數
   private double score;//非靜態的變數
  public static void main(String[] args) {
    Student S1 = new Student();
    System.out.println(Student.age);
    System.out.println(S1.age);
    System.out.println(S1.score);
   }
}

package com.Java.Static;
public class Student {
  //2
   {
    System.out.println("匿名程式碼塊");
   }
  // 1  : 只執行一次
  static{
    System.out.println("靜態程式碼塊");
   }
  //3
  public Student() {
    System.out.println("構造方法");
   }
  public static void main(String[] args) {
    Student student = new Student();
   }
}

final 定義了的 就不能被繼承了

3.抽象類

1.abstract修飾符可以用來修飾方法也可以修飾類 ，如果修飾方法，那麼該方法就是抽象方法：如果修飾類，那麼該類就是抽象類

2.抽象類.不能使用new關鍵字 來建立物件，他是用來讓子類繼承的

3.抽象方法，只有方法的宣告，沒有方法的實現 它是用來讓子類實現的

4.子類繼承抽象類，那麼就必須要實現抽象類沒有實現的抽象方法，否則該子類也要宣告為抽象類

package com.Java.Static;
​
public class Choxiang {
  //abstract 抽象類：類 extends：單繼承  ~ (介面可以多繼承)
  public abstract class Action{
    //約束~ 有人幫我們實現
    //abstract，抽象方法，只有方法名字，沒有方法的實現
    public abstract void doSomething();
    //  1.不能new 這個 抽象類，只能靠類去實現它
    // 2.抽象類中可以寫普通的方法
    //3.抽象方法必須在抽象類中
     }
   }

4.介面

1.普通類： 只有具體實現

2.抽象類：具體實現和規範(抽象方法)都有！

介面：只有規範！自己無法寫的方法~裝也的約束！約束個實現分離：面向介面程式設計

interface

作用

1.約束

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

3.public abstract

4.public static final

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

6.implements 可以實現多個介面

7.必須要重寫介面中的方法

package com.Java.JieKo;
//抽象類 ：extends~
//類 可以實現介面 implements 介面
//實現了介面的類， 就需要重寫介面中的方法
//多繼承 ~  利用介面的多繼承
public class UserServiceImpl implements UserService,TimeService {
  @Override
  public void add(String name) {
   }
  @Override
  public void query(String name) {
   }
  @Override
  public void update(String name) {
   }
  @Override
  public void delete(String name) {
   }
  @Override
  public void time() {
   }
}

package com.Java.JieKo;
//interface 定義的關鍵字   介面都需要一個實現類
public interface UserService {
  //介面中所有定義其實都是抽象的 public
  //可以直接寫 返回值型別 和方法名
   void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);
}

package com.Java.JieKo;
​
public interface TimeService {
  void time();
​
}