1.類：模板，⽤來定義⼀類物件的⽅法和屬性，⽐如⼈、學⽣、貓，萬物都是有模板，都是可 以定義為類。 (類名⾸字⺟⼤寫)

class Student{

}
class Person{

}
class Cat{

}

物件：類的例項化，⽐如 學⽣這個類例項化，就是 XX同學

Student student = new Student();
Cat cat1 = new Cat();
new Persion();

方法：⽅法是語句的集合，在⼀起完成⼀個功能

　　⽅法包含於類或物件中，即普通⽅法或者類⽅法

修飾符 返回值型別 ⽅法名(引數型別 引數名){
 ...
 ⽅法體
 ...
 return
 
 返回值;
}

繼承：⼦類繼承⽗類的特徵和⾏為，使得⼦類物件具有⽗類的⽅法和屬性

　　⽗類也叫基類，具有公共的⽅法和屬性

　　　　動物<-貓

　　　　動物<-狗

多型

　　同⼀個⾏為具有多個不同表現形式的能⼒

　　優點：減少耦合、靈活可拓展

　　⼀般是繼承類或者重寫⽅法實現

抽象

　　關鍵詞abstract宣告的類叫作抽象類，abstract宣告的⽅法叫抽象⽅法

　　⼀個類⾥包含了⼀個或多個抽象⽅法，類就必須指定成抽象類

　　抽象⽅法屬於⼀種特殊⽅法，只含有⼀個宣告，沒有⽅法體

teacher類

package day3;

public class Teacher {

    
 
private int age;

    private String name;

    private int sex;

    public void tech(){
        System.out.println("教學");
    }

    public void sleep(){
        System.out.println("睡覺");
    }
}

school類

package day3;

public class School {

    private String name;

    private String address;

    
 
private int age;

    private Teacher [] teachers;

    public void addTearcher(){

    }

    public void setTeachers(Teacher[] teachers){
        this.teachers = teachers;
    }

    public Teacher[] getTeachers() {
        return teachers;
    }

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

    public String getName(){
        return name;
    }

    public void setAge(int age){
        if(age>0){
            this.age = age;
            System.out.println("設定完成");
        }else{
            System.out.println("非法引數");
        }

    }

    public static void main(String [] args){
        System.out.println("主入口");
        School school = new School();
        school.setAge(1);
        Teacher teacher1 = new Teacher();
        teacher1.tech();
    }

}

2.建構函式:⼀種特殊的⽅法，建立物件時⽤來初始化物件，每次使⽤new 建立物件的時候，就會使⽤建構函式。與類具有相同的名稱，但是沒有返回值，Java會⾃動為每個類提供⼀個預設建構函式，如果⾃⼰定義了建構函式，就不再使⽤預設建構函式，如果沒有顯示的寫出預設建構函式， 則會消失。

注意點：如果建構函式之間互相調⽤，務必寫在⽅法第⼀⾏

建構函式種類

預設建構函式

public 類名(){
}

⽆參建構函式

public 類名(){
//寫⾃定義的語句
}

有參建構函式

public 類名(引數型別1 引數名1，引數型別2 引數名2...){
//⾃定義⽅法體
}

建構函式的修飾符

　　public ⽤的最多，⽤來建立物件

　　private 私有化建構函式，不給外部建立物件，⽐如⼯具類，或者單例設計模式

　　default 預設的話，只能在當前包⾥⾯使⽤new 建立物件，⼏乎不⽤

user 類

package day3;
//一個類裡面可以有多個建構函式
public class User {

    private int age;

    private String name;

//    建構函式，相當於這個物件初始化
//    如果建構函式之間互相呼叫，務必寫在方法第一行
    public User(){
        System.out.println("這是預設建構函式");
        this.age = age;

    }

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void setAge(int age){
        if(age>0){
            this.age = age;
        }else{
            System.out.println("非法引數");
        }
    }

    public int getAge(){
        return age;
    }

    public String getName(){
        return name;
    }

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

    public void sleep(){
        System.out.println("睡覺");
        String name = this.getName();
        System.out.println(name+"在睡覺");
    }

    public void sleep(String address){
        System.out.println(address);
        System.out.println("睡覺");
    }
}

maintest類

package day3;

public class MainTest {
    public static void main(String [] args){
//        test1();
//        test2();
        test3();
    }

    public static void test3(){
        User user = new User();
    }

    public static void test2(){
        String name = "一把手";
        int age = 5;

        User u = new User(name,age);
        User u2 = new User();
        System.out.println(u.getName());
    }

    public static void test1(){
        User user = new User();
        user.setAge(10);
        System.out.println(user.getAge());
        user.setName("大爺灰");
        System.out.println(user.getName());
    }
}

3.封裝

　　封裝是把過程和資料包圍起來，對資料的訪問只能通過已定義的接⼝即⽅法

　　在java中通過關鍵字private，protected和public實現封裝。什麼是封裝？封裝把物件的所有組成部分組合在⼀起，封裝定義程式如何引⽤物件的資料，封裝實際上使⽤⽅法將類的資料隱藏起來，控制⽤戶對類的修改和訪問資料的程度。 適當的 封裝可以讓程式碼更容易理解和維護，也加強了程式碼的安全性.

　　類封裝

　　⽅法封裝

overload（過載，過載）

　　在⼀個類⾥⾯，⽅法名字相同，⽽引數不同，和返回型別⽆關

override（重寫，覆蓋）

　　⼦類對⽗類的允許訪問的⽅法的實現過程進⾏重新編寫, 返回值和形參都不能改變

　　　　返回值型別，⽅法名，引數型別以及個數

　　⼦類能夠根據需要實現⽗類的⽅法

3.this關鍵字

　　當⼀個物件建立後，JVM會給這個物件分配⼀個引⽤⾃身的指標，這個指標的名字就是 this

　　只能⽤於⾮靜態⽅法體內，靜態⽅法和程式碼塊不能出現this

　　this就是指向當前物件本身

使⽤場景：

　　this(引數型別1 引數名，...) 表示當前類對應的建構函式

　　⽅法形參和物件的屬性重名，⽤this來區分

public void setAge(int age){
 this.age = age;
}

4，繼承

　　⼦類繼承⽗類的特徵和⾏為，使得⼦類物件具有⽗類的⽅法和屬性

　　⽗類也叫基類，具有公共的⽅法和屬性，⽣活中的例⼦

　　　　動物<-貓

　　　　動物<-狗

　　java中的繼承，減少重複程式碼

　　格式，通過extends關鍵字

class ⽗類名稱{

}
class ⼦類名稱 extends ⽗類名稱{

}

特點

　　⼦類擁有⽗類的⾮private的屬性和⽅法

　　⼦類可以⽤⾃⼰的⽅式實現⽗類的⽅法 override(重寫，覆蓋)

　　實現了程式碼的復⽤

　　重寫從⽗類那⾥繼承來的⽅法的，當調⽤⽅法時候會優先調⽤⼦類的⽅法（預設就近原則）

注意：

　　不⽀持多繼承，⽀持多重繼承，多重繼承提⾼了耦合性，組合優於繼承

　　所有的類都是繼承於 java.lang.Object

　　final關鍵字

　　　　修飾的類，則這個類不可以被繼承

　　　　修飾⽅法，則這個⽅法不允許被覆蓋（重寫）

living類

package day3;

public class Living {

    public void run(){
        System.out.println("運動");
    }
}

animal類

package day3;

public class Animal extends Living{

    private String name;

    private int age;

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    public void sleep(){
        System.out.println("閉著眼睛睡覺");
    }
}

dog類

package day3;

public class Dog extends Animal{

    public void eat(){
        System.out.println("狗吃骨頭");
    }

    @Override
    public void sleep(){
        System.out.println("狗白天不著眼睛睡覺");
    }

    public void test(){
    //呼叫父類的方法,super表示父物件的引用
    super.sleep();
    //呼叫當前類的方法，this表示當前物件的引用
    this.sleep();
    }
}

EetendsMainTest類

package day3;

public class EetendsMainTest {
    public static void main(String [] args){
        Dog dog = new Dog();
        dog.setAge(1);
        dog.setName("旺財");
        System.out.println(dog.getAge());
        dog.sleep();
        dog.eat();
        dog.test();
    }
}

5.繼承

　　⼀個引⽤變數，⽤於引⽤⽗類物件

　　⽗類和⼦類都具有相同的命名⽅法，要調⽤⽗類⽅法時使⽤

　　⽗類和⼦類都具有相同的命名屬性，要調⽤⽗類中的屬性時使⽤

　　super也是⽗類的建構函式，格式 super(引數)

　　注意點 調⽤super() 必須是類建構函式中的第⼀條語句，否則編譯不通過

注意

　　每個⼦類構造⽅法的第⼀條語句，都是隱含地調⽤super()，如果⽗類沒有這種形式的構造函 數，那麼在編譯的時候就會報錯

public class Father {
 public Father(){
 System.out.println("father ⽆參建構函式");
 }
}
public class Children extends Father{
 public Children(){
 //預設存在，寫和不寫都⾏
 super();
 System.out.println("Child⽆參建構函式");
 }
}

　　this()和super()都指的是物件，均不可以在static環境中使⽤

　　包括：static變數,static⽅法，static語句塊。

建構函式 super和this

　　this 和super在建構函式中只能有⼀個，且都必須是建構函式當中的第⼀⾏

　　當⽗類的建構函式是⽆參建構函式時，在⼦類的建構函式中，不⽤顯式super()去調⽤⽗類的 建構函式,

　　當⽗類的建構函式是有參建構函式時，如果⼦類的建構函式中不寫super()進⾏調⽤⽗類的建構函式，編譯器會報錯。

java繼承後類的初始化順序

　　問題：靜態程式碼塊、⾮靜態程式碼、⽗類/⼦類⽆參構造⽅法、⽗類/⼦類的⼀般⽅法

father類

package day3;

public class Father {

    static {
        System.out.println("父類靜態程式碼塊");
    }

    public Father(){
        System.out.println("father 無參建構函式");
    }

    public Father(int age){
        System.out.println("father 有參建構函式");
    }

    public void sleep(){
        System.out.println("father sleep方法");
    }
}

children類

package day3;

public class Children extends Father{

    static {
        System.out.println("Child靜態模組");
    }

    public Children(){
        System.out.println("Child 無參建構函式");
        super.sleep();
    }

    public void sleep(){
        System.out.println("Child sleep方法");
    }

}

SuperTest類

package day3;

public class SuperTest {
    public static void main(String [] args){
        new Children().sleep();
    }
}

6.抽象

　　需求：動物都有年齡和名稱，但是吃的不⼀樣，⽺吃草，⽼⻁吃⾁，但是都是閉著眼睛睡覺的

　　　　 ⻋，都有名稱和價格，也有跑的⽅法，但是最⾼速度或者動⼒來源不⼀樣

　　當⽗類的某些⽅法不確定時，可以⽤abstract關鍵字來修飾該⽅法，即抽象⽅法，⽤abstract 來修飾該類，即抽象類

　　抽象類將事物的共性的東⻄提取出來，由⼦類繼承去實現，程式碼易擴充套件、易維護

　　java中的抽象類和抽象⽅法

//抽象類
abstract class 類名{
}
//抽象⽅法，不能有⽅法主體
abstract 返回型別 ⽅法名();

Vehicle類

package day4;

public abstract class Vehicle {

    public abstract void run();

    public void stop(){
        System.out.println("停在路上");
    }
}

Bicycle類

package day4;

public class Bicycle extends Vehicle{

    @Override
    public void run() {
        System.out.println("人力驅動");
    }
}

Auto類

package day4;

public class Auto extends Vehicle {

    @Override
    public void run() {
        System.out.println("汽油驅動");
    }
}

AbstractTest類

package day4;

public class AbstractTest {

    public static void main(String [] args){
        Bicycle bicycle = new Bicycle();
        Auto auto = new Auto();

        bicycle.run();
        bicycle.stop();

        auto.run();
        auto.stop();

//        不能 new 抽象類
//        new Vehicle();
    }
}

抽象特點：

　　抽象類的特點

　　　　抽象類不能被例項化，因為抽象類中⽅法未具體化，這是⼀種不完整的類，所以不能直 接例項化，編譯⽆法通過

　　　　抽象類中不⼀定包含抽象⽅法，但是有抽象⽅法的類必定是抽象類

　　　　如果⼀個抽象類中可以沒有抽象⽅法，這樣做的⽬的是為了此類不能被例項化。

　　　　抽象類的⼦類必須給出抽象類中的抽象⽅法的具體實現，否則⼦類也是抽象類，需要⽤ abstract宣告

　　　　抽象類不能使⽤final關鍵字修飾，因為final修飾的類是⽆法被繼承

　　抽象⽅法的特點

　　　　抽象類中的抽象⽅法只是宣告，不包含⽅法體

　　　　抽象⽅法不能⽤private修飾，因為抽象⽅法必須被⼦類實現（覆寫），⽽private許可權 對於⼦類來 說是不能訪問的

　　　　⼀個類繼承了⼀個抽象類，那麼它必須全部覆寫抽象類中的抽象⽅法，當然也可以不全 部覆寫，如果 不覆寫全部抽象⽅法則這個⼦類也必須是抽象類

　　構造⽅法，類⽅法（即static 修飾的⽅法）不能宣告為抽象⽅法

7.介面

　　是抽象⽅法的集合，接⼝通常以interface來宣告，⼀個類通過繼承接⼝的⽅式，從⽽來繼承 接⼝的抽象⽅法

　　語法

interface 名稱 [extends 其他的接⼝名] {
 // 宣告變數
 // 抽象⽅法
 int getMoney();
}

接⼝的特點

　　接⼝的⽅法都是抽象⽅法，預設都是 public abstract，其他修飾符都會報錯

　　接⼝中可以含有變數，但是接⼝中的變數會被隱式的指定為 **public static final**

　　類描述物件的屬性和⽅法，⽽接⼝則包含類要實現的⽅法

　　接⼝⽆法被例項化，需要被實現才⾏

　　⼀個實現接⼝的類，必須實現接⼝內所描述的所有⽅法，否則就必須宣告為抽象類

接⼝和類的區別

　　接⼝沒有建構函式

　　接⼝⾥可以有靜態⽅法和⽅法體

　　接⼝中所有的⽅法必須是抽象⽅法（JDK8之後就不是）

　　接⼝不是被類繼承了，⽽是要被類實現

　　接⼝⽀持多繼承, 類不⽀持多個類繼承

接⼝的實現implements

　　當類實現接⼝的時候，類要實現接⼝中所有的⽅法，不然類必須宣告為抽象的類，使⽤ implements關鍵字實現所有接⼝

語法

class 類名 implements 接⼝名稱[, 其他接⼝名稱, 其他接⼝名稱]{
 //要實現的⽅法
}

注意

　　⼀個類只能繼承⼀個類，但是能實現多個接⼝

　　接⼝能繼承另⼀個接⼝，接⼝的繼承使⽤extends關鍵字，和類繼承⼀樣

JDK8新特性

　　interface中可以有static⽅法，但必須有⽅法實現體，該⽅法只屬於該接⼝，接⼝名直接調⽤ 該⽅法

　　接⼝中新增default關鍵字修飾的⽅法，default⽅法只能定義在接⼝中，可以在⼦類或⼦接⼝ 中被重寫

　　default定義的⽅法必須有⽅法體

　　⽗接⼝的default⽅法如果在⼦接⼝或⼦類被重寫，那麼⼦接⼝實現物件、⼦類物件，調⽤該 ⽅法，以重寫為準

　　本類、接⼝如果沒有重寫⽗類（即接⼝）的default⽅法，則在調⽤default⽅法時，使⽤⽗類 定義的default⽅法邏輯

IPay類

package day4;

public interface IPay {

//    static 修飾符定義靜態方法
    static void staticMethod() {
        System.out.println("介面中的靜態方法");
    }

//    default 修飾符定義預設方法，預設方法不是抽象方法，可以重寫也可以不重寫
    default void defaultMethod() {
        System.out.println("介面中的預設方法");
    }
}

Alipay類

package day4;

public class Alipay implements IPay {

    @Override
    public void defaultMethod() {
        System.out.println("重寫後的方法");
    }
}

interfaceTest類

package day4;

public class interfaceTest {

    public static void main(String [] args){

        IPay.staticMethod();
        Alipay alipay = new Alipay();
        alipay.defaultMethod();
    }
}

8.面向物件程式設計之InstanceOf關鍵詞和多型

InstanceOf 關鍵詞：是Java的⼀個⼆元操作符（運算子）,也是Java的保留關鍵字

作用：判斷⼀個類是否實現了某個接⼝，或者判斷⼀個例項物件是否屬於⼀個類

語法

//如果該object 是該class的⼀個例項，那麼返回true。如果該object 不是該class的⼀個例項，或者object是null，則返回false

boolean result = object instanceof class

引數：
　　result ：boolean型別。
　　object ：必選項。任意物件表示式。
　　class：必選項。任意已定義的物件類。

物件型別強制轉換前的判斷

Person p1 = new Student();
//判斷物件p是否為Student類的例項
if(1p instanceof Student)
{
 //向下轉型
 Student s = (Student)p1;
}

⽅法重寫和過載

⽅法重寫 overriede:⼦類對⽗類的允許訪問的⽅法的實現過程進⾏重新編寫,

注意點

　　返回值和形參都不能改變

　　⽗類的成員⽅法只能被它的⼦類重寫

　　final 和 static的⽅法不能被重寫

　　構造⽅法不能被重寫

　　訪問許可權不能⽐⽗類中被重寫的⽅法的訪問許可權更低

⽅法過載 overload

　　⼀個類⾥⾯，⽅法名字相同但引數不同，返回型別可以相同也可以不同

　　⽐如建構函式過載

注意核⼼區分

override是在不同類之間的⾏為，overload是在同⼀個類中的⾏為

總結：Java多型

　　同⼀個⾏為具有多個不同表現形式或形態的能⼒

常⻅的⽅式：繼承⽅法重寫、同類⽅法過載、抽象⽅法、接⼝

10.寫個計算器，能完成加減乘除運算

　　定義接⼝做引數

　　加減乘除定義4個類

　　定義⼀個靜態⼯具類，把下⾯的接⼝作為其中⼀個形參物件，傳遞具體的運算子類完成計算

ICompute類

package day4;

//計算機介面
public interface ICompute {
    /**
     * 通過傳遞兩個引數，完成傳遞
     * @param num1
     * @param num2
     * @return
     */
    int computer(int num1, int num2);
}

AddOper類

package day4;

public class AddOper implements ICompute {
    @Override
    public int computer(int num1, int num2) {
        return num1 + num2;
    }
}

SubOper類

package day4;

public class SubOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        return num1 - num2;
    }
}

MulOper類

package day4;

public class MulOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        return num1*num2;
    }
}

DeviceOper類

package day4;

public class DeviceOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        try {
            return num1/num2;
        }catch (Exception e){
            e.printStackTrace();
        }
        return -1;
    }
}

UseComputer類

package day4;

public class UseComputer {

    public static void computer(ICompute compute, int num1, int num2){
        int result = compute.computer(num1, num2);
        System.out.println(result);
    }
    public static void main(String [] args){
        UseComputer.computer(new AddOper(),25,5);
        UseComputer.computer(new SubOper(),25,5);
        UseComputer.computer(new MulOper(),25,5);
        UseComputer.computer(new DeviceOper(),25,0);
    }

}