===============java相關講解=============

final關鍵字：

final關鍵字的用法

• final關鍵字修飾一個基本型別的變數時，該變數不能重新賦值，第一次的值為最終的。
• fianl關鍵字修飾一個引用型別變數時，該變數不能重新指向新的物件。
• final關鍵字修飾一個函式的時候，該函式不能被重寫。
• final關鍵字修飾一個類的時候，該類不能被繼承。

常量 的修飾符一般為： public static final

抽象類

抽象類的應用場景：

我們在描述一類事物的時候，發現該種事物確實存在著某種行為，但是這種行為目前是不具體的，那麼我們可以抽取這種行為 的宣告，但是不去實現該種行為，這時候這種行為我們稱作為抽象的行為，我們就需要使用抽象類。

抽象類的好處: 強制要求子類一定要實現指定的方法。

抽象類要注意的細節：

• 如果一個函式沒有方法體，那麼該函式必須要使用abstract修飾,把該函式修飾成抽象 的函式。。
• 如果一個類出現了抽象的函式，那麼該類也必須 使用abstract修飾。
• 如果一個非抽象類繼承了抽象類，那麼必須要把抽象類的所有抽象方法全部實現。
• 抽象類可以存在非抽象方法，也可以存在抽象的方法.
• 抽象類可以不存在抽象方法的。

• 抽象類是不能建立物件的。
  疑問：為什麼抽象類不能建立物件呢？

  因為抽象類是存在抽象方法的，如果能讓抽象類建立物件的話，
  那麼使用抽象的物件呼叫抽象方法是沒有任何意義的。
  

• 抽象類是存在建構函式的，其建構函式是提供給子類建立物件的時候初始化父類的屬性的。

//動物類--->抽象類
abstract class Animal{
    String name;
    String  color;
    public Animal(String  name,String color){
        this.name = name;
        this.color = color;
    }
    //非抽象的方法
    public void eat(){
        System.out.println(name+"吃糧食");
    }
    //移動...
    public abstract void run();
}

//狗 是屬於動物中一種 
 

class Dog extends Animal{
    public Dog(String name,String color){
        super(name,color);
    }
    public void run(){
        System.out.println(name+"四條腿跑得很快...");
    }
}

//魚 是屬於動物中一種
class Fish extends Animal{
    public Fish(String name,String color){
        super(name,color);
    }
    public void run(){
        System.out.println(name+"搖搖尾巴游啊遊！");
    }
}

class Demo3 {
    public static void main(String[] args) 
    {
        /*
        Dog d = new Dog("牧羊犬","棕色");
        d.run();
        //建立一個魚物件
        Fish f  = new Fish("錦鯉","金黃色");
        f.run();
        */
        Animal a = new Animal();

    }
}

抽象類demo舉例

需求： 描述一個圖形、圓形、 矩形三個類。不管哪種圖形都會具備計算面積與周長的行為，但是每種圖形計算的方式不一致而已。

常量的命名規範：全部字母大寫，單詞與單詞 之間 使用下劃線分隔。

abstract不能與以下關鍵字共同修飾一個方法：

1. abstract不能與private共同修飾一個方法。
2. abstract 不能與static共同修飾一個方法。
3. abstract 不能與final共同修飾一個方法。

//abstract 抽象

//圖形類
abstract class MyShape{ 
    String name;
    public MyShape(String name){
        this.name = name;
    }
    public  abstract void getArea();
    public abstract void getLength();
}

//圓形 是屬於圖形類的一種
class Circle extends MyShape{
    double r;
    public static final double PI = 3.14;
    public Circle(String name,double r){
        super(name);
        this.r =r;
    }
    public  void getArea(){
        System.out.println(name+"的面積是："+PI*r*r);
    }
    public  void getLength(){
        System.out.println(name+"的周長是："+2*PI*r);
    }
}

//矩形 屬於圖形中的 一種
class Rect extends MyShape{
    int width;
    int height;
    public Rect(String name,int width, int height){
        super(name);
        this.width = width;
        this.height = height;
    }
    public  void getArea(){
        System.out.println(name+"的面積是："+width*height);
    }
    public  void getLength(){
        System.out.println(name+"的周長是："+2*(width+height));
    }
}

class Demo4 
{
    public static void main(String[] args) 
    {
        //System.out.println("Hello World!");
        Circle c = new Circle("圓形",4.0);
        c.getArea();
        c.getLength();

        //矩形
        Rect r = new Rect("矩形",3,4);
        r.getArea();
        r.getLength();

    }
}

介面

介面：拓展功能的。 usb介面.。。

介面的定義格式：

interface 介面名{

}

介面要注意的事項 ：

1. 介面是一個特殊的類。
2. 介面的成員變數預設的修飾符為： public static final 。
   那麼也就是說介面中的成員變數都是常量。
3. 介面中 的方法都是抽象的方法，預設的修飾符為： public abstract。
4. 介面不能建立物件。
5. 介面是沒有構造方法的。
6. 介面是給類去實現使用的，非抽象類實現一個介面的時候，
   必須要把介面中所有方法全部實現。

實現介面的格式：

class  類名 implements 介面名{

}

interface A{
    //成員變數
    public static final int i=10;
    //成員函式
    public void print();
}
class Demo7 implements A{ // Demo7就實現了A介面
    public static void main(String[] args) 
    {
        Demo7 d = new Demo7();
        d.print();
    }
    //實現介面中的方法
    public void print(){
        System.out.println("這個是介面中的print方法...");
    }
}

介面的作用：

1. 程式的解耦。  （低耦合）
2. 定義約束規範。
3. 拓展功能。

程式碼舉例：

//普通的鉛筆類
class Pencil{
    String name;
    public Pencil(String name){
        this.name = name;
    }
    public void write(){
        System.out.println(name+"沙沙的寫...");
    }
}

//橡皮介面
interface Eraser{
    public void remove();
}

//帶橡皮的鉛筆
class PencilWithEraser extends Pencil implements Eraser {
    public PencilWithEraser(String name){
        super(name);
    }
    public void remove(){
        System.out.println("塗改,塗改....");
    }
}

class Demo8 
{
    public static void main(String[] args) 
    {
        PencilWithEraser p = new PencilWithEraser("2B鉛筆");
        p.write();
        p.remove();

    }
}

類與介面之間關係： 實現關係。

類與介面要注意的事項：

1. 非抽象類實現一個介面時，必須要把介面中所有方法全部實現。
2. 抽象類實現一個介面時，可以實現也可以不實現介面中的 方法。
3. 一個類可以實現多個介面 。

疑問： java為什麼不支援多繼承，而支援了多實現呢？

        class A{

            public void print(){
                System.out.println("AAAAAA");
            }
        }

        class B{

            public void print(){
                System.out.println("BBBBBB");
            }
        }


        class C extends A ,B{

        }

        new C().print();

介面與介面之間關係： 繼承關係。

介面與介面之間要注意事項：

1. 一個介面是可以繼承多個介面的。

interface A{
    public void print();
}
interface C{
    public void getArea();
}
interface B extends A,C{ // B介面繼承A介面
    public void test();
}

class Demo10 implements B{
    public static void main(String[] args) 
    {
        Demo10 d = new Demo10();
        d.print();
    }
    public void getArea(){}
    public void test(){}
    public void print(){
        System.out.println("這個是A介面的print方法...");
    }
}