1、面向對象

面向對象

OOP

面向對象的優點：

（1）便于程序模擬現實世界中的實體
用“類”表示實體的特征和行為

（2）隱藏細節
對象的行為和屬性被封裝在類中，外界通過調用類的方法來獲得，不需關注內部細節如何實現

（3）可重用
可以通過類的模板，創建多個類的對象

2、對象

（1）特征：

屬性：attribute / field / property

屬性是對象具有的各種特征。
每個對象的每個屬性都擁有特定值。

方法 / 行為：method

方法是對象執行的操作。

（2）使用對象的步驟：

使用new創建一個對象：
School center = new School();

使用對象：
center.schoolName = “qinghua";        對象名.屬性
center. toInter ();      對象名.方法名()

（3）對象在內存中的存放形式

對象在內存中的存放形式

3、類

類是具有相同屬性和方法的對象的集合。

所有Java程序都以類class為組織單元。

定義一個類的步驟：

1. 定義類名
2. 編寫類的屬性
3. 編寫類的方法

4、類和對象的區別

類是抽象的概念，僅僅是模板，比如說：“人”。
對象是一個你能夠看得到、摸得著的具體實體，比如：“張三”。

5、抽象

把相同的或相似的對象歸為一類的這個過程就是抽象，所以，抽象就是分析問題的方法。

抽象的過程其實就是面向對象編程的核心思想之一。

6、成員運算符：.

在Java中，只有先實例化類的對象，才可以訪問到類中的成員（屬性和方法）。

使用成員運算符（.）來訪問成員屬性或成員方法；

一般語法是：
對象名.成員名

std.age = 18;   //為成員屬性賦值
std.dining();  //調用成員方法

7、構造器 / 構造方法：constructor

在上例中，只能逐個地為數據成員賦值，如果想在對象實例化的同時就初始化成員屬性，就使用到了構造方法。正是由于在實例化對象的同時會自動調用構造方法，所以構造方法一般用來給數據成員分配資源或初始化數據成員。

作用：對象實例化。

構造方法是特殊的成員方法，它與類同名，在對象實例化時由虛擬機自動調用。因為是由虛擬機來調用構造方法，所以構造方法一般應定義成public。

只有調用構造方法，才能在內存中開辟空間，才允許存放類中屬性和方法的數據。

構造方法的一般形式：

訪問權限 類名（形參列表） {
    方法體
}

請注意：

• 構造方法沒有返回值類型，也不能有返回值。
• 構造方法一般定義成public
• 每個對象在生成時都必須執行構造方法，而且只能執行一次。
• 如果構造方法調用失敗，那么對象也無法創建。
• 不可以顯式地直接調用構造方法。
• 在沒有定義構造方法的情況下，類會自動產生一個無參數的默認構造方法，這個默認的構造方法什么都不做。
  一旦顯式地定義了構造方法，默認構造方法自動消失。

修改后的Student類

例：

Person.java：

public class Person {
    String name;
    // 無參構造器
    public Person() {
        System.out.println("又一個人誕生了！");
    }

    // 含參構造器
    public Person(String name) {
        this.name = name;
        System.out.println
        ("一個人誕生了，他的名字是："+this.name);
    }
}

TestConstructor.java：

public class TestConstructor {
    public static void main(String[] args) {
        // 通過Person類的含參構造器實例化一個對象person
        Person person = new Person("張三");
        person.name="李四";
        System.out.println("名字："+person.name);
    
        // 通過Person類的無參構造器實例化一個對象p1
        Person p1 = new Person();
        p1.name="王五";
        System.out.println("人名字："+p1.name);
    }

}

8、this關鍵字

既然所有的對象都共用相同的成員方法，那么在不同的對象都調用同一方法時，它是怎么確定要使用哪個對象的數據成員呢？

每個成員方法都有一個隱含的this引用，它總是指向調用它的對象；

關鍵字this給出用于調用成員方法的對象的地址；

每當調用成員方法時，編譯器會向this分配調用該方法的對象的地址；
可以像使用任何引用那樣使用this。

/*this示例，代碼片段*/
public class Student  //定義學生類
{
  private String mName;  //姓名
  private int mAge;      //年齡

  public Student(String name, int age)
  {
    //隱式調用，等同于this.mName = name;
    mName = name;
    //顯式調用，等同于mAge = age;
    this.mAge = age;
  }
  ……
}

注意：在static作用域內，絕對不可以使用this關鍵字！！！
（因為this是指向本類的一個實例，而static只有一個實例）

9、面向對象的3大基本特征：

（1）封裝

java系列4：封裝encapsulation

（2）繼承

java系列5：繼承（inheritance）

（3）多態

java系列6：多態（Polymorphism）

3大基本特征

10、堆區、棧區、方法區

Java的內存分為3個區：堆（heap）、棧（stack）、方法區（method）。

堆區：

1. 存儲的全部是對象，每個對象都包含一個與之對應的class的信息。（class的目的是得到操作指令）。

2. JVM只有一個堆區被所有線程共享，堆中不存放基本類型和對象引用，只存放對象本身。

棧區：

1. 每個線程包含一個棧區，棧中只保存基本數據類型的對象和自定義對象的引用（不是對象），對象都存放在堆區中。

2. 每個棧中的數據（原始類型和對象引用）都是私有的，其他棧不能訪問。

3. 棧分為3個部分：基本類型變量區、執行環境上下文、操作指令區（存放操作指令）。

方法區：

String say(String name){return "abc"}
// name、"abc"等都存放在方法區

11、靜態成員

（1）變量

Java中的變量可分為成員變量和局部變量。
兩種變量的作用域和加載時間均不一樣。

（2）靜態成員變量

在成員變量前加static關鍵字，可以將其聲明為靜態成員變量；

如果類中成員變量被定義為靜態，那么不論有多少個對象，靜態成員變量只有一份內存拷貝，即所有對象共享該成員變量；
在沒有實例化對象時，可以通過類名訪問靜態成員變量；也可以通過對象訪問靜態成員變量，但不論使用的是哪個對象，訪問到的都是同一個變量。

靜態成員變量的作用域只在類內部，但其生命周期卻貫穿整個程序。和程序同生命周期。

靜態成員變量在聲明時最好初始化，如果不進行初始化，系統會默認初始化為0。

package test;

class Dog{
  public static int count = 0;  //靜態成員變量
  
  public Dog() {     //構造方法
    count++;
  }
}

public class Test{
  public static void main(String[] args){
    System.out.println("當前狗的數量是：" + Dog.count);
    Dog d1 = new Dog();
    Dog d2 = new Dog();
    System.out.println("當前狗的數量是：" + Dog.count);
  }
}

（3）靜態成員方法

在成員方法前加static關鍵字，可以將其聲明為靜態成員方法；
靜態成員方法只能對類的靜態成員變量（靜態屬性和靜態方法）進行操作，不能操作非靜態成員變量。（因為static屬性和方法是在編譯（javac）時開辟的內存空間，而普通變量和方法是在運行（java）時才產生）
靜態成員方法沒有this引用；
在沒有實例化對象時，可以通過類名訪問靜態成員方法。

靜態方法不能直接操作非靜態的屬性和方法

加上static后，就可以操作了

package test;

class Dog {
  private static int count = 0;  //靜態成員變量

  public Dog() {
    count++;
  }

  //顯示數量的方法，靜態成員方法
  public static void displayCount() {
    System.out.println("當前狗的數量是：" + count);
  }
}

public class Test {
  public static void main(String[] args) {
    //沒有實例化對象之前，直接通過類名調用靜態成員方法
    Dog.displayCount();
    Dog d1 = new Dog();
    Dog d2 = new Dog();
    Dog.displayCount();
  }
}

12、包

有時候，類和類的名稱可能發生沖突；Java提供了把類名空間劃分為更容易管理的塊的機制，這就是包；包允許將類組合成較小的單元，類似于文件夾。

• 有助于避免命名沖突，分屬不同包的類即便名稱相同也不會引起誤會。
• 能在包與包之間對于類的訪問權限提供更有力的約束。

（1）缺省包

如果省略了package語句，類將保存在一個缺省的沒有名稱的包中；
盡管缺省包很方便，但對于大型的程序，它是不恰當的；
請盡量為自己編寫的類定義具體的包。

（2）使用package關鍵字打包

可以使用package關鍵字將源文件中的類打入某個包中，語法是：

package 包名;

該語句必須是整個源文件的第一條語句。

package mypkg;      //將本源文件中的所有類打到mypkg包中

class Student {      //定義學生類
    ……
}

（3）使用import關鍵字導入包

如要使用到某個包中的類，就需要使用import關鍵字將包或類顯式地包括到程序中。有如下兩種情況：

/*導入java包下的io子包中的所有類*/
import java.io.*;

/*導入mypkg包下的Student類，但并不導入該包中的其它類*/
import mypkg.Student;
……

一個程序中允許有多條import語句，導入多個包或多個類。