• 靜態方法是一種特殊的方法，它可以在不創建類的情況下使用。
• 關鍵字 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");

        }
    }
}

開頭先引用一下官方文件的說明

Type aliases and interfaces are very similar, and in many cases you can choose between them freely. Almost all features of an interface are available in type, the key distinction is that a type cannot be re-opened to add new properties vs an interface which is always extendable.

這段文字簡單來說就是兩著幾乎相同，但是有一個很大的差別就是介面可以被擴充，但是型別別名不行。那其實只要選擇擴充性高的話就好了呀，為什麼還要有型別別名呢？
以下就來比較差異和共同點吧!

宣告方式

一個是使用=，另個一個是物件的方式

介面

interface Person {
  name: string;
  age: number;
}

型別別名

type Person = {
  name: string;
  age: number;
};

宣告型別

介面

不能宣告基本型別，只能宣告物件型別，而且可以重複宣告，並且會合併

interface Person {
  name: string;
  age: number;
}
interface Person {
  account: string;
  money: number;
}
let Amy: Person = {
  name: "Amy",
  age: 18,
  acount: "AAA",
  money: 2000,
};
console.log(Amy);

型別別名

可以宣告基本型別和物件型別，但是不能重複宣告，會報錯

type Person = {
  name: string;
  age: number;
};
type Person = {
  account: string;
  money: number;
};
let Amy: Person = {
  name: "Amy",
  age: 18,
  acount: "AAA",
  money: 2000,
};
console.log(Amy);

擴充性

介面可以被擴充，型別別名也可以但是是藉由交集的方式，所以會有一些限制，例如不能使用 extends，但是可以使用&

介面

interface Person {
  name: string;
  age: number;
}
interface account extends Person {
  account: string;
  money: number;
}
let Amy: account = {
  name: "Amy",
  age: 18,
  acount: "AAA",
  money: 2000,
};
console.log(Amy);

型別別名

type Person = {
  name: string;
  age: number;
};
type account = {
  account: string;
  money: number;
} & Person;

let Amy: account = {
  name: "Amy",
  age: 18,
  acount: "AAA",
  money: 2000,
};

console.log(Amy);

總結

初步整理一下，介面和型別別名的差異，表格如下:

回到一開始的問題，那為什麼還要有型別別名呢？

以初學的階段而言需要使用到的時機就在於基本型別吧!因為 ts 本身的限制，有些時候會需要使用到基本型別，但是又想要擴充，這時候就可以使用型別別名，但是如果是物件型別的話，那就可以使用介面，因為介面可以被擴充，所以就沒有必要使用型別別名了。

簡介: 事務(Transaction)是一個邏輯上的工作單位，它可以包含一個或多個 SQL 語句

簡介: 事務(Transaction)是一個邏輯上的工作單位，它可以包含一個或多個 SQL 語句。事務可以讓一組 SQL 語句作為一個單元來執行，這些語句要麼全部執行，要麼全部不執行。事務是一個不可分割的工作執行單元，事務中包含的 SQL 語句要麼全部執行，要麼全部不執行，事務在執行過程中發生錯誤，會被回滾(Rollback)到事務開始前的狀態，事務在執行過程中沒有發生錯誤，會被提交(Commit)。

事務操作

開啟事務

START TRANSACTION;
-- 或
BEGIN;

提交事務

COMMIT;

回滾事務

ROLLBACK;

事務特性(ACID)

原子性(Atomicity)

事務是一個不可分割的工作執行單元，事務中包含的 SQL 語句要麼全部執行，要麼全部不執行，事務在執行過程中發生錯誤，會被回滾(Rollback)到事務開始前的狀態，事務在執行過程中沒有發生錯誤，會被提交(Commit)。

一致性(Consistency)

事務在執行過程中，數據庫會從一個一致性狀態轉換到另一個一致性狀態，事務開始前和結束後，數據庫的完整性約束沒有被破壞。

隔離性(Isolation)

事務的隔離性是指多個事務並發執行時，一個事務的執行不會被其他事務干擾，多個事務並發執行時，一個事務內部的操作及使用的數據對其他事務是隱藏的，其他事務的操作及使用的數據對該事務也是隱藏的。

持久性(Durability)

事務完成後(提交或是回滾)，事務對數據的修改被永久保存到數據庫中，即使發生故障也不會丟失。

範例

create table account(
id int primary key auto_increment,
name varchar(20),
money int

) ;

insert into account(name,money) values
("AAA",2000),
("BBB",3000);

begin;
SET SQL_SAFE_UPDATES = 0; -- 關閉安全模式
update account set money=money-500 where name="AAA";
update account set money=money+500 where name="BBB";
SET SQL_SAFE_UPDATES = 1; -- 開啟安全模式
-- commit; 預設式自動提交在mysql中
rollback;

MySQL 約束條件

約束概念和分類

概念:約束條件是一種限制條件，用於限制變數的取值範圍，使得變數在取值時必須滿足某種條件。
約束分類表格

外鍵約束

概念:外鍵約束是一種約束條件，用於限制變數的值必須在另一個表中存在。
外鍵約束的語法格式

CONSTRAINT 外鍵名稱 FOREIGN KEY (外鍵欄位名稱) REFERENCES 另一個表名稱(另一個表的欄位名稱)

外鍵約束的語法範例

create table dept(
id int primary key auto_increment,
dep_name varchar(20),
addr varchar(20)
);
create table emp(
id int primary key auto_increment,
name varchar(20),
age int,
dep_id int ,
constraint fk_emp_dept foreign key(dep_id)
references dept(id)
);

insert into dept (dep_name,addr) values
("RD","台北"),
("ME","台中");
insert into emp (NAMe,age,dep_id) values
("AAA",20,1),
("BBB",20,1),
("CCC",20,1),
("DDD",20,2),
("EEE",20,2),
("FFF",20,2);

主表要先建立，外鍵表要後建立，否則會報錯