分散式物聯網邊緣計算服務設計與實現

阿新 • • 發佈：2020-11-21

1.初始面向物件

1.1面向物件&&面向過程

面向過程
- 步驟清晰簡單，第一步做什麼，第二部做什麼……
- 面向過程適合處理一些較為簡單的問題

睡覺：上床，蓋被子，睡覺

面向物件思想
- 物以類聚，分類的思維模式，思考問題首先會解決問題需要哪些分類，然後對這些分類進行單獨思考。最後，再對某個分類下的細節進行面向過程的思索。
- 面向物件適合處理複雜的問題，是和處理需要多人協作的問題！

人---->睡覺

對於面熟複雜的事物，為了從巨集觀上把握、從整體上合理分析，我們需要使用面向物件的思路來分析整個系統。但是，具體到微觀操作，仍然需要面向過程的思路去處理。

1.2面向物件程式設計（Object-Oriented Programming，OOP）

本質：以類的方式組織程式碼，以物件的組織（封裝）資料
一個比較抽象的概念
三大特性：
- 封裝
- 繼承
- 多型
從認知的角度考慮，是先有物件後有類。物件，是具體的事物；類是抽象的，對物件的抽象。
從程式碼執行角度考慮，現有類後有物件。**類是物件的模板**

2.方法回顧及加深

方法的定義

修飾符
- public
- static
- ……
返回型別

與返回值相對應
break 與 return的區別
- break：跳出switch迴圈，結束迴圈
- return 結束方法，返回一個返回值
方法名：注意規範即可！駝峰命名法！見名知意！
引數列表

引數型別，引數名。（可變引數）
異常丟擲

方法的呼叫

靜態方法：static
非靜態方法
形參和實參

形式引數和實際引數的型別要相互隊形
值傳遞和引用傳遞

Java是值傳遞

public class Demo01 {
    public static void main(String[] args) {
        int x = 1;
        System.out.println(x);//1
        //java為值傳遞，將x傳入函式中後，當前的x為10，當呼叫方法完之後，還是原來的值
        //只是將10這個值丟給x了，並沒有改變x的值
        change(x);
        System.out.println(x);//1
    }
    public static void change(int a){
        a = 10;
    }
}

引用呼叫傳遞

//引用傳遞： 傳遞一個引用型別即例項物件
public class Demo02 {
    public static void main(String[] args) {
        Student stu = new Student();
        change1(stu);
        System.out.println(stu.name);
    }
    public static void change1(Student stu){
        stu.name = "dog";
    }
}
class Student{
    public String name;
}

this關鍵字

可以再當前物件裡呼叫當前這個物件的方法及屬性

3.物件的建立分析

類是一種抽象的資料型別，它是對某一類事物整體描述/定義，但是並不能代表某一個具體的事物
物件是抽象概念的具體例項
- eg：張三就是人的一個具體例項，張三家裡的旺財就是狗的一個具體例項
- 能夠體現出特點，展現出功能的是具體的例項
使用new關鍵字建立物件
使用new關鍵字建立的時候，除了分配記憶體空間之外，還會給建立好的物件，進行預設的初始化以及對類中構造器的呼叫
構造器
1. 必須和類的名字相同
2. 必須沒有返回型別，也不能寫void
作用
1. new的過程，實質是再呼叫構造方法
2. 初始化物件的值
注意點
定義有參構造之後，如果想使用午餐構造，顯示的定義一個無參的構造

小結

類與物件
- 類是一個模板：類是一個抽象的
- 物件是類的一個例項，將類具體化
方法
- 掌握定義和呼叫
對應的引用
- 引用型別；基本型別（8種）
- 物件都是引用型別
- 物件是通過引用來操作的：棧-->堆
- 類的屬性(欄位，成員變數)
  - 預設初始化
    - 數字：0，0.0
    - char： u0000
    - boolean：false
    - 引用： null
  - 修飾符屬性
物件的建立和使用
- 必須使用new關鍵字創造物件，構造器。Person teacher = new Person（）；
- 物件的屬性 teacher.name;
- 物件的方法：teacher.sleep;
類：
- 靜態的屬性屬性
- 動態的行為方法
- 每個類都只有方法和屬性！！！

4.面向物件三大特性

封裝、繼承、多型

4.1封裝

高內聚，低耦合
- 高內聚：一個方法儘可能做一件事，並且可以最大化複用
- 低耦合：方法與方法之間，模組模組之間之間儘量不要相互影響
封裝實現的是資料的隱藏
- 通常禁止直接訪問一個物件的資料的實際表示，而應該通過操作介面來訪問，為資訊的隱藏
屬性私有，通過get/set去訪問屬性
作用：
1. 提高程式的安全性，保護資料
2. 隱藏程式碼的實現細節
3. 統一介面（get/set）
4. 系統可維護增加

4.2繼承

Java中類的繼承只有單繼承，沒有多繼承！！！一個兒子只有一個爸爸！一個爸爸可以有多個兒子！！！

子類即是父類

object類

它是Java中所有類的根類，祖先！

所有的類都預設直接或者間接繼承了object類
super
- 呼叫父類的一些屬性或者方法。私有屬性和方法無法被呼叫！！！
- 子類的構造方法預設第一步執行父類的無參構造方法。且必須放在子類的第一行！！！父類如果沒有無參構造方法，必須呼叫父類的有參構造方法！！！
- super只能出現在子類的方法或者後遭方法中
VS this
1. 代表的物件不同
  - this代表當前物件
  - super代表父類物件
2. 前提
  - this 沒有繼承也可以使用
  - super只有在繼承條件下才可以使用
3. 構造方法
  - this() 本類的構造
  - super() 父類的構造

//父類

public class Person {
    private String name;

    public Person(String name){
        this.name = name;
    }
}

//子類
public class Student extends Person{
    private int age;
    public Student(int age){
        this.age = age;
    }
}

方法重寫

必須要有繼承關係！方法名相同，引數列表相同，方法體不一樣

靜態方法和非靜態方法重寫有很大區別

//A繼承B
A a = new A();
B b = new A();
/*  
    靜態方法：呼叫方法只和左邊的物件有關
    非靜態方法：呼叫方法只和右邊的物件有關
*/

修飾符：範圍可以擴大，但不能縮小
丟擲的異常：範圍可以被縮小但是不能被擴大
意義：

父類的功能子類不一定需要，或者不一定滿足

4.3多型

概念：同一個方法可以根據傳送物件的不同而採用多種不同的行為方式
一個物件的實際型別是確定的，但是可以指向物件的引用的型別有很多

//實際型別均為Student  指向的引用型別卻一個為Student一個為Person
Person person = new Student();
Student student = new Student();
//Student繼承了Person且Student重寫了Person的run方法
person.run();
student.run();
//均為呼叫子類student的方法
//物件能執行哪些方法，主要看物件左邊的型別，和右邊關係不太大，優先執行子類重寫的方法

子類呼叫的方法都是自己的或者繼承父類的！
父類可以指向子類，但是不能呼叫子類獨有的方法！即可以呼叫子類重寫的方法
注意事項
1. 多型是方法的多型，屬性沒有多型
2. 父類和子類，有聯絡，可以型別轉換。毫無關係的兩個物件型別轉換會報錯：ClassCastException
3. 存在條件：繼承關係，方法需要重寫，父類引用型別指向子類。
4. 有些方法不能被重寫
  1. static方法屬於類，不屬於例項
  2. final 常量；
  3. private方法私有！

4.4instanceof 和型別轉換

instanceof

判斷一個物件是什麼型別

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

System.out.println("s1 instance Student");//true
System.out.println("s2 instance Teacher");//編譯報錯
System.out.println("s1 instance Person");//true
System.out.println("s1 instance Object");//true
System.out.println("s3 instance String");//編譯報錯
System.out.println("==================");
System.out.println("s2 instance Student");//true
System.out.println("s2 instance Teacher");//false
System.out.println("s2 instance Person");//true
System.out.println("s2 instance Object");//true
System.out.println("s3 instance String");//編譯報錯
System.out.println("==================");
System.out.println("s3 instance Student");//true
System.out.println("s3 instance Teacher");//false
System.out.println("s3 instance Person");//true
System.out.println("s3 instance Object");//true
System.out.println("s3 instance String");//false

型別轉換
1. 父類引用指向子類的物件
2. 把子類轉換為父類，向上轉型；自動
3. 把父類轉換為子類，向下轉型；強制轉換
4. 方便方法的呼叫，減少重複的程式碼！
詳解static方法
- 靜態程式碼塊：只執行一次！！！
- 匿名程式碼塊：賦初值

public class Person{
    {
        System.out.println("匿名程式碼塊")
    }
    static{
        System.out.println("靜態程式碼塊")
    }
    public Person(){
        System.out.println("構造方法")
    }
    public static void main(String[] args){
        Person p1 = new Person();
        System.out.println("=====================")
        Person p2 = new Person();
    }
}

輸出結果：

ps:靜態匯入包~

import static java.lang.Math.random;
import static java.lang.Math.PI;
//可以直接使用PI 和random()函式

5.抽象類和介面

抽象類
- abstract關鍵字實現
  - 可以寫抽象方法和普通方法
  - 被繼承的類必須要實現它的所有抽象方法
介面
- interface
  - 介面的方法只會有抽象方法和靜態方法
  - 方法名預設有public、abstract修飾
  - 屬性會有預設的public,static,final修飾
  - 介面側面實現了java的多繼承！！！

6.內部類

成員內部類
區域性內部類
靜態內部類
匿名內部類

public class User {
    private String name;
    private int ID;

    //成員內部類
    public class Uesr_son{
        public void getName()
        {
            System.out.println(name);
        }
    }

    //區域性內部類
    public void run(){
        class User_son{

        }
    }

    //靜態內部類
    static class USer_son{

    }

    public static void main(String[] args) {
        new User().run();//匿名內部類
        User user = new User();
        Uesr_son son = user.new Uesr_son();//創造成員內部類的例項

    }
}