認識對象

時間 2019-11-13

標籤認識對象简体版

原文原文鏈接

文章目錄

1、面向對象的編程基礎

1.1 程序（program）

1.1.1 理解程序
1.1.2 程序!=天然語言
1.1.3 人與計算機的對話
1.1.4 程序分類
1.1.5 程序內容
1.1.6 程序編寫原則
1.1.7 程序執行過程

1.2 程序設計語言

1.2.1 程序設計語言發展階段

1.2.1.1高級語言
1.2.1.2 腳本語言
1.2.1.3 語言區別和聯繫

1.2.2 面向機器語言—low level language

1.2.2.1 機器語言
1.2.2.2 彙編語言

1.2.3 面向過程語言—high level language
1.2.4 面向對象編程—high level language

1.3 理解面向對象

1.3.1 面向對象（Object Oriented）
1.3.3 案例：敬老院的奶奶們
1.3.4 案例：小汽車
1.3.5 面向對象的設計思路
1.3.6 案例：飼養動物
1.3.7 案例：把大象裝進冰箱

1.4 面向對象與面向過程設計思路的對比

1.4.1 案例：製做年夜飯
1.4.2 案例：定義窗體

1.5 認識Java

1.5.1 Java語言的發展
1.5.2 Java關鍵字
1.5.3 Java標識符

1.5.3.1 標識符
1.5.3.2 用戶自定義標識符應該知足的條件
1.5.3.3 Java程序設計中涉及的標識符

1.5.4 Java語言數據類型

1.5.4.1 數制
1.5.4.2 數據類型
1.5.4.3 內存如何存放數據

2、封裝數據爲類

2.1 從對象抽象出「類」

2.1.1 案例：職員
2.1.2 抽象步驟
2.1.3 深化理解對象

2.1.3.1 平常生活中的對象
2.1.3.2 程序中建立對象
2.1.3.3 匿名對象

2.1.4 深化理解類
2.1.5 案例：小王減秤
2.1.6 類與對象的關係
2.1.7 深化理解抽象
2.1.8 案例：學生
2.1.9 如何理解消息
2.1.10 類的設計原則
2.1.11 屬性和方法

2.1.11.1 屬性和方法闡述
2.1.11.2 屬性
2.1.11.3 方法
2.1.11.4 實例

2.1.12 案例：組裝電腦

2.2 類間關係

2.2.1五種類間關係

2.2.1.1 關聯關係(Association)
2.2.1.2 依賴關係(Dependency)
2.2.1.3 彙集關係(Aggregation)
2.2.1.4 泛化關係(Generalization)
2.2.1.5 實現關係(Realization)

2.2.2 案例：客戶和訂單的關聯關係
2.2.3 案例：狗逮耗子的依賴關係
2.2.4 思考題

2.3 類的設計

2.3.1 類的設計原則
2.3.2 源文件基本結構
2.3.3 定義類

2.3.3.1 定義一個類的步驟
2.3.3.2 類的定義格式
2.3.3.3 類的定義說明

2.3.4 符號

2.3.4.1 訪問控制符
2.3.4.2 類型說明符

2.3.5 成員變量的定義
2.3.6 成員方法的定義

2.3.6.1 方法的定義格式
2.3.6.2 成員方法的定義說明

2.4 特殊點強調

2.4.1 案例：return的理解
2.4.2 案例：toString()方法
2.4.3 案例：教育機構

2.5 類的訪問機制

2.5.1 this關鍵字

2.6 基本類型和引用類型做

2.6.1 基本數據類型做爲參數傳遞（深拷貝）
2.6.2 引用數據類型做爲參數傳遞（淺拷貝）
2.6.3 進一步理解引用類型變量

2.7 方法的重載

2.7.1 生活中的方法重載
2.7.2 Java中的方法重載
2.7.3 構造函數方法重載

2.7.3.1 構造方法
2.7.3.2 構造方法重載
2.7.3.3 案例：教育機構
2.7.3.4 不帶參數構造方法（默認構造方法）
2.7.3.5 帶參數構造方法
2.7.3.6 構造函數實例化類對象的格式
2.7.3.7 辨別構造方法

2.8 局部變量和成員變量

2.8.1 案例：person
2.8.2 區別
2.8.3 案例：對象的內存圖解

2.9 內存管理

2.9.1 內存管理的兩種方法
2.9.2 JAVA內存管理

2.9.2.1 垃圾自動回收機制
2.9.2.2 Java內存強制回收

2.10 類的靜態屬性和靜態方法

2.10.1 程序運行時的內存佔用
2.10.2 回答問題
2.10.3 Static的使用場合
2.10.4 案例：統計出從Person共new出多少個對象
2.10.5 案例：TestStudent.java
2.10.6 回答問題
2.10.7 靜態代碼塊與非靜態代碼塊的異同點
2.10.8 案例：初始化順序

2.11 總結

1、面向對象的編程基礎

1.1 程序（program）

1.1.1 理解程序

A program is a sequence of instructions that specifies how to perform a computation. 程序是一系列的指令，來告訴計算機如何進行運算java

程序是爲實現特定目標或解決特定問題而用計算機語言編寫的命令序列的集合。它由序列組成，告訴計算機如何完成一個具體的任務，是軟件開發人員根據用戶需求開發的、用程序設計語言描述的適合計算機執行的指令（語句）序列。android

1.1.2 程序!=天然語言

程序不是天然語言，天然語言存在歧義，而程序中不能存在歧義。因爲如今的計算機還不能理解人類的天然語言，因此還不能用天然語言編寫計算機程序。ios

1.1.3 人與計算機的對話

人與計算機的對話方式能夠分爲三種：程序員

人學習計算機的語言：機器語言
計算機學習人的語言：天然語言
學習第三方語言：高級程序設計語言

一般意義上的程序是由高級語言編寫的爲進行某活動或過程所規定的途徑。算法

1.1.4 程序分類

通常分爲系統程序和應用程序兩大類：編程

系統軟件：
用於實現計算機系統的管理、調度、監視和服務等功能，其目的是方便用戶，提升計算機使用效率，擴充系統的功能。
應用軟件：
針對用戶的須要，爲解決各類實際問題而編制的計算機應用程序。

1.1.5 程序內容

對數據的描述：
在程序中要指定數據的類型和數據的組織形式，即數據結構（data structure）。
對操做的描述：
即操做步驟，也就是算法（algorithm）或者行爲。

實際上，一個程序除子以上兩個主要的要素外，還應當來用程序設計方法進行設計，而且用一種計算機語言來表示。windows

1.1.6 程序編寫原則

低耦合，可維護
可擴展，可伸縮
可複用
安全性

1.1.7 程序執行過程

編寫、編譯、上載、運行數組

1.2 程序設計語言

1.2.1 程序設計語言發展階段

面向機器語言面向過程語言面嚮對象語言腳本語言安全

1.2.1.1高級語言

C、C++、Java、C#、Basic、Pascal…網絡

1.2.1.2 腳本語言

JavaScript、Python、Ruby、PHP、Asp.Net、Perl、.…

1.2.1.3 語言區別和聯繫

C/C++、Java、.Net（C）以及其它語言
C/C++：程序性能高、支持底層應用·主要用於系統級軟件、資源受限環境軟件
- 典型應用：通用軟件、主機遊戲、與硬件相關底層應用等
Java：跨平臺，更好的互操做性，主要用於太規模企業級應用軟件，隨着硬件的發展，其跨平臺的特性使得其在嵌大式領域（如手機軟件應用也日益普遍
- 典型應用：電信、銀行等行業管理信息系統、Android應用、人工智能、大數據分析
.Net：開發、部署效率高，成本低。主要用於中小規模企業級應用軟件
- 典型應用：部門級信息系統、桌面應用軟件
ios平臺上的語言：Objective-C、Swift
其它腳本語言也有其應用環境，如PHP、Python、Js等結論
C結構體，C++結構體和 C++類的區別及聯繫
- 區別：
  C的結構體不能添加成員函數，不能繼承和派生；
  C++的結構體和類，都能添加成員函數，可以繼承和派生，具備多態性；
  C++的結構體和類的區別僅僅是默認狀況下外部對類成員的訪問權限的不一樣，結構體默認是pubilc，C++中類默認是private；
- 聯繫：
  結構體也能夠被認爲是一種特殊的類，它不存在在何函數，構造和析構函數也沒有，並且是一個公共的類
C語言、C++和Java對比
C是面向過程的語言。C++和Java都是面向對象的。在C中沒有類或者對象的概念，C中對包含複雜屬性的主體採用struct封裝；
Java和C++都是面嚮對象語言，C++兼容C，並且對C中的結構體作了擴展，可是Java中完全拋棄了struct的概念；
Java和C++程序的共同點都須要抽象出類，都具備封裝、繼承和多態的三大特徵；
C和C++主要用在在中間件和底層，Java主要用在應用層，Java更注重於面向對象的思想（爲了徹底面向對象，能夠適當的犧牲效率），而C++更注重於效率（爲了更好的效率，能夠適當的犧牲面向對象），因此C++相比Java在語法上更復雜一些。

1.2.2 面向機器語言—low level language

1.2.2.1 機器語言

使用高低電壓來表示0和1兩種狀態，這樣計算機就可使用二進制數來存儲和處理信息了
機器語言直接由計算機的指令組成，能夠被計算機直接執行

1.2.2.2 彙編語言

使用一些簡單的容易記憶的符號來代替二進制指令，比機器語言更容易讀懂，更容易編寫
彙編語言抽象層次很低，程序員須要考慮大量的機器細節。
機器語言與彙編語言都是面向機器的語言，須要針對不一樣的硬件環境編寫不一樣的代碼，所以這兩種語言被稱爲低級語言

1.2.3 面向過程語言—high level language

隨着計算機硬件功能的提升，在20世紀60年代出現了面向過程的程序設計語言，如C語言和Fortran語言
面向過程的語言比低級語言更加接近人類的天然語言，所以被稱爲高級語言
使用面向過程的程序設計語言，不用再考慮機器指令的細節，只須要按照語言的語法規則去編寫代碼
面向過程的程序由若干個過程或函數模塊組成，每一個模塊的目標就是完成某一個任務
由於計算機只能識別0、1代碼，所以使用高級語言編寫的程序須要經過某種機制將其轉變成機器碼，計算機才能識別
將高級語言編寫的源文件轉化成機器碼一般有兩種方式：編譯方式和解釋方式
（1）編譯方式（Compilation）
針對當前的處理器，將源文件所有翻譯成機器指令，稱爲目標程序，再將目標程序交給計算機執行
（2）解釋方式（Interpretation）
此種方式並不產生整個的目標程序，而是根據當前的處理器，邊解釋邊執行，解釋一句，執行一句

不管哪一種高級語言，都必須提供相應的編譯器或者解釋器
Java語言編寫的程序使用的是編譯與解釋相結合的方式來運行的
JVW中提供的JIT（即時編譯方式）將字節碼直接轉化成高性能的本地機器碼，即JIT使得Java程序既能跨平臺又能高速運行

1.2.4 面向對象編程—high level language

隨着計算機硬件設備功能的進一步提升，使得面向對象的編程成爲可能。
面向對象的基本思想是，從現實世界中客觀存在的事物出發來構造軟件系統，並在系統的構造中儘量運用人類的天然思惟方式。
面向對象更加符合人的思惟模式，編寫的程序更加健壯和強大，也可以解決更加複雜的問題，而且面向對象編程鼓勵創造性的程序設計。

1.3 理解面向對象

1.3.1 面向對象（Object Oriented）

面向對象是一種軟件開發方法
-面向對象的分析與設計（00A&00D）是用客觀世界中描述事物的方法，來描述程序中要解決的問題
萬物皆對象（萬事萬物，都是對象）
程序即是成堆的對象，彼此經過消息傳遞，請求其餘對象進行工做

第一個面向對象的語言：Simula-67
第一個成功的面向對象的語言：Smalltalk
目前主流面向對象的語言：C++，JAVA，C#

1.3.3 案例：敬老院的奶奶們

1.3.4 案例：小汽車

現實生活中的對象（對現實世界創建對象模型）

計算機中的對象原型

class Car {
     String color;
     String brand;
     String model;
     int door_number;
     int speed;
     
    void brake() { … }
    void speedUp() {…};
    void slowDown() { …  } 
}

View Code

類是對象共性的的描述，包括屬性和行爲

若是將對象比做汽車，那麼類就是汽車的設計圖紙。因此面向對象程序設計的重點是類的設計，而不是對象的設計。

1.3.5 面向對象的設計思路

面向對象的基本思想是：從現實世界中客觀存在的事物出發來構造軟件系統，並在系統的構造中儘量運用人類的天然思惟方式。
面向對象更增強調運用人類在平常生活的邏輯思惟中常常採用的思想方法與原則，如抽象、芬類，森承、聚谷、多態等。
人在思考的時候，首先眼睛裏看到的是一個一個的對象。
旨在在計算機程序中模擬現實世界中的概念，在 OOP 中，現實世界的全部事物全都被視爲對象，可以在計算機程序中用相似的實體模擬現實世界中的實體，設計和實現軟件系統的方法。

面向對象實際上是現實世界模型的天然延伸。現實世界中任何實體均可以看做是對象，都歸結爲某一類事物，都是某一類事件的實例。萬物對象程序由類組成：對相同類型的對象進行分類、抽象後，得出共同的特性而造成了類。例如Student Teacher和Person類。
將數據及對數據的操做行爲放在一塊兒，做爲一個相互依存、不可分割的總體——對象。對象是細粒度的。
對象之間經過消息（方法）相互做用，完成系統功能。

1.3.6 案例：飼養動物

設計應用程序，模擬現實世界中，動物園裏飼養員餵養動物的場景

Animal類
Animal子類Dog類
Animal子類Cat類

食物Food類
Food類子類Bone
Food類子類Fish

飼養員Feeder類

測試類

1.3.7 案例：把大象裝進冰箱

步驟：打開冰箱；將大象裝進去；關閉冰箱

一、先按照名詞提煉問題領域中的對象
二、對對象進行描述，明確對象中應該具有的屬性和功能，抽象出類，設計類，編寫類
三、經過new的方式能夠建立該事物的具體對象
四、經過該對象調用它之後的功能。

package 把大象裝進冰箱;

/**
 * 大象類
 *
 * @author gwr
 * @date 2019-06-04 21:12
 */
public class Elephant {
    private double weight;
    private double height;
    private char sex;

    public Elephant() {};

    public Elephant(double weight, double height, char sex) {
        this.weight = weight;
        this.height = height;
        this.sex = sex;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Elephant{" +
                "weight=" + weight +
                ", height=" + height +
                ", sex=" + sex +
                '}';
    }
}

View Code

package 把大象裝進冰箱;

/**
 * 冰箱類
 *
 * @author gwr
 * @date 2019-06-04 21:15
 */
public class Refrigerator {
    private double brand;
    private String model;
    private String color;

    public Refrigerator(){}

    public Refrigerator(double brand, String model, String color) {
        this.brand = brand;
        this.model = model;
        this.color = color;
    }

    void open() {
        System.out.println("打開冰箱");
    }

    void in(Elephant e) {
        System.out.println("儲存大象");
    }

    void close() {
        System.out.println("關閉冰箱");
    }
}

package 把大象裝進冰箱;

/**
 * 測試冰箱成大象
 *
 * @author gwr
 * @date 2019-06-04 21:41
 */
public class EleRefTest {
    public static void main(String[] args) {
        Elephant e = new Elephant();
        Refrigerator r = new Refrigerator();
        r.open();
        r.in(e);
        r.close();
    }
}

View Code

程序輸出

打開冰箱
儲存大象
關閉冰箱

1.4 面向對象與面向過程設計思路的對比

面向對象和麪向過程的思想有着本質上的區別

面向過程的思惟：
肯定第一步先作什麼，第二步作什麼，第三步作什麼。。。自頂向下的功能分解法
面向對象的思惟：
- 第一步：明確問題域，分析這個問題裏面有哪些類和對象
- 第二步：分析這些類和對象應該具備哪些屬性和方法。
- 第三步：分析類和類之間具體有什麼關係。

「面向過程」是一種以過程爲中心的編程思想，強調的是功能行爲。
「面向過程」只是分析出解決問題所須要的步驟，而後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就能夠了。面向過程在這一系列工做的執行中，強調的是工做的執行。「面向過程」不支持豐富的「面向對象」特性（好比繼承、多態）

面向對象更加劇視軟件的可維護，可擴展，可複用等特性。
面向對象編程的三個特性

封裝
面向對象編程的核心思想就是將數據和數據的操做封裝在一塊兒，經過抽象，即從具體的實例中抽取共同的性質造成通常的概念，好比類的概念
繼承
多態
- 一種是操做名稱的多態，即方法的重載。
- 另外一種是指同一個操做被不一樣對象調用時可能產生不一樣的行爲。

面向對象的核心思想和概念包括：抽象、封裝、接口、多態和繼承，靈活運用這些理論武器，就會使得軟件系統象用積木搭起來的系統同樣，可以方便地進行組裝、拆卸和重用。
運用面向對象思惟來構建可維護、可重用和可擴展的軟件系統

面向對象思惟方式是一種更符合人們思考習慣的思想
面向過程思惟方式中更多的體現的是執行者（本身作事情），面向對象中更多的體現是指揮者（指揮對象作事情）。
面向對象思惟方式將複雜的問題簡單化。

1.4.1 案例：製做年夜飯

面向過程：
作什麼？怎麼作？準備材料，按步驟由本身作

面向對象：

採購員（姑姑）買肉
採購員（媽媽）買菜
採購員（你）買雞蛋和做料
廚師（爸爸）烹飪
廚師（嬸嬸）烤甜品

package 年夜飯;

/**
 * Person類
 *
 * @author gwr
 * @date 2019-06-04 19:02
 */
public abstract class Person {
    private String name;
    private char sex;

    public Person(String name, char sex) {
        super();
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }
}

View Code

package 年夜飯;

/**
 * 採購員類
 *
 * @author gwr
 * @date 2019-06-04 22:08
 */
public class Buyer extends Person {
    private String toBuy;

    public Buyer(String name, char sex, String toBuy) {
        super(name, sex);
        this.toBuy = toBuy;
    }

    public String getToBuy() {
        return toBuy;
    }

    public void setToBuy(String toBuy) {
        this.toBuy = toBuy;
    }

    @Override
    public String toString() {
        return super.toString() +
                "Buyer{" +
                "toBuy='" + toBuy + '\'' +
                '}';
    }
}

View Code

package 年夜飯;

/**
 * 廚師類
 *
 * @author gwr
 * @date 2019-06-04 22:13
 */
public class Cook extends Person {
    private String toCook;

    public Cook(String name, char sex, String toCook) {
        super(name, sex);
        this.toCook = toCook;
    }

    public String getToCook() {
        return toCook;
    }

    public void setToCook(String toCook) {
        this.toCook = toCook;
    }

    @Override
    public String toString() {
        return super.toString() +
                "Cook{" +
                "toCook='" + toCook + '\'' +
                '}';
    }
}

View Code

package 年夜飯;

/**
 * 協同製做年夜飯
 *
 * @author gwr
 * @date 2019-06-04 22:16
 */
public class WorkTogether {
    public static void main(String[] args) {
        Buyer 姑姑 = new Buyer("姑姑", 'F', "買肉");
        Buyer 媽媽 = new Buyer("媽媽", 'F', "買菜");
        Buyer 我 = new Buyer("我", 'F', "買雞蛋和做料");

        Cook 爸爸 = new Cook("爸爸", 'M', "烹飪");
        Cook 嬸嬸 = new Cook("嬸嬸", 'F', "烤甜品");

        System.out.println(姑姑);
        System.out.println(媽媽);
        System.out.println(我);
        System.out.println(爸爸);
        System.out.println(嬸嬸);
    }
}

View Code

程序輸出

Person{name=‘姑姑’, sex=F}Buyer{toBuy=‘買肉’}
Person{name=‘媽媽’, sex=F}Buyer{toBuy=‘買菜’}
Person{name=‘我’, sex=F}Buyer{toBuy=‘買雞蛋和做料’}
Person{name=‘爸爸’, sex=M}Cook{toCook=‘烹飪’}
Person{name=‘嬸嬸’, sex=F}Cook{toCook=‘烤甜品’}

1.4.2 案例：定義窗體

面向過程（C）
在一個結構體中定義窗口的大小，位置，顏色，背景等屬性·對窗口操做的函數與窗口自己的定義沒有任何尖系，如HideWindow·MoveWindow，MinimizeWindow.這些函數都須要接受一個表明要被操做的窗口參數，是一種謂語與賓語的尖系。

面向對象（Java andC++）（Window.java）
定義窗口時，除了要指定在面向過程當中規定的那些屬性，如大小，位置，顏色，背景等外，還要指定該窗口可能具備的動做，如隱藏，移動，最小化等。這些函數被調用時，都是以某個窗口要隱藏，某個窗口要移動的語法格式來使用的·這是一種主語與謂語的關係。

Java中全部的數據和函數都隸屬於類（記得別忘了寫main函數）

/**
 * 窗口類
 *
 * @author gwr
 * @date 2019-06-03 21:58
 */
public class Window {
    /**
     * 定義窗口屬性：
     *
     * 大小，位置，顏色，背景
     */
    private int size;
    private int x;
    private int y;
    private String color;
    private String background;

    /**
     * 定義窗口方法
     */
    public void windowMove() {
        System.out.println("moving");
    }

    public void windowsHide() {
        System.out.println("hideing");
    }

    public static void main(String[] args) {
        //TODO Auto-generated method stub
        Window androidWindow = new Window();
        Window macWindow = new Window();
        androidWindow.windowMove();
        androidWindow.windowsHide();
        macWindow.windowMove();
        macWindow.windowsHide();
    }
}

View Code

程序輸出：

1.5 認識Java

1.5.1 Java語言的發展

Java是一種咖啡的名稱，中文譯名爲爪哇，爲這種新的語言起名爲Java，其寓意是爲世人端上一杯熱咖啡

Java的發展史——JDK版本發展

1996年，Java JDK1.0正式發表；
1996年4月，10個最主要的操做系統供應商申明將在其產品中嵌入JAVA技術；
1996年9月，約8.3萬個網頁應用了JAVA技術來製做；
1999年6月，SUN公司發佈Java的三個版本：標準版、企業版和微型版
2009年04月20日，甲骨文74億美圓收購Sun。取得java的版權。
目前最高版本JDK 1.8

Java2的三個體系

J2SE(Java 2 Software Development Kit, Standard Edition)
J2EE(Java 2 Software Development Kit, Enterprise Edition)
J2ME(Java 2 Software Development Kit, Micro Edition)

2005年，Java 10週年大會正式爲J2SE，J2ME，J2EE從新命名

老版本名稱	新版本名稱
J2SE	Java SE
J2ME	Java ME
J2EE	Java EE

/**
 * helloworld
 *
 * @author gwr
 * @date 2019-06-04 18:20
 */
public class HelloWorld/*public修飾的類的名稱必須與Java文件同名！*/ {
    //main方法四要素必不可少
    public static void main/*main方法時Java程序執行的入口點*/(String[] args) {
        System.out.println("Hello world!");/*從控制檯輸出信息*/
    }/*{和}一一對應，缺一不可*/
}

View Code

1.5.2 Java關鍵字

類別	關鍵字（共53個）	個數
量	true false null this super	5
運算	new instanceof	2
類型	boolean byte char short int long float double void class interface enum	12
控制	if else switch case default for do while continue break return	11
修飾	private protected public abstract static final synchronized stricfp native transient volatile	11
聲明	package import extends implements	4
異常	try catch finally throws throw	5
調試	assert	1
保留	const goto	2

1.5.3 Java標識符

1.5.3.1 標識符

用於識別不一樣實體的由若干符號組成的一個名字
標識符的一個最基本的要求
把組成標識符的符號分紅兩部分
開頭的符號：字母、下劃線、$
其他的符號：字母、下劃線、$、數字
標識符用於類、方法、變量的名字
以名字爲中心，名字通常按照不一樣的主題（包）進行分類管理

1.5.3.2 用戶自定義標識符應該知足的條件

對：知足標識符的最基本要求
好：見名知義
美：遵循風格
注：絕對不能與關鍵字重名；最好不要與系統已定義的標識符重名，以避免產生意想不到的麻煩。

1.5.3.3 Java程序設計中涉及的標識符

項目名：即要開發的系統名，要反映項目的總體

文件名：系統中包含的各類文件，一源文件爲主，用於存儲類的實現代碼。通常由類名肯定（public）

類名（接口、枚舉）：每一個單詞第一個字母大寫，其他字母小寫

對象名：又稱實例名，屬於變量範疇

變量名：用於存儲數據，分爲成員變量和局部變量。成員變量第一個單詞所有小寫，後面與類名風格一致。局部變量採用小寫形式，沒有特殊要求

方法名：又稱函數，實現對數據的操做，參數屬於局部變量，沒有局部方法。通常採用動詞，動賓詞組，名介等形式。

1.5.4 Java語言數據類型

1.5.4.1 數制

十進制、八進制或十六進制數據的表示方法：
以1-9開頭的數爲十進制數
以0開頭的數爲八進制數
以0x開頭的數爲十六進制數

1.5.4.2 數據類型

數據類型

基本數據類型

數值類型

整數類型byte short int long

浮點數類型float double

字符類型char

布爾類型boolean

複合數據類型

類類型

數組

接口類型interface

數據類型轉換：
自動類型轉換
強制類型轉換
Java數據類型類

1.5.4.3 內存如何存放數據

數據各式各樣，要先根據數據的需求（即類型）爲它申請一塊合適的空間

簡單數據類型直接保存在棧中

引用數據類型的內容保存在堆中，指向它的指針值保存在棧中

2、封裝數據爲類

2.1 從對象抽象出「類」

類是模子，是對象的類型，肯定對象將會擁有的特徵（屬性）和行爲（方法）

2.1.1 案例：職員

package object;

/**
 * Person類
 *
 * @author gwr
 * @date 2019-06-04 19:02
 */
public class Person {
    private String name;
    private int id;
    private char sex;
    private int age;

    public Person() {
        super();
        System.out.println("Person類構造函數");
    }

    public Person(String name, int id, char sex, int age) {
        super();
        this.name = name;
        this.id = id;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public int getId() {
        return id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

View Code

package object;

/**
 * 地址類
 *
 * @author gwr
 * @date 2019-06-04 19:05
 */
public class Address {
    private String addName;
    private String addId;
    private String city;
    private String district;

    public Address() {
        super();
        System.out.println("Address類構造函數");
    }

    public Address (String addName, String addId, String city,
                    String district) {
        super();
        this.addName = addName;
        this.addId = addId;
        this.city = city;
        this.district = district;
        System.out.println("Address類構造函數");
    }

    public String getAddName() {
        return addName;
    }

    public void setAddName(String addName) {
        this.addName = addName;
    }

    public String getAddId() {
        return addId;
    }

    public void setAddId(String addId) {
        this.addId = addId;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getDistrict() {
        return district;
    }

    public void setDistrict(String district) {
        this.district = district;
    }

    @Override
    public String toString() {
        return "Address{" +
                "addName='" + addName + '\'' +
                ", addId='" + addId + '\'' +
                ", city='" + city + '\'' +
                ", district='" + district + '\'' +
                '}';
    }
}

View Code

package object;

/**
 * Employee類
 *
 * @author gwr
 * @date 2019-06-04 19:25
 */
public class Employee extends Person {//is
    private double salary;
    private final int workId;
    private static int counter = 0;
    private Address homeAddress;//has
    private Address comAddress;//has

    public Employee() {
        super();
        this.workId = ++counter;
        System.out.println("Employee類構造函數");
    }

    public Employee(String name, int id, char sex, int age) {
        super(name, id, sex, age);
        this.workId = ++counter;
        System.out.println("Employee類構造函數");
    }

    public Employee(String name, int id, char sex, int age, double salary,
                    Address homeAddress, Address comAddress) {
        super(name, id, sex, age);
        this.salary = salary;
        this.workId = ++counter;
        this.homeAddress = homeAddress;
        this.comAddress = comAddress;
        System.out.println("Employee類構造函數");
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getWorkId() {
        return workId;
    }

    public Address getHomeAddress() {
        return homeAddress;
    }

    public void setHomeAddress(Address homeAddress) {
        this.homeAddress = homeAddress;
    }

    public Address getComAddress() {
        return comAddress;
    }

    public void setComAddress(Address comAddress) {
        this.comAddress = comAddress;
    }

    @Override
    public String toString() {
        return super.toString() + "\n" +
                "Employee{" +
                "salary=" + salary +
                ", workId=" + workId +
                ", homeAddress=" + homeAddress +
                ", comAddress=" + comAddress +
                '}';
    }
}

View Code

package object;

/**
 * Manager類
 *
 * @author gwr
 * @date 2019-06-04 19:37
 */
public class Manager extends Employee {
    private String department;

    public Manager () {
        super();
        System.out.println("Manager類構造函數");
    }

    public Manager (String name, int id, char sex, int age, double salary,
                    Address homeAddress, Address comAddress) {
        super(name, id, sex, age, salary, homeAddress, comAddress);
        System.out.println("Manager類構造函數");
    }

    public Manager (String name, int id, char sex, int age, double salary,
                    Address homeAddress, Address comAddress,
                    String department) {
        super(name, id, sex, age, salary, homeAddress, comAddress);
        this.department = department;
        System.out.println("Manager類構造函數");
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return super.toString() + "\n" +
                "Manager{" +
                "department='" + department + '\'' +
                '}';
    }
}

View Code

package object;

/**
 * Deirector類
 *
 * @author gwr
 * @date 2019-06-04 19:39
 */
public class Deirector extends Manager {
    private int carAllowance;

    public Deirector() {
        super();
        System.out.println("Deirector類構造函數");
    }

    public Deirector (String name, int id, char sex, int age, double salary,
                      Address homeAddress, Address comAddress,
                      String department) {
        super(name, id, sex, age, salary, homeAddress, comAddress, department);
        System.out.println("Deirector類構造函數");
    }

    public Deirector (String name, int id, char sex, int age, double salary,
                      Address homeAddress, Address comAddress,
                      String department, int carAllowance) {
        super(name, id, sex, age, salary, homeAddress, comAddress, department);
        this.carAllowance = carAllowance;
        System.out.println("Deirector類構造函數");
    }

    public int getCarAllowance() {
        return carAllowance;
    }

    public void setCarAllowance(int carAllowance) {
        this.carAllowance = carAllowance;
    }

    @Override
    public String toString() {
        return super.toString() + "\n" +
                "Deirector{" +
                "carAllowance=" + carAllowance +
                '}';
    }
}

View Code

package object;

import java.util.ArrayList;

/**
 * Company類
 *
 * @author gwr
 * @date 2019-06-04 19:44
 */
public class Company {
    private int id;
    private String comName;
    private Address address;
    private ArrayList<Employee> employees;

    public Company() {
        super();
        System.out.println("Company類構造函數");
    }

    public Company(int id, String comName, Address address,
                   ArrayList<Employee> employees) {
        super();
        this.id = id;
        this.comName = comName;
        this.address = address;
        this.employees = employees;
        System.out.println("Company類構造函數");
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getComName() {
        return comName;
    }

    public void setComName(String comName) {
        this.comName = comName;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public ArrayList<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(ArrayList<Employee> employees) {
        this.employees = employees;
    }

    @Override
    public String toString() {
        return "Company{" +
                "id=" + id +
                ", comName='" + comName + '\'' +
                ", address=" + address +
                ", employees=" + employees +
                '}';
    }
}

View Code

package object;

import java.util.ArrayList;
import java.util.List;

/**
 * 測試類
 *
 * @author gwr
 * @date 2019-06-04 20:05
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("First:");
        Deirector d = new Deirector();
        System.out.println(d);
        System.out.println("Second:");
        Deirector D = new Deirector("Jack", 1740, '男', 44, 13.14D,
                new Address(), new Address(), "nothing", 0);
        System.out.println(D);
        System.out.println("Third:");
        Company c = new Company();
        System.out.println(c);
        System.out.println("Forth:");
        ArrayList<Employee> l = new ArrayList<>();
        l.add(d);
        l.add(D);
        Company C = new Company(233, "破產集團", new Address(), l);
        System.out.println(C);
    }
}

View Code

程序輸出

First:
Person類構造函數
Employee類構造函數
Manager類構造函數
Deirector類構造函數
Person{name=‘null’, id=0, sex= , age=0}
Employee{salary=0.0, workId=1, homeAddress=null, comAddress=null}
Manager{department=‘null’}
Deirector{carAllowance=0}
Second:
Address類構造函數
Address類構造函數
Employee類構造函數
Manager類構造函數
Deirector類構造函數
Person{name=‘Jack’, id=1740, sex=男, age=44}
Employee{salary=13.14, workId=2, homeAddress=Address{addName=‘null’, addId=‘null’, city=‘null’, district=‘null’}, comAddress=Address{addName=‘null’, addId=‘null’, city=‘null’, district=‘null’}}
Manager{department=‘nothing’}
Deirector{carAllowance=0}
Third:
Company類構造函數
Company{id=0, comName=‘null’, address=null, employees=null}
Forth:
Address類構造函數
Company類構造函數
Company{id=233, comName=‘破產集團’, address=Address{addName=‘null’, addId=‘null’, city=‘null’, district=‘null’}, employees=[Person{name=‘null’, id=0, sex= , age=0}
Employee{salary=0.0, workId=1, homeAddress=null, comAddress=null}
Manager{department=‘null’}
Deirector{carAllowance=0}, Person{name=‘Jack’, id=1740, sex=男, age=44}
Employee{salary=13.14, workId=2, homeAddress=Address{addName=‘null’, addId=‘null’, city=‘null’, district=‘null’}, comAddress=Address{addName=‘null’, addId=‘null’, city=‘null’, district=‘null’}}
Manager{department=‘nothing’}
Deirector{carAllowance=0}]}

2.1.2 抽象步驟

有兩個方面，一方面是它的靜態屬性，另外一方面是它的動態屬性。反映到 JAVA 裏面的類怎麼包裝它呢？一方面成員變量，另外一方面是方法。

2.1.3 深化理解對象

2.1.3.1 平常生活中的對象

在平常生活中，對象就是咱們認識世界的基本單元，它能夠是人，也能夠是物，還能夠是一件事。
整個世界就是由形形色色的「對象」構成的（萬物皆對象）。
對象是現實世界中的一個實體，其特徵是：

對象的標示（名稱）惟一；
對象的狀態（屬性、數據區）
對象的行爲（方法、功能）

2.1.3.2 程序中建立對象

必須使用new關鍵字建立一個對象
使用對象屬性（對象名.成員變量）
使用對象方法（對象名.方法名）
同一個類的每一個對象有不一樣的成員變量的存儲
空間
同一個類的每一個對象共享該類的方法

類是引用類型變量，聲明並不爲對象分配內存空間，而只是分配一個引用空間；對象的引用相似於指針，是32位的地址空間，它的值指向一箇中間的數據結構，它存儲有關數據類型的信息以及當前對象所在的堆的地址，而對於對象所在的實際的內存地址是不可操做的，這就保證了安全性。

2.1.3.3 匿名對象

咱們也能夠不定義對象的句柄，而直接調用這個對象的方法。這樣的對象叫作匿名對象
例如：

Student stu=new Student()；//stu是對象，名字是stu
new Student()；∥這個也是一個對象，可是沒有名字，稱爲匿名對象
new Student().show()；匿名對象方法調用匿名對象用完了以後就變成垃圾了，由於這個對象沒有被棧內存中的變量指向，全部會被gc回收
若是對一個對象只須要進行一次方法調用，那麼就可使用匿名對象。
咱們常常將匿名對象做爲實參傳遞給一個函數調用。

2.1.4 深化理解類

類：在軟件中，類，就是一個模板，它定義了一類事物的狀態和行爲。
類是對現實世界的抽象，所以類是一種抽象的複合數據類型。

類的真正意義就是在描述事物。
屬性和功能統稱爲事物中的成員。事物的成員分爲兩種：成員屬性和成員功能。
成員屬性在代碼中的體現就是成員變量成員功能在代碼中的體現就是成員方法

2.1.5 案例：小王減秤

小王原本體重70Kg，通過減肥，體重降到45Kg，試從這個問題領域中識別對象、類、屬性、行爲、狀態，和狀態變化

package 小王減秤;

/**
 * Person類
 *
 * @author gwr
 * @date 2019-06-04 19:02
 */
public class Person {
    private String name;
    private int weight;

    public Person() {
        super();
        System.out.println("Person類構造函數");
    }

    public Person(String name, int weight) {
        super();
        this.name = name;
        this.weight = weight;
    }

    public int getWeight() {
        return weight;
    }

    public void loseWeight(int newWeight) {
        weight = newWeight;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                '}';
    }
}

View Code

package 小王減秤;

/**
 * 小王減肥測試類
 *
 * @author gwr
 * @date 2019-06-04 21:51
 */
public class TestWeight {
    public static void main(String[] args) {
        Person p = new Person("小王", 70);
        System.out.println(p);
        p.loseWeight(45);
        System.out.println(p);
    }
}

View Code

Person{name=‘小王’, weight=70}
Person{name=‘小王’, weight=45}

案例：大掃除

package 大掃除;

/**
 * Employee類
 *
 * @author gwr
 * @date 2019-06-04 19:25
 */
public class Employee {
    private String name;
    private final int id;
    private static int count = 0;

    public Employee(String name) {
        super();
        this.name = name;
        this.id = ++count;
    }

    public void 擦玻璃() {
        System.out.println(this.toString()+"擦玻璃");
    }

    public void 掃地() {
        System.out.println(this.toString()+"掃地");
    }

    public void 拖地() {
        System.out.println(this.toString()+"拖地");
    }

    public void 倒垃圾() {
        System.out.println(this.toString()+"倒垃圾");
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

View Code

package 大掃除;

/**
 * 大掃除測試類
 *
 * @author gwr
 * @date 2019-06-04 22:00
 */
public class TestEmployee {
    public static void main(String[] args) {
        Employee tom = new Employee("Tom");
        Employee jack = new Employee("Jack");
        Employee jean = new Employee("Jean");
        Employee mary = new Employee("Mary");

        tom.擦玻璃();
        jack.掃地();
        jean.拖地();
        mary.倒垃圾();
    }
}

View Code

程序輸出

Employee{name=‘Tom’, id=1}擦玻璃
Employee{name=‘Jack’, id=2}掃地
Employee{name=‘Jean’, id=3}拖地
Employee{name=‘Mary’, id=4}倒垃圾

2.1.6 類與對象的關係

類和對象之間是抽象和具體的關係。類是建立對象的模板，對象是類的具體實例。

類（class）是總稱，對象是個體，所以對象（object）也叫實例（instance）。

2.1.7 深化理解抽象

抽象的過程就是分析的過程，分析中摒棄細節，提取共性、由複雜到簡潔

2.1.8 案例：學生

package stu;

/**
 * Student類
 *
 * @author gwr
 * @date 2019-06-04 20:41
 */
public class Student {
    private String name;
    private char sex;
    private String birthday;
    private int mathScore;
    private int engScore;

    public Student() {
        super();
    }

    public Student(String name, char sex, String birthday) {
        this.name = name;
        this.sex = sex;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public int getMathScore() {
        return mathScore;
    }

    public void setMathScore(int mathScore) {
        this.mathScore = mathScore;
    }

    public int getEngScore() {
        return engScore;
    }

    public void setEngScore(int engScore) {
        this.engScore = engScore;
    }

    public double getAverScore() {
        return (mathScore + engScore) / 2.0;
    }

    public int getMaxScore() {
        int max;
        if (mathScore > engScore)
            max = mathScore;
        else
            max = engScore;
        return max;
    }

    @Override
    public String toString() {
        return "姓名" + name + "；性別" + sex + "；出生年月；" + birthday;
    }
}

View Code

package stu;

/**
 * 學生測試類
 *
 * @author gwr
 * @date 2019-06-04 20:48
 */
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("Jack", 'M', "19881111");
        System.out.println(s1);
        s1.setBirthday("1988/11/11");
        System.out.println(s1);
        s1.setMathScore(59);
        s1.setEngScore(61);
        System.out.println("math"+s1.getMathScore());
        System.out.println("english"+s1.getEngScore());
        System.out.println("average"+s1.getAverScore());
        System.out.println("max"+s1.getMaxScore());
    }
}

View Code

程序輸出

姓名Jack；性別M；出生年月；19881111
姓名Jack；性別M；出生年月；1988/11/11
math59
english61
average60.0
max61

2.1.9 如何理解消息

對象提供的服務是由對象的方法來實現的，所以發送消息實際上也就是調用一個對象的方法。例如：遙控器向電視機發送「開機」消息，意味着遙控器對象調用電視機對象的開機方法。

2.1.10 類的設計原則

取有意義的名字。
儘可能將數據設計爲私有屬性。
儘可能對變量進行初始化。
類的功能儘可能單一。（類是細粒度的）

2.1.11 屬性和方法

2.1.11.1 屬性和方法闡述

對象的特徵：屬性(attribute/instance variable/data field)每一個對象的每一個屬性都擁有特定值
對象的動做：方法

2.1.11.2 屬性

在類中表示對象或實體擁有的特性時稱爲屬性
事物的特性，在類中表示爲變量
每一個對象的每一個屬性都擁有其特有的值
屬性名稱由類的全部實例共享

2.1.11.3 方法

對象執行的操做稱爲方法
操做的實際實現
方法指定操做對象數據的方式
如何執行所請求的操做的規範
在獲得操做請求時指定如何作的算法

2.1.11.4 實例

收銀員布萊尼 {
屬性：姓名（布萊尼），職銜（收銀員），年齡（35），體重（60kg）
方法：收款，打印帳單，刷卡
}

顧客朱麗葉 {
屬性：姓名（朱麗葉），年齡（28），體重（52kg）
方法：購買商品
}

尼古拉斯·凱奇駕駛的這輛法拉利F360 Spider {
屬性：品牌（法拉利），型號（F360 Spider），顏色（黃色），價格（380萬元）
方法：發動，中止，加速
}

小狗 {
屬性：顏色（白色）
方法：叫，跑，吃
}

投影儀 {
屬性：顏色（黑色），品牌（BENQ）
方法：投影
}

學生張三 {
屬性：姓名（張三），年齡（17）
方法：學習
}

桌子 {
屬性：材質（木質）
方法：支撐物品
}

燈泡 {
屬性：類型（白熾燈）
方法：開，關，變亮，變暗
}

2.1.12 案例：組裝電腦

在網上查詢具體每個硬件的參數和報價；
實體店詢價；
詢價結束後，根據具體的結果分析出本身比較滿意的某品牌報價；
到某品牌店裏進行組裝，組裝時須要進行現場監督。
假如咱們須要買組裝機，這時應該找一個懂電腦硬件的人，讓他幫咱們查看參數和報價，並進行詢價和殺價，以及現場組裝監督。而咱們本身並不須要親歷親爲具體怎麼作，只要告訴這我的咱們想要的具體需求便可。

公共父類Engineer

網絡管理工程師（類）
- 上網查看參數和報價
- 電話查詢
- 電話殺價
- 監督
組裝工程師（類）
- 組裝電腦
Agent類（測試類）（產生對象，協做完成）

面向對象編程：一組對象互相配合經過溝通完成特定功能
作軟件苦苦追求的一種境界是可重用性（reusable），可擴展性。
若是是面向過程，通常狀況是屬性和方法它們是分開的，他們不是聚合的關係，不是合在一塊兒的，這樣要複用起來比較麻煩，複用的層次只是侷限於方法這個層次上，
而面向對象則不一樣，它是把屬性和方法綜合在一個裏面。因此面向對象和麪向過程相比，前者更加容易讓咱們達到可重用性。

2.2 類間關係

2.2.1五種類間關係

2.2.1.1 關聯關係(Association)

類A與類B的實例之間存在特定的對應關係。

關聯指的是類之間的特定對應關係，在UML中用帶實線的箭頭表示。
按照類之間的數量對比，關聯可分爲如下三種：
一對一關聯：例如假定一個家庭教師只教一個學生，一個學生只有一個家庭教師，那麼家庭教師和學生之間是一對一關聯。
一對多關聯：例如假定一個足球隊員只能加入一個球隊，一個球隊能夠包含多個隊員，那麼球隊和隊員之間是一對多關聯。
多對多關聯：例如假定一個足球隊員能夠加入多個球隊，一個球隊能夠包含多個隊員，那麼球隊和隊員之間是多對多關聯。

2.2.1.2 依賴關係(Dependency)

類A訪問類B提供的服務。

依賴指的是類之間的調用關係，在UML中用帶虛線的箭頭表示。若是類A訪問類B的屬性或方法，或者類A負責實例化類B，那麼能夠說類A依賴類B。
例如：把大象裝進冰箱
例如：在面板中繪圖

2.2.1.3 彙集關係(Aggregation)

類A爲總體類，類B爲局部類，類A的對象由類B的對象組合而成。
彙集指的是總體與部分之間的關係，在UML中用帶實線的菱形箭頭表示。例如：檯燈和燈泡之間就是彙集關係。
組合：組合是一種用多個簡單子系統來組裝出複雜系統的有效手段。

2.2.1.4 泛化關係(Generalization)

類A繼承類B。
泛化指的是類之間的繼承關係

Shape

Circle
Line
Rectangle

2.2.1.5 實現關係(Realization)

類A實現了B接口。
實現指的是類與接口之間的關係。
在UML中用帶虛線的三角形箭頭表示，這裏的接口指的是接口類型，接口名字用斜體字表示，接口中的方法都是抽象方法，也採用斜體字表示。

2.2.2 案例：客戶和訂單的關聯關係

package CusOrd;

import java.util.HashSet;
import java.util.Set;

/**
 * 客戶類
 *
 * @author gwr
 * @date 2019-06-05 19:17
 */
public class Customer {
    /**
     * 全部與Customer對象關聯的Order對象
     */
    private Set<Order> orders = new HashSet<>();
    
    public Set getOrders() {
        return this.orders;
    }
    
    public void setOrders(Set orders) {
        this.orders = orders;
    }
}

View Code

package CusOrd;

/**
 * 訂單類
 *
 * @author gwr
 * @date 2019-06-05 19:17
 */
public class Order {
    /**
     * 與Order對象關聯的Customer對象
     */
    private Customer customer;
    public Customer getCustomer() {
        return this.customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

View Code

2.2.3 案例：狗逮耗子的依賴關係

package 狗拿耗子;

/**
 * 老鼠類
 *
 * @author gwr
 * @date 2019-06-05 19:25
 */
public class Mouse {
    private String name;
    private double height;
    private double weight;

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public void scream() {
        System.out.println("被狗咬了！");
    }
}

View Code

package 狗拿耗子;

/**
 * 狗類
 *
 * @author gwr
 * @date 2019-06-05 19:25
 */
public class Dog {
    /**狗毛顏色**/
    private int furcolor;
    /**狗的高度**/
    private float height;
    /**狗的體重**/
    private float weight;

    public Dog() {}

    public Dog(int furcolor, float height, float weight) {
        super();
        this.furcolor = furcolor;
        this.height = height;
        this.weight = weight;
    }

    public void catchMouse (Mouse mouse) {
        mouse.scream();
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        Mouse m = new Mouse();

        d.catchMouse(m);
    }
}

View Code

2.2.4 思考題

列舉一些現實生活中的例子，來講明什麼是依賴關係、什麼是彙集關係，以及什麼是關聯關係。

依賴關係：人依賴食物；電視機依賴電；理髮師依賴剪刀和吹風機；魚依賴水。
彙集關係：電腦由顯示器、主機和鍵盤等彙集而成。
關聯關係：公司和員工；銀行和客戶；老公和老婆。

2.3 類的設計

2.3.1 類的設計原則

取有意義的名字

儘可能將數據設計爲私有屬性

儘可能對變量進行初始化

類的功能儘可能單一（原子、細粒度）

2.3.2 源文件基本結構

一個基本的Java程序的三大件

包的聲明：指定類所在的位置
類的導入：用到其餘位置中的類
類的定義：核心部分

Java源文件的基本語法
[<包聲明>]
[<導入聲明>]
<類聲明>+

舉例

package shipping.reports;

import shipping.domain.*;
import java.io.Writer;
import java.util.List;

/**
 * 源文件佈局展現
 *
 * @author gwr
 * @date 2019-06-06 8:29
 */
public class VehicleCapacityReport {
    private List vehicles;
    public void generateReport(Writer output) {}
}

View Code

Java容許在一個Java源文件中編寫多個類，但其中的多個類至多隻能有一個類使用public修飾。

package 源文件;

/**
 * 一個類放在一個源文件中
 *
 * @author gwr
 * @date 2019-06-06 8:34
 */
public class Student {
    /**成員屬性：學號、姓名、性別、年齡**/
    private String studentId;
    private String studentName;
    private String studentSex;
    private int studentAge;

    /**
     * 構造函數
     */
    public Student() {
        super();
    }
}

View Code

package 源文件;

/**
 * 多個類放在一個源文件中
 *
 * @author gwr
 * @date 2019-06-06 8:36
 */
public class ClassTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("HelloWorld!");
    }
}

class Test1{

}

class Test2{

}

View Code

2.3.3 定義類

2.3.3.1 定義一個類的步驟

定義類名（每一個單詞的第一個字母大寫，其他的小寫）
編寫類的屬性
編寫類的方法

2.3.3.2 類的定義格式

~~類修飾符~~ class 類名 ~~extends 基類~~
~~implements 接口列表~~
{
[數據成員定義]
[成員方法定義]
}

2.3.3.3 類的定義說明

關鍵字class表示類定義的開始
類名要符合標識符的命名規範
修飾符分爲訪問控制符和類型說明符

2.3.4 符號

2.3.4.1 訪問控制符

類的訪問控制符有兩個，一個是public，即公共類，另外一個就是默認，即沒有訪問控制符。

一個類被定義爲公共類，就表示它可以被其它全部的類訪問和引用。
在一個Java源程序中只能有一個public類，這個類通常含有main方法。
不用public定義的類，其只能被同一個包中定義的類訪問和引用。
在一個Java程序中能夠定義多個這樣的類。

2.3.4.2 類型說明符

類的類型說明符主要有兩個：final abstract

2.3.5 成員變量的定義

成員變量的定義格式：
-[修飾符]變量的數據類型變量名[=初始值]
修飾符主要有四種，分別是：
① public、
② private、
③ protected、
④默認。

2.3.6 成員方法的定義

2.3.6.1 方法的定義格式

~~修飾符~~ 返回值類型方法名（~~形參說明~~）
~~throws例外名1，例外名2…~~
{
局部變量聲明；
執行語句組；
}

2.3.6.2 成員方法的定義說明

經常使用的修飾符爲public、private、protected、static、final等
返回值類型：方法通常須要有一個返回值表示執行結果，也能夠無返回值（用void表示）。返回值類型能夠是Java類型系統中的全部類型。有返回值的方法使用return語句將值返回給調用者。

2.4 特殊點強調

2.4.1 案例：return的理解

package understand_return;

/**
 * return退出方法
 * 結束方法，無輸出
 *
 * @author gwr
 * @date 2019-06-06 8:54
 */

class Dog{
    String name;

    public void bark(int a) {
        if (a == 0) {
            System.out.println("你好");
        } else if (a == 1) {
            return;
        }
        System.out.println("我很好");
    }
}

public class FangFa1 {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.bark(1);
    }
}

View Code

2.4.2 案例：toString()方法

在java中，全部對象都有默認的toString（）這個方法
建立類時沒有定義toString（）方法，輸出對象時會輸出對象的哈希碼值（對象的內存地址）它一般只是爲了方便輸出，好比System.out.println（xx），（xx是對象），括號裏面的」xx」若是不是String類型的話，就自動調用xx的toString（）方法
它只是sun公司（0racle）開發java時爲了方便全部類的字符串操做而特地加入的一個方法

package toString方法研究;

/**
 * Desk類
 *
 * @author gwr
 * @date 2019-06-06 9:01
 */
public class Desk {
    private String colcr;
    private int length;
    private int width;
    private int height;

    public Desk() {
        super();
    }

    public Desk(String colcr, int length, int width, int height) {
        super();
        this.colcr = colcr;
        this.length = length;
        this.width = width;
        this.height = height;
    }

    public String getColcr() {
        return colcr;
    }

    public void setColcr(String colcr) {
        this.colcr = colcr;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public void print() {
        System.out.println("printDesk{" +
                "colcr='" + colcr + '\'' +
                ", length=" + length +
                ", width=" + width +
                ", height=" + height +
                '}');
    }
    public static void main(String[] args) {
        //test phrase 1
        Desk d1 = new Desk();
        d1.print();
        d1.setColcr("red");
        d1.setHeight(40);
        d1.setLength(20);
        d1.setWidth(20);
        d1.print();

        //test phrase2
        Desk d2 = new Desk("red", 30, 30, 30);
        d2.print();

        System.out.println(d2.toString());
        System.out.println(d2);
    }
}

View Code

程序輸出

printDesk{colcr=‘null’, length=0, width=0, height=0}
printDesk{colcr=‘red’, length=20, width=20, height=40}
printDesk{colcr=‘red’, length=30, width=30, height=30}
toString方法研究.Desk@7eda2dbb
toString方法研究.Desk@7eda2dbb

2.4.3 案例：教育機構

設計程序知足如下四點：某教育機構在北京、杭州等地都有分公司，在不一樣分公司，你會感覺到相同的環境和教學氛圍。
A中信的默認值是「杭州中心」
編寫A中心的toString()，輸出該中心的描述信息
編寫測試類

package 教育機構;

/**
 * 教育機構A
 *
 * @author gwr
 * @date 2019-06-06 9:17
 */
public class A {
    /**A中心的屬性（成員變量）**/
    /**中心的全稱，默認值爲「杭州中心」**/
    private String schoolName = "杭州中心";
    /**教室的數目**/
    private int classNum;
    /**機房的數目**/
    private int labNum;

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }

    public int getClassNum() {
        return classNum;
    }

    public void setClassNum(int classNum) {
        this.classNum = classNum;
    }

    public int getLabNum() {
        return labNum;
    }

    public void setLabNum(int labNum) {
        this.labNum = labNum;
    }

    /**
     * A培訓機構的toString方法
     * 
     * 用於輸出類的相關信息
     */
    @Override
    public String toString() {
        return "A{" +
                "schoolName='" + schoolName + '\'' +
                ", classNum=" + classNum +
                ", labNum=" + labNum +
                '}';
    }
}

class InitialSchool{
    
    public static void main(String[] args) {
        A center = new A();
        System.out.println(center);
        
        center.setSchoolName("北京中心");
        center.setClassNum(10);
        center.setLabNum(10);
        
        System.out.println(center);
        System.out.println(center.toString());
    }
}

View Code

程序輸出

A{schoolName=‘杭州中心’, classNum=0, labNum=0}
A{schoolName=‘北京中心’, classNum=10, labNum=10}
A{schoolName=‘北京中心’, classNum=10, labNum=10}

2.5 類的訪問機制

在一個類中的訪問機制：類中的方法能夠直接訪問類中的成員變量；

在不一樣類中的訪問機制：先建立要訪問類的對象，再用對象訪問類中定義的成員。

2.5.1 this關鍵字

在類的方法定義中使用this關鍵字表明使用該方法的對象的引用
有時，使用this能夠處理方法中成員變量和參數重名的問題
this能夠看作一個變量，他的值是當前對象的引用

package this關鍵字;

/**
 * this關鍵字解讀
 *
 * @author gwr
 * @date 2019-06-06 9:27
 */
class Cat{
    String name;
    char sex;
    int age;

    public void set(String name, char sex, int age) {
        this.name = name;//爲了區別兩個name用this表明使用該方法的對象c的引用
        this.sex = sex;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.set("wth", '母', 2);
        System.out.println(c);
    }
}

View Code

2.6 基本類型和引用類型做

2.6.1 基本數據類型做爲參數傳遞（深拷貝）

package 不一樣數據類型傳參;

/**
 * 數據類型傳參
 *
 * @author gwr
 * @date 2019-06-06 9:33
 */
public class Demo {
    
    public static void main(String[] args) {
        int x = 4;
        show(x);
        System.out.println("x="+x);
    }
    
    public static void show(int x) {
        x = 5;
    }
}

View Code

程序輸出

x=4

基本類型做爲參數傳遞時，其實就是將基本類型變量×空間中的值複製了一份傳遞給調用的方法show()，當在show()方法中x接受到了複製的值，再在show()方法中對x變量進行操做，這時只會影響到show中的x。當show方法執行完成，彈棧後，程序又回到main方法執行，main方法中的x值仍是原來的值。

2.6.2 引用數據類型做爲參數傳遞（淺拷貝）

package 不一樣數據類型傳參;

/**
 * 數據類型傳參
 *
 * @author gwr
 * @date 2019-06-06 9:33
 */
public class Demo {
    private int x;

    public static void main(String[] args) {
        Demo d = new Demo();
        d.x = 5;
        show(d);
        System.out.println("x=" + d.x);
    }

    public static void show(Demo d) {
        d.x = 6;
    }
}

View Code

程序輸出

x=6

當引用變量做爲參數傳遞時，這時實際上是將引用變量空間中的內存地址（引用）複製了一份傳遞給了show方法的d引用變量。這時會有兩個引用同時指向堆中的同一個對象。當執行show方法中的d.x=6時，會根據d所持有的引用找到堆中的對象，並將其x屬性的值改成6。
因爲是兩個引用指向同一個對象，無論是哪個引用改變了引用的所指向的對象的中的值，其餘引用再次使用都是改變後的值。

2.6.3 進一步理解引用類型變量

對象由兩部分組成：對象的實體；對象的引用

案例：Person pl=new Person(「Jack"，"Male"，23);內存狀態變化過程分析

案例：
Person p1=new Person(「Jack」,」Male」,23);
Person p2=p1;
Person p3=new Person(「Jack」,」Male」,23);

2.7 方法的重載

方法的重載是指一個類中能夠定義有相同的名字，但參數不一樣的多個方法，調用時會根據不一樣的參數表選擇對應的方法。

2.7.1 生活中的方法重載

類	方法	方法參數	方法實現
司機	駕駛	轎車	啓動、行駛
司機	駕駛	巴士	等待乘客上車、啓動、行駛、到站停車
司機	駕駛	火車	正點發車、行駛、到站停車

若是用代碼實現，咱們須要三個方法，這些方法的方法名稱相同，參數類型不一樣。

2.7.2 Java中的方法重載

示例1：java.io.PrintStream類的println方法可以打印數據並換行，根據數據類型的不一樣，有多種實現方式。

在PrintStream中println(int)、println(char)、println(String)是方法名相同，參數類型不一樣的，因此是方法重載

/**
 * Test類
 *
 * @author gwr
 * @date 2019-06-06 10:04
 */
public class Test {
    public static void main(String[] args) {
        int i = 0;
        char c = 'z';
        String s = "hello";
        System.out.println(i);
        System.out.println(c);
        System.out.println(s);
    }
}

View Code

示例2：java.lang.Math類的max()方法可以從兩個數字中取出最大值，它有多種實現方式
運行時，Java虛擬機先判斷給定參數的類型，而後決定到底執行哪一個max()方法。

在Math中max(int a, int b)、max(float a, float b)、max(long a, long b)、max(double a, double b)是方法名相同，參數類型不一樣的，因此是方法重載

/**
 * Test類
 *
 * @author gwr
 * @date 2019-06-06 10:04
 */
public class Test {
    public static void main(String[] args) {
        Math.max(1,2);
        Math.max(1.0F, 2.0F);
        Math.max(1.0, 2);
    }
}

View Code

2.7.3 構造函數方法重載

2.7.3.1 構造方法

構造方法（constructor）是一類特殊的成員方法。
從功能上講，它使用new關鍵字用來對新建立的對象進行初始化的。
從形式上來說，它有如下特色：

它與類同名；
它沒有任何返回值；
除了上述兩點外，在語法結構上與通常的方法相同。

2.7.3.2 構造方法重載

Java語言中，每一個類都至少有一個構造方法；
構造方法有兩大類，構造方法能夠重載，而且一般是重載的：

經過調用不一樣的構造方法來表達對象的多種初始化行爲

2.7.3.3 案例：教育機構

-默認狀況下，教師來自北京中心，初始化時，只需提供教員姓名
-有時，須要提供所在中心名稱及教員姓名

/**
 * 教師類
 *
 * @author gwr
 * @date 2019-06-06 10:17
 */
public class Teacher {
    /**姓名**/
    private String name;
    /**所在中心**/
    private String school = "北京中心";

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

    public Teacher(String name, String school) {
        this.name = name;
        this.school = school;
    }

    public String introduction() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", school='" + school + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
}

class TeacherTest{
    public static void main(String[] args) {
        Teacher t1 = new Teacher("Mary");
        System.out.println(t1.introduction());

        Teacher t2 = new Teacher("Jack", "天津中心");
        System.out.println(t2.introduction());
    }
}

View Code

2.7.3.4 不帶參數構造方法（默認構造方法）

public Teacher() { }

Java語言中，每一個類都至少有一個構造方法；若是類的定義者沒有顯式的定義任何構造方法，系統將自動提供一個默認的構造方法：

默認構造方法沒有參數
默認構造方法沒有方法體
默認的構造方法：Animal(){}
因此：不編寫構造方法就能用new Xxx()建立類的實例。

無參構造函數建立對象時，成員變量的值被賦予了數據類型的隱含初值。

變量類型	默認值	變量類型	默認值
byte	o	short	0
int	o	long	OL
float	0.0f	double	0.0d
char	\u0000’	boolean	false
引用類型	null

在Java裏，若是一個類沒有明顯的代表哪個類是它的父類，0bject類就是它的父類。若是類中沒有定義構造函數，編譯器會自動建立一個默認的不帶參數的構造函數。
若是程序員爲類定義了構造函數，Java就不會爲該類建立默認的不帶參數的構造函數。
注意：若是類中提供的構造函數都不是無參數構造函數，卻企圖調用無參數構造函數初始化此類的對象，編譯時會產生語法錯誤。

2.7.3.5 帶參數構造方法

經過帶參數的構造方法，顯式地爲實例變量賦予初始值
類中有太多的屬性及對應的setter方法，在初始化時，很容易就忘記了，形成代碼冗餘，要簡化對象初始化的代碼，能夠經過調用帶參數的構造方法解決。

/**
 * 教師類
 *
 * @author gwr
 * @date 2019-06-06 10:17
 */
public class Teacher {
    /**姓名**/
    private String name;
    /**年齡**/
    private int age;
    /**學歷**/
    private String education;
    /**職位**/
    private String position;

    public String introduction() {
        return "你們好，我是" + name +
                "，我今年" + age +
                "歲，學歷是'" + education +
                "，職位是" + position;
    }

    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 String getEducation() {
        return education;
    }

    public void setEducation(String education) {
        this.education = education;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }
}

class TeacherTest{
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.setName("Mary");
        t.setAge(99);
        t.setEducation("本科");
        t.setPosition("老師");

        System.out.println(t.introduction());
    }
}

View Code

能夠經過調用帶參數的構造方法，簡化對象初始化的代碼，作到建立對象時，一併完成了對象成員的初始化工做

public Teacher(String name, int age, String education, String position) {
    this.name = name;
    this.age = age;
    this.education = education;
    this.position = position;
}

class TeacherTest{
    public static void main(String[] args) {
        Teacher t = new Teacher("Mary",99,"本科","老師");

        System.out.println(t.introduction());
    }
}

View Code

2.7.3.6 構造函數實例化類對象的格式

類名對象名=new構造函數（實際參數）
New關鍵字的做用
①爲對象分配內存空間。
②引發對象構造方法的調用。
③爲對象返回一個引用。

2.7.3.7 辨別構造方法

給定以下Java代碼，請指出代碼中的錯誤，並解釋緣由

public class Sample{
private int x;
//T無參構造函數
public Sample() {
x=1;
}
//T帶參構造函數
public Sample(int i) {
x=i;
}
//T不是構造函數
public int Sample(int i) {
x=i;
return x++;
}
//T帶參構造函數
private Sample(int i,String s){}
//T帶參構造函數
public Sample(String s,inti){}
//F名稱與類名不相同
private Sampla(int i) {
x=i++;
}
//T不是構造方法
private void Sampla(int i) {
x=i++;
}

2.8 局部變量和成員變量

自動初始化只用於成員變量，方法體中的局部變量不能被自動初始化，必須賦值後才能使用。

2.8.1 案例：person

package 全局變量和局部變量;

/**
 * Person類
 *
 * @author gwr
 * @date 2019-06-06 10:51
 */
public class Person {
    private String name;
    private String sex;
    private int age;

    public Person() {
    }

    public Person(String name, String sex, int age/*方法體中的局部變量不能被自動初始化，
                必須賦值後才能使用*/) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1);

        Person p2 = new Person("Jack", "男", 20);
        System.out.println(p2);
        int i = 0;//局部變量必須初始化後才能使用
        System.out.println(i);
    }
}

View Code

2.8.2 區別

區別一：定義的位置不一樣
- 定義在類中的變量是成員變量
- 定義在方法中或者}語句裏面的變量是局部變
  量
區別二：在內存中的位置不一樣
- 成員變量存儲在堆內存的對象中
- 局部變量存儲在棧內存的方法中
區別三：聲明週期不一樣
- 成員變量隨着對象的出現而出如今堆中，隨着對象的消失而從堆中消失
- 局部變量隨着方法的運行而出如今棧中，隨着方法的彈棧而消失
區別四：初始化不一樣
- 成員變量由於在堆內存中，全部成員變量具備默認的初始化值
- 局部變量沒有默認的初始化值，必須手動的給其賦值纔可使用。

2.8.3 案例：對象的內存圖解

package 對象的內存圖解;

/**
 * Car
 *
 * @author gwr
 * @date 2019-06-06 10:59
 */
public class Car {
    String color;
    int number;

    void run() {
        System.out.println(color+":"+number);
    }
}

View Code

package 對象的內存圖解;

/**
 * Demo
 *
 * @author gwr
 * @date 2019-06-06 11:00
 */
public class CarDemo {
    public static void main(String[] args) {
        Car c = new Car();

        c.color = "red";
        c.number = 4;
        c.run();
    }
}

View Code

2.9 內存管理

2.9.1 內存管理的兩種方法

一種方法是由程序員在編寫程序時顯式地釋放內存，例如C++。
另外一種方法是由語言的運行機制自動完成，例如Smalltalk，EiffeI和Java。

2.9.2 JAVA內存管理

2.9.2.1 垃圾自動回收機制

Java虛擬機後臺線程負責內存的回收。垃圾強制回收機制：Java系統提供了方法
「System.gc()」和「Runtime.gc()」方法來強制當即回收垃圾（但系統並不保證會當即進行垃圾回收）。
判斷一個存儲單元是不是垃圾的依據是：該存儲單元所對應的對象是否仍被程序所用。
判斷一個對象是否仍爲程序所用的依據是：是否有引用指向該對象。
Java的垃圾收集器自動掃描對象的動態內存區，對所引用的對象加標記，而後把沒有引用的對象做爲垃圾收集起來並釋放出去。
Java虛擬機能夠自動判斷並收集到「垃圾」，但通常不會當即釋放它們的存儲空間。
Java系統本身定義了一套垃圾回收算法，用來提升垃圾回收的效率。

2.9.2.2 Java內存強制回收

System.gc()；強制系統回收垃圾內存
Runtime.gc()；強制系統回收垃圾內存Java沒有提供析構方法，但提供了一個相似的方法：protected void finalize()。
Java虛擬機在回收對象存儲單元以前先調用該對象的finalize方法，若是該對象沒有定義finalize方法，則java系統先調用該對象默認的finalize方法。

package Java垃圾回收;

/**
 * Java垃圾回收
 *
 * @author gwr
 * @date 2019-06-06 11:06
 */
class JavaBook extends Object {
    private String name;

    JavaBook(String name) {
        this.name = name;
    }

    @Override
    protected void finalize() {
        System.out.println("Book" + name + "is destroyed!");
    }
}

public class JavaFinalize {
    public static void main(String[] args) {
        JavaBook book = new JavaBook("工科數學分析");
        new JavaBook("大學物理");
        new JavaBook("下雨了");
        System.gc();
        /*其實當咱們直接調用System.gc()
        只會把此次gc請求記錄下來，
        等到runFinalization=true的時候纔會先去執行GC，
        runFinalization=true以後會在容許一次system.gc()。
        以後在call System.gc()還會重複上面的行爲。
         */
        //調用這句話使gc當即執行
        System.runFinalization();
        book = new JavaBook("我在上馬原課");
    }
}

View Code

2.10 類的靜態屬性和靜態方法

2.10.1 程序運行時的內存佔用

代碼區（code area）存放程序的代碼部分
數據區（data area）存放程序的全局數據和靜態數據
堆區（heap area）存放程序動態申請的數據
棧區（stack area）存放程序的局部數據和參數

2.10.2 回答問題

問題一：不論產生多少個對象，或不存在任何對象的狀況下，某些特定數據的存儲空間都只有一份；
-例如：統計出從Person共new出多少個對象？
問題二：某些數據或者函數不要和class object綁在一塊兒。

經過關鍵字static，即可以處理這兩種狀況，當你將某個數據成員或某個成員函數聲明爲static時，它就再也不侷限於所屬的class object上。
Java中把這種表明類範圍信息的變量用關鍵字static修飾。

2.10.3 Static的使用場合

用static修飾的屬性（變量）稱爲靜態屬性，又叫類變量；用static修飾的方法稱爲靜態方法，又叫類方法（靜態方法裏，無this）；能夠用來修飾初始化語句塊，這樣的語句塊常稱爲靜態初始化語句塊（要跟非靜態初始化語句塊區分開來）

2.10.4 案例：統計出從Person共new出多少個對象

理解並掌握Static關鍵字的用法
類變量概念
類方法概念
適用場合：經過關鍵字static，即可以處理這兩種狀況，當你將某個數據成員或某個成員函數聲明爲static時，它就再也不侷限於所屬的class object上。

即便沒有建立該類的具體對象，類中的static類成員也會存在，這時能夠經過：
1.類名.靜態變量
2.類名.靜態方法

package 全局變量和局部變量;

/**
 * Person類
 *
 * @author gwr
 * @date 2019-06-06 10:51
 */
public class Person {
    private String name;
    private String sex;
    private int age;
    private static int count;

    public static int getCount() {
        return count;
    }

    public Person(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        count++;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Person p1=new Person("張三","男",20);
        System.out.print("count="+p1.getCount()+"\t");//1
        System.out.print("count="+Person.getCount()+"\n");//1

        Person p2=new Person("Tom","M",50);
        System.out.print("count="+p2.getCount()+"\t");//2
        System.out.print("count="+Person.getCount()+"\n");//2
        Person p3=new Person("Mary","F",10);
        System.out.print("count="+p3.getCount()+"\n");//3
        System.out.println("經過類名和不一樣對象名訪問靜態變量count:");
        System.out.print("count="+Person.getCount()+"\n");//3
        System.out.print("count="+p1.getCount()+"\t");//3
        System.out.print("count="+p2.getCount()+"\t");//3
        System.out.print("count="+p3.getCount()+"\n");//3l
    }
}

View Code

程序輸出

count=1 count=1
count=2 count=2
count=3
經過類名和不一樣對象名訪問靜態變量count:
count=3
count=3 count=3 count=3

2.10.5 案例：TestStudent.java

重點：類變量和類方法；實例變量和實例方法

類變量和類方法
1.類的變量和方法是由關鍵字static修飾的的。
2.類變量和類方法由該類產生的全部實例共享。
3.調用方式：
·類名\對象名.靜態變量
·類名\對象名.靜態方法

實例變量和方法
1.每個實例擁有一份獨立拷貝，所以每一個實例對象的數據是獨立且惟一的。
2.調用方式：
1.對象名.事例變量
2.對象名.事例方法

package stu;

/**
 * 學生測試類
 *
 * @author gwr
 * @date 2019-06-04 20:48
 */
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.num);
        Student zhang = new Student();
        Student guo = new Student();
        Student wu = new Student();

        System.out.println("zhang.num = "+ zhang.add1());
        System.out.println("zhang.number = "+ zhang.add2());
        System.out.println("guo.num = "+ guo.add1());
        System.out.println("guo.number = "+ guo.add2());
        System.out.println("wu.num = "+ wu.add1());
        System.out.println("wu.number = "+ wu.add2());

    }
}

View Code

程序輸出

10
zhang.num = 11
zhang.number = 1
guo.num = 12
guo.number = 1
wu.num = 13
wu.number = 1

2.10.6 回答問題

你知道main（）爲何要用static修飾的緣由了嗎？
main（）方法中的static能夠去掉嗎？

靜態代碼塊與非靜態代碼塊的異同點

2.10.7 靜態代碼塊與非靜態代碼塊的異同點

相同點：
1.都是在JVM加載類時且在構造方法執行以前執行，在類中均可以定義多個。
2.通常在代碼塊中對一些static變量進行賦值。

不一樣點：
1.靜態代碼塊在非靜態代碼塊以前執行：①靜態代碼塊一〉非靜態代碼塊一〉構造方法
2.靜態代碼塊只在第一次new執行一次，以後再也不執行，而非靜態代碼塊在每new一次就執行一次

2.10.8 案例：初始化順序

package 靜態代碼塊;

/**
 * 代碼塊初始化順序
 *
 * @author gwr
 * @date 2019-06-06 13:28
 */
public class staticBlock {
    private static int counter;
    private int cnt;

    public staticBlock() {
        System.out.println("默認構造方法");
    }

    /**
     * 非靜態代碼塊
     */
    {
        System.out.println("非靜態代碼塊");
        cnt = 4;
        counter = 4;
    }

    /**
     * 靜態代碼塊
     */
    static {
        System.out.println("靜態代碼塊");
        counter = 5;
        //cnt = 5;
    }

    /**
     * 靜態成員方法
     */
    public static void test() {
        System.out.println("靜態成員方法：普通方法中的代碼塊");
    }

    /**
     * 測試
     */
    public static void main(String[] args) {
        System.out.println("main函數");
        staticBlock s = new staticBlock();
        s.test();
    }
}

View Code

程序輸出

靜態代碼塊
main函數
非靜態代碼塊
默認構造方法
靜態成員方法：普通方法中的代碼塊

2.11 總結

需求中提取類，即抽象的過程。
建立一個類就是建立一個新的數據類型，實例化一個類，就獲得一個對象。
類的構成有兩部分，分別是成員變量和成員方法。

類的成員變量能夠是基本類型或數組，也能夠是類的對象。
類的成員方法用於處理該類的數據，是用戶與對象之間或對象之間的交互接口。

類的設計是細粒度的 – 例如：公司員工擁有地址，包括公司地址和家庭地址，通常咱們會單獨編寫地址類（Address）

從編程需求出發，不須要的不考慮，全部的屬性和方法，都是在編程中所須要用到的。 – 是你的，打死也要。不是你的，打死也不要

1個工具：抽象Abstract（摒棄細節，提取共性）
2個概念：對象Object（客觀存在的實體）；類Class（具備相同性質的對象的抽象體）
3個特性：封裝Encapsulation；繼承Inheritance；多態Polymorphism
4個步驟：分析Analysis（·找出系統中的對象，抽象出類，肯定它們所屬的不一樣主題，分析它們之間的關係）；設計Design：（·對每一個類應該封裝的數據及其操做進行詳細設計和描述）；實現Implementation：（·採用某種編程語言編碼（Coding）實現各個類）；測試Test：（·由類建立對象，驗證其功能和性能是否知足需求）

對象是程序所處理數據的最主要的載體，數據以實例變量的形式存放在對象中。每一個對象在生命週期的開始階段，Java虛擬機都須要爲它分配內存，而後對它的實例變量進行初始化。
對象構造順序：用new語句建立類的對象時，Java虛擬機會從最上層的父類開始，依次執行各個父類以及當前類的構造方法，從而保證來自於對象自己以及從父類中繼承的實例變量都被正確地初始化。
對象構造順序：當子類的構造方法沒有經過super語句調用父類的構造方法，那麼Java虛擬機會自動先調用父類的默認構造方法。
匿名對象：當一個對象不被程序的任何引用變量引用，對象就變成無用對象，它佔用的內存就能夠被垃圾回收器回收。
合理地使用內存：每一個對象都會佔用必定的內存，而內存是有限的資源，爲了合理地利用內存，在決定對象的生命週期時，應該遵循如下原則：-當程序不須要再使用一個對象，應該及時清除對這個對象的引用，使它的內存能夠被回收。一重用已經存在的對象。程序可經過類的靜態工廠方法來得到已經存在的對象，而不是經過new語句來建立新的對象。（Java反射）

靜態代碼塊只能定義在類裏面，它獨立於任何方法，不能定義在方法裏面。
靜態代碼塊裏面的變量都是局部變量，只在本塊內有效。
靜態代碼塊會在類被加載時自動執行，而不管加載者是JVM仍是其餘的類。
一個類中容許定義多個靜態代碼塊，執行的順序根據定義的順序進行。
靜態代碼塊只能訪問類的靜態成員，而不容許訪問實例成員。

即便沒有建立該類的具體對象，類中的static類成員也會存在，這時能夠經過：類名.靜態變量；類名.靜態方法。

static方法中不能直接調用非static的域或方法（必須經過對象名引用）。 1.static函數並不須要先產生任何對象，就能夠經過類名來調用。 2.non-static數據/函數和對象綁定（緣由）。 3.在static函數中「直接」取用non-static數據/函數，會產生語法錯誤。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。