遞迴是一種函式呼叫自己的技巧，遞迴的函式必須要有一個終止條件，否則會無限迴圈下去，直到記憶體爆掉為止。

public class Recursion {
    public static void main(String[] args) {
        int result = sum(10);
        System.out.println(result);
    }

    public static int sum(int k) {
        if (k > 0) {
            return k + sum(k - 1);
        } else {
            return 0;
        }
    }
}

所謂的訪問權限，其實就是訪問屬性、方法的權利和限制

public

1. public: 公共的,任意使用,訪問權限修飾符
2. Java 中的public class只能有一個,且必須與檔名相同
3. main 方法必須是 public static void,不加不能使用，因為 main 方法是由 JVM 調用的，JVM 應該可以任意調用，不該受到限制。
4. static: 靜態的,靜態方法,靜態變數,靜態代碼塊,main 方法不加 staitic,一樣不能使用

private

1. private: 私有的,訪問權限修飾符
2. private 修飾的變數,只能在所屬類中使用

default

1. (default): 默認的,當沒有設定訪問權限修飾符時,JVM 會默認提供一個訪問權限，就是 package(路徑)訪問權限，子 package 不能使用
2. default 修飾的變數,只能在同一包中使用

protected

1. protected: 受保護的,訪問權限修飾符
2. protected 修飾的變數,只能在同一包中使用,同 package 或是不同 package 子類都可以使用

小結

訪問權限由小到大排列
1.private: 只能在本類中使用
2.(default): 只能在同一包中使用,不同的包路徑就不能使用
3.protected: 只能在同一包中使用,同包或是不同包子類都可以使用
4.public: 任意使用,JVM 預設給的構造方法

類的訪問權限

外部類

就是直接在程式碼中定義的類 1.外部類只能是 public 或是 (default) 修飾

內部類

就是在類中定義的類 1.內部類可以是 public、protected、(default)、private 修飾 2.內部類就當成外部類的屬性或是方法來使用

內部類如何創建

因為內部類是外部類的屬性或是方法，所以必須先創建外部類，才能創建內部類

package basic;

public class helloworld {
    public static void main(String[] args) {
    //內部類要先創建外部類
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.show();
    }
}

class Outer{
    public  class Inner{
        public void show(){
            System.out.println("Hi");
        }
    }
}

Final

Java 中提供一種語法，可以讓初始化的變數或是方法或是類不被改變，這種語法就是 final

1. final 修飾的變數,只能被賦值一次,不能再次賦值
2. final 不能被 JVM 默認賦值,必須手動賦值
3. final 修飾的方法不能被覆寫
4. final 修飾的類不能被繼承，也就是不能有子類
5. final 不能修飾建構方法
6. final 可以修改方法的參數，一旦修飾就不能被修改

常用的方法搭配構造方法使用

package basic;

public class helloworld {
    public static void main(String[] args) {
    final String name = "John";
      User user = new User(name);
    }
}

class User{
    public String name;
    public User(String name){
        this.name = name;
    }
}

單例模式

使用情境:

1. 當需要創建一個類的實例，但是又不希望每次創建新的實例時都創建一個新的時候

實作概念:

1. 單例模式是一種常用的設計模式
2. 在單例模式中，類的構造方法是私有的
3. 在單例模式中，類必須自行創建一個實例
4. 在單例模式中，類必須自行向整個系統提供這個實例

package basic;

public class helloworld {
    public static void main(String[] args) {
        SingleMode singleMode1 = SingleMode.getInstance();
        SingleMode singleMode2 = SingleMode.getInstance();
        System.out.println(singleMode1 == singleMode2);
    }
}

class SingleMode{
    private static SingleMode singleMode = null;
    private SingleMode(){

    }
    public static SingleMode getInstance(){
        if(singleMode == null){
            singleMode = new SingleMode();
        }
        return  singleMode;
    }
}

• 靜態方法是一種特殊的方法，它可以在不創建類的情況下使用。
• 關鍵字 static 表示靜態方法，它屬於類，而不是屬於類的實例。
• 靜態方法可以直接使用類名.方法名調用
• 靜態方法不能訪問成員屬性和成員方法

範例

package basic;

public class helloworld {
    public static void main(String[] args) {
        TestStatic test = new TestStatic();
        test.test1();
        TestStatic.test2();
    }
}

class TestStatic{
    public void test1() {
        System.out.println("non-static Hello world!");
    }
    public static void test2() {
        System.out.println("Static Hello world!");
    }

}

靜態代碼塊

類的程式載入完成後會自動執行的程式碼，只會執行一次。可以完成靜態屬性的初始化。

範例

public class helloworld {
    public static void main(String[] args) {
    TestStatic t= new TestStatic();
    TestStatic.test();

    }
}

class TestStatic{
    static {
        System.out.println("static block");
    }
    static void test(){
        System.out.println("test");
    }
}

創建實例時也會執行代碼塊，但不是靜態代碼塊，而是代碼塊。

Java 有許多不同的特殊類別，例如：介面、抽象類別、枚舉類別、匿名類別，這些類別都有各自的特性，也有各自的使用場景，這篇文章會介紹這些特殊類別的特性與使用場景。

介面(Interface)

可以簡單的理解為一個規則

介面的特性

1. 介面都是抽象的
2. 規則的屬性為固定值,且不能修改
3. 屬性和行為的訪問權限必須為公共的
4. 屬性是靜態的
5. 行為是抽象的
6. 介面和類是不一樣的東西
7. 介面可以繼承多個介面
8. 類的物件需要遵循介面，在 Java 中這個動作叫做實現(implements)，類需要實現介面，而且可以實現多個介面

介面的語法

package basic;

public class helloworld {
    public static void main(String[] args) {
    Computer c=new Computer();
    Light l1=new Light();
    Light l2=new Light();
    c.usb1=l1;
    c.usb2=l2;
    c.powerSupply();
    }
}
interface USBInterface {
}
interface USBSupply extends USBInterface{
    public void powerSupply();
}
interface USBReceive extends USBInterface{
    public void powerReceive();
}
class Computer implements USBSupply{
    public USBReceive usb1;
    public USBReceive usb2;
    public void powerSupply(){
    System.out.println("Computer is supplying power");
    usb1.powerReceive();
    usb2.powerReceive();
    };
}
class Light implements USBReceive{
    public void powerReceive(){
        System.out.println("Light is receiving power");
    }
}

抽象(Abstract)

只有宣告沒有實作的方法

抽象方法(Abstract Method)

語法

abstract 返回值類型 方法名稱(參數列表);

abstract class Animal{
    abstract void eat();
}

抽象類別(Abstract Class)

1.因為類不完整，所以不能被實體化，只能被繼承 2.如果一個類有抽象方法，那麼該類必須定義為抽象類 3.抽象類可以有抽象方法，也可以有非抽象方法 4.抽象類無法直接實體化，必須由子類繼承實現間接的實體化 5.如果抽象類有抽象方法，那麼子類必須重寫抽象方法

語法

abstract class 類別名稱{…}

abstract class Animal{
    abstract void eat();
}
class Dog extends Animal{
    void eat(){
        System.out.println("dog eat");
    }
}

枚舉(Enum)

1.枚舉是一個特殊的類別，其中包含一組特定對象，這些對象不會發生改變 2.關鍵字 enum 用來宣告一個枚舉 3.枚舉會將對象放置在最前面,後面用分號隔開 4.枚舉不能創建對象，它是在內部創建的

package basic;

public class JavaEnum {
    public static void main(String[] args){
    System.out.println(City.TAIPEI.name);
    System.out.println(City.TAICHUNG.name);

    }
}
enum City{
    TAIPEI("台北"),TAICHUNG("台中"),TAINAN("台南");
    City(String name){
        this.name=name;
    }
    public String name;

}

匿名類(Anonymous)

在某些場合，類的名子不重要，指向使用類中的方法或功能
如下範例，直接在方法中建立一個類，並且實作方法，並且在方法中使用

package basic;

public class JavaAnonymousClass {
    public static void main(String[] args){
    Me me = new Me();
    me.sayHello(new Person(){
        public String name(){
            return "John";
        }
    });
    }
}
abstract class Person{
    public abstract String name();
}
class Me{
    public void sayHello(Person person){
        System.out.println("Hello " + person.name());
    }
}

Java 身為標準的物件導向程式設計語言，物件導向程式設計的特性有繼承、多型、多載、重寫，這些特性都是為了讓程式碼更加的模組化，讓程式碼更加的容易維護與擴充。

物件導向程式設計的特性

繼承(Extends)

1.父類別是在子類別建構出來前就就建構出來的，子類別會繼承父類別的屬性與方法，完成父類別的建構後。 2.以物件的概念，每一個子類對應到的父類都是各自獨立的，而子類繼承父類的屬性與方法，就是子類繼承父類的物件。
3.super()可以呼叫父類的建構方法，super.可以呼叫父類的屬性與方法。this()可以呼叫自己的建構方法，this.可以呼叫自己的屬性與方法。 4.如果父類提供建構方法，那麼 JVM 不會自動提供預設建構方法，所以子類必須要有對應的建構方法，否則會出現錯誤。

以 JAVA 為例，繼承的語法如下：

class 父類別 {
    // 父類別的屬性與方法
}
class 子類別 extends 父類別 {
    // 子類別的屬性與方法
}

多型(Polymorphism)

所謂的多型，就是同一個物件在不同場景下，會有不同的表現形式。 1.多型其實會在對物件的使用場景下進行限制，例如：父類別的物件只能使用父類別的屬性與方法。

public class helloworld {
    public static void main(String[] args) {
    Person p1=new Person();
    p1.sayPerson();
    Person p2=new Boy();
    p2.sayPerson();
    p2.sayBoy();//這裡會出現錯誤，只能使用Person的屬性與方法，不能使用Boy的屬性與方法。
    //改成如下
    Boy b2= new Boy();
    b2.sayBoy();

    Person p3=new Girl();
    p3.sayPerson();
    p3.sayGirl();//這裡會出現錯誤，只能使用Person的屬性與方法，不能使用Girl的屬性與方法。
    ////改成如下
    Girl g3=new Girl();
    g3.sayGirl();
    }
}
    class Person {
       void sayPerson(){
              System.out.println("I am a person");
       }
    }

    class Boy extends Person {
        void sayBoy(){
            System.out.println("I am a boy");
        }
    }

多載(Overload)

1.一個類別中，不能重複宣告相同名稱的方法，這裡的相同是指方法名稱與參數列表都相同，與返回值無關，但是可以宣告相同名稱的方法，只要參數列表不同(個數、順序、類型)即可，這就是所謂的方法多載。

package basic;

public class helloworld {
    public static void main(String[] args) {
        LoginApp loginApp = new LoginApp();
        loginApp.Login("123456789","123456");
        loginApp.Login(123456789,"123456");
        loginApp.Login("11@11");
    }

    static class LoginApp {
        void Login(String account,String password){
            System.out.println("帳號密碼登入");
        }
        void Login(Number phone,String password){
            System.out.println("手機號碼密碼登入");
        }
        void Login(String email){
            System.out.println("email登入");
        }
    }
}

2.構造方法也有多載

package basic;

public class helloworld {
    public static void main(String[] args) {
 LoginApp loginApp = new LoginApp();
    loginApp.LoginApp();
    loginApp.LoginApp("AAA");
    }

    static class LoginApp {
     void LoginApp(){
         System.out.println("原生");
     }
     void LoginApp(String name){
         System.out.println( name+"重载");
     }

    }
}

重寫(Override)

子類別可以重寫父類別的方法，但是要注意的是，子類別重寫父類別的方法時，方法名稱、參數列表、返回值都要相同。 1.一個類能使用什麼方法取決於引用的變數類型 2.一個類能使用什麼屬性取決於引用的變數類型 3.一個類的方法如何實現取決於實際的物件類型 4.一個類的屬性具體的使用不需要考慮實際的物件，屬性在哪裡宣告在哪裡使用

package basic;

public class helloworld {
    public static void main(String[] args) {
        Child c = new Child();
        c.print();
    }

    static class Parent{
        String name = "Parent";
        public void print() {
            System.out.println("I'm a parent");
        }
    }

    static class Child extends Parent{
        String name = "Child";
        public void print() {
            System.out.println("I'm a child");

        }
    }
}