抽象類:

含有抽象方法的類被聲明為抽象類
抽象方法由子類去實現

含有抽象方法的類必須被聲明為抽象類

抽象類被子類繼承，子類（如果不是抽象類）必須重寫抽象類中的所有抽象方法

抽象方法：

聲明而未被實現的方法

抽象類不能被實例化
子類實現不了, 由下一級子類去實現, 當前類聲明為抽象類, 繼承的這個方法聲明為抽象方法
抽象方法的權限修飾符必須為public

abstract

//人類
public class Person {
    private String name;
    //自定義屬性  引用類型 寵物
    private Pet pet;
    
    
 
public Person() {
        
    }
    
    public Person(String name, Pet pet) {
        this.name = name;
        this.pet = pet;
    }

    public void petHappy() {
        pet.scream();
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        
 
this.name = name;
    }

    public Pet getPet() {
        return pet;
    }

    public void setPet(Pet pet) {
        this.pet = pet;
    }
}

// 父類寵物類 抽象類
public abstract class Pet {
    private String pname;
    //抽象類可以有構造方法
    public Pet() {
    }

    public Pet(String pname) {
        
 
this.pname = pname;
    }
    //抽象類 的抽象方法   不能有方法體
    public abstract void scream();

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }
}

//子類 老虎類
public class Tiger extends Pet {
    public String fur; // 毛的顏色

    public Tiger(String name, String fur) {
        super(name);
        this.fur = fur;
    }

    public Tiger() {
        super();
    }

    @Override
    public void scream() {
        System.out.println("這是一只老虎的聲音 !");
    }

    public String getFur() {
        return fur;
    }

    public void setFur(String fur) {
        this.fur = fur;
    }
}

//子類 兔子類
public class Rabbit extends Pet {

    public String fur; // 毛的顏色

    public Rabbit(String name, String fur) {
        super(name);
        this.fur = fur;
    }

    public Rabbit() {
        super();
    }

    @Override
    public void scream() {
        System.out.println("兔子會賣萌 !");
    }

    public String getFur() {
        return fur;
    }

    public void setFur(String fur) {
        this.fur = fur;
    }
}

//主方法
public class Main {
    public static void main(String[] args) {
        Pet t1 = new Tiger("qqqq","www");
        Pet r1 = new Rabbit();
        
        Person p1 = new Person("小明", t1);
        Person p2 = new Person("小紅", r1);
        
        p1.petHappy();
        p2.petHappy();
    }
}

接口：

一種特殊的抽象類，裏面全部是由全局常量和公共的抽象方法所組成

類與類之間的實現關系

接口的實現也必須通過子類，使用關鍵字implements，而且接口是可以多實現的

一個類可以同時繼承和實現接口

一個借口不能集成一個抽象類，但是卻可以通過extends關鍵字同時繼承多個接口，實現接口的多繼承

public interface InterFaceTest1 {
    public static final String name = "hanqi";
    String pname = "tianqi";
    //接口定義的屬性默認public static final
    public void testMethod();
}

一個類去實現一個接口必須實現其中的方法

繼承：Java中不支持多繼承，一個類只能繼承一個

接口：接口可以實現多個

//接口1
public interface Inter {
    int AGE=22;//接口中的常量都是全局常量，也就是默認 public全局公共的，static靜態，final不可改變的
    public abstract void tell(); 
}

//接口2
public interface Inter2 {
    public abstract void say();
}

//接口3
public interface Inter3 extends Inter,Inter2{
    //接口繼承接口
    //一個接口不能繼承一個抽象類，但可以繼承多個接口，實現接口的多繼承
}

//抽象類
public abstract class Chouxc {
    public abstract void write();
}

//子類
public  class Shixian extends Chouxc implements Inter,Inter2{
    public void tell(){
        System.out.println("這是類實現的接口 Inter 的抽象方法");
    }
    public void say(){
        System.out.println("這是類實現的接口 Inter2 中的抽象方法");
    }
    public void write(){
        System.err.println("這是類繼承的抽象類中的抽象方法");
    }
}

//主方法
public class InterTest1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Shixian s=new Shixian();
        s.tell();
        s.say();
        System.out.println(Inter.AGE);
        System.out.println(s.AGE);
    }
}

Java面向對象之抽象類，接口