Java抽象（方法，類）和Java的介面

一.抽象方法和抽象類(關鍵字abstract)（沒有抽象的成員變數）

1)抽象方法：用abstract修飾的類的方法

2)抽象類：用abstract修飾的類

成員變數：可以有變數，也可以有常量

成員方法：可以有抽象方法，也可以有成員方法

3）抽象方法沒有方法體的（也就是沒有方法具體的實現部分）

注意：

1）抽象類中抽象方法 強制子類去重寫父類的方法

2）抽象類不能例項化物件 ，不能用抽象類建立物件 ，所以-用多型的【父類的引用指向子類的物件】

3）抽象類中不一定有抽象方法，但是抽象方法一定存在抽象類中

4）抽象類中的子類 ，必須重寫抽象類的抽象方法

5）抽象類中的抽象方法不需要具體實現的功能。

6）abstract類中可以有構造方法，抽象類的構造方法不能是抽象方法。

7）abstract類和abstract方法都不能用final修飾。

8）程式碼：

public class Demo01 {
  public static void main(String[] args) {
      //父類的引用指向子類的物件
    Animal animal=new Cat();
    animal.eat();
    animal.fun();
    //列印 貓吃魚
}
}
/*
 * 動物  eat
 * 貓類 eat:魚
 * 
 */
//abstract class Person
 /*class Person{
    // 抽象類中不一定有抽象方法 
    // public  void fun()

    //抽象方法一定存在抽象類中 
    public  abstract void fun() {

    }
}*/
 abstract class Animal{

 final   int number=10;
     public Animal() {
         System.out.println("我是父類的抽象方法");
     }
     public void fun() {
         System.out.println("我是成員方法");
     } 
     //抽象類中的抽象方法
     //第一種寫法 abstract public void eat();
     //第二中寫法
      public abstract void eat() ;

      }

 class Cat extends Animal{

    @Override
    public void eat() {

        System.out.println("貓吃魚");
    }


}

9）abstract與那些關鍵字不能共存

1.不能與static共存

static修飾方法，用類名去呼叫。

abstract修飾抽象方法沒有方法的實現，沒有實現部分的方法，只能是方法的宣告，不能直接呼叫，所以不能共存

2.不能final共存

final修飾方法不能重寫。

abstract修飾方法就是為了子類方法的重寫，所以不能被共存

3.不能與private共存

private修飾方法，只能本類去訪問private修飾的方法，而子類訪問不到，談不到重寫

10）程式碼

public class Demo02 {

    public static void main(String[] args) {
        //利用多型建立子類物件
         BiXieJianBu y=new YBQ();
         y.ziGong();
         BiXieJianBu l=new LPZ();
         l.ziGong();

    }

}
 abstract class BiXieJianBu{
        abstract void ziGong();
       public abstract void fun();

 }

 class YBQ extends BiXieJianBu{
      @Override
    public void ziGong() {
        // TODO Auto-generated method stub
        System.out.println("用刀自宮");
    }
      @Override
    public void fun() {


    }

 }

 class LPZ extends BiXieJianBu{

      @Override
    public void ziGong() {

        System.out.println("用錘子自宮");
    }
      @Override
    public void fun() {

        System.out.println();
    }
 }

二.Java介面（是一個抽象型別，抽象方法的集合，不是類）

1.用==interface關鍵字==修飾的叫做介面

2.只有抽象方法(沒有成員方法）和常量，沒有構造方法（==因為介面不是類==）

3.形式：

interface 介面名{}

程式碼

interface InterA （介面名）{

}

4.介面的特點

1）介面中只能宣告抽象的方法，成員常量

interface InterA {
    public static final int num=10;
    public abstract void print();

}

注：介面中 系統會預設將

成員變數 寫成 int num(其實前面有 public static)

成員方法 寫成 void print()；//方法名 其實前面是(public abstract)

這些都被系統預設的，但是自己最好填寫上

2）介面中不能有建構函式，所以也不能被例項化（誰去用介面 ，就要去強制你去實現介面中的方法）。—–不能被例項化，可以使用多型的方法是建立實現類的物件。

3）關係

1. 類和類的關係

類和類之間是繼承關係，分為單繼承和多層繼承

2.類和介面的關係

類和介面之間是==實現==關係,不是繼承關係,可以單實現,也可以多實現

3.介面和介面的關係

介面和介面之間可以單繼承,也可以多繼承

4.程式碼

public class Demo03 {
    public static void main(String[] args) {
        InterA a=new Person();
        a.print();

        System.out.println(InterA.num);
}
}
interface InterA {
    public static final int num=10;
    public abstract void print();

}

class Person implements InterA{
 //實現介面的方法

    @Override
    public void print() {
        // TODO Auto-generated method stub
        System.out.println(num);
        System.out.println("我是人類的列印");
    }
}

interface InterX{
     public  abstract void fun();
}

interface InterY{
     public  abstract void fun1();
}

//介面和介面之間 可以單繼承 也可以多繼承
interface InterZ extends InterX,InterY{

}

//介面的多實現
/*class Car implements InterX , InterY {

    @Override
    public void fun1() {
        // TODO Auto-generated method stub
        System.out.println("我是fun1");
    }

    @Override
    public void fun() {
        // TODO Auto-generated method stub
        System.out.println("我是fun");
    }

}*/