什么是面向物件，什么是面向程序

 面向程序： 1.把冰箱打開 2. 把大象放入 3. 冰箱關起來 
 面向物件： 打開冰箱，儲存，關閉都是對冰箱的操作，是冰箱的行為，
 冰箱就是一個物件，所以只要操作冰箱所具備的功能，都要定義在冰箱中，

不知以上解釋可否滿意呢？

面向物件概念

1. 面向物件是思考問題的一種思考方式，是一種思想，比如：概念與實體，理論與實踐，名和實等等，，
2. 類就是一類物件的統稱，物件就是這一類具體化的一個實體，
3. 面向物件的好處：將復雜的事情變簡單了，只要面對一個物件就行，

面向物件設計

面向物件設計把握一個重要的經驗：誰擁有資料，誰對外提供操作這些資料（私有）的方法！（被動的一方是資料的擁有者，主動的一方是執行者）
開發時：找物件，建物件，用物件，并維護物件之間的關系， 以后學習程序當中，我們會就這三點進行深入學習，

  說了那么多該來點實際操作了

正文開始類的創建以及實體化

我先拿來一串代碼，

class Person {
    public int age;//成員屬性 實體變數
    public String name;
    public String sex;
    public void eat() {//成員方法
       System.out.println("吃飯!");  
   }
    public void sleep() {
       System.out.println("睡覺!");  
   }
}

我們要知道，以上代碼就是類的創建，創建類的關鍵字就是class； Person 也就是我們C語言說的結構體（比結構體要牛）也就是自定義型別， public 叫做訪問修飾符，也就是我們所說的權限，public 就是公有的，大家都能使用的，那么什么又是實體化類呢？

Person person = new Person();

那么這個就是實體化Person類，
這就是 類的創建和實體化了，

怎么使用這個類

使用 . 來訪問物件中的屬性和方法.
下面看代碼，

class Person {
    public int age;//成員屬性 實體變數
    public String name;
    public String sex;
    public void eat() {//成員方法
        System.out.println("吃飯!");
    }
    public void sleep() {
        System.out.println("睡覺!");
    }
}

public class Test {
    public static void main(String[] args) {
        Person person  = new Person();
        person.name = "WeiRan";
        person.sex = "男";
        person.age = 19; //因為類中 age為int型，所以person.age也是整型，因為我們是用過物件訪問的年齡，
        System.out.println(person.name);
        System.out.println(person.sex);
        System.out.println(person.age);
    }
}

代碼有點長，但我相信很好理解，畢竟我在中間也加了注釋呢，在這里我們發現可以直接賦值，，簡單嘛？簡單的很啊，下面我說一下注意事項

1. new 關鍵字用于創建一個物件的實體.
2. 使用 . 來訪問物件中的屬性和方法.
3. 同一個類可以創建多個實體.
   對于 同一個類可以創建多個實體. 這句話的理解呢，我們看一個代碼；便可以理解

        Person person  = new Person();
        Person person1  = new Person();
        Person person2  = new Person();
        Person person3  = new Person();
        Person person4 = new Person();

我們可以用這樣的方式實作代碼，每次new一個便可以在堆區創建一塊空間，在這里我要給大家擴展一點

擴展

1 在代碼：Person person = new Person(); 中，person在堆疊區存盤 它身上存著一塊地址，比如我運行一下，

你們看，運行結果是類名+字符@+地址，當然我們如何解決這個問題呢，比如我們如果想要輸出類內的元素
我說下步驟：

1. 將滑鼠游標移動到類內，按住alt+ins鍵ins也就是我們平常所說的插入鍵
2. 他會彈出這樣的小框框，我們選擇toString()；
3. 我們將其全部選中再點擊ok即可，代碼將會自動補入，
   做好這一切，我們再運行一遍，看看結果是否滿意：

這個結果便是我們想要的了，當然有點小知識：new再堆區開空間，有默認值的，大家可以看我之前寫的博客 在這里我就說一下，參考型別默認為null

介紹null

null 在 Java 中為 “空參考”, 表示不參考任何物件. 類似于 C 語言中的空指標. 如果對 null 進行 . 操作就會引發例外.

欄位/屬性/成員變數

其實我們再類內定義的變數 就被成為 欄位，屬性，成員變數 我們不強制叫做什么，比如我就喊他元素，

欄位就地初始化

什么是就地初始化呢，就是在類內對欄位進行初始化，

class Person {
    public String name = "張三";
    public int age = 18; }

這就叫就地初始化 當然 我們這樣初始化可以理解為在方法內使用時，我們如果是初始化這個類，那么name，age欄位就有了初始值

方法

方法就是類內使用方法，大家可以看代碼！其實這個知識點特別簡單哦

class Person {
    public int age;//成員屬性 實體變數
    public String name = "Weiran";
    public String sex;
    public void eat() {//成員方法
        System.out.println("吃飯!");
    }
    public void sleep() {
        System.out.println("睡覺!");
    }

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

public class Test {
    public static void main(String[] args) {
        Person person  = new Person();
        person.eat();
    }
}

看這個代碼，，其實就是呼叫類里面的函式，就完了，好了，以上就是 類的基礎了，下一個模塊就要變的難咯，建議大家看到這里先去練練手，把類吃明白了，再繼續看

static 在類中的使用

修飾屬性

由上文我相信大家可以知道 屬性，欄位，成員變數是一個東西，也就是我們類里面的變數，一個類如果是一個集合的話，那么屬性/欄位就是元素，下面看一遍代碼吧，在下將用代碼解釋所有

class Person{
    public static int count;
    public int n;
}

定義方法很簡單咯，就是將count定義成靜態的整型變數，權限為公開，下面我讓你看看他的不同之處在哪里吧

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

這串代碼便是直接使用的上圖中的類，大家運行可以發現，靜態變數 ： p1.count++ 第一次執行的時候從0變成了1 第二次執行則是再 1 的基礎上再加，而非靜態變數呢，定義一次初始化一次，看到這里 再聯想之前的知識，我們就可以發現，在類中普通變數在使用時，則是在不同堆區進行改變， 而 new p2 是 count 使用的還是原來那塊空間，當然在這里我就不讓大家思考了，我直接說原因了

1. 首先，類開辟實在堆區，每次new一下就會在堆區再次開辟一個空間
2. 靜態變數存在靜態區，count使用時應為類名.count
   看完以上兩點是不是就明白了很多了？ 既然時類名.count 我們會發現他們似乎就是一樣噠，
   當然我們之前使用p1,p1時 我們會發現 編譯器會給我們警告的，而換成類名.count 則沒有，
   
   大家看以上兩行代碼 使用p1.count 帶陰影 便是警告，而類名.count 則沒有陰影

修飾方法

      如果在任何方法上應用 static 關鍵字，此方法稱為靜態方法

看到上面這句話 我們應該就知道上面時靜態方法了 下面我給大家介紹幾點重點吧

1. 靜態方法屬于類，而不屬于類的物件，
2. 可以直接呼叫靜態方法，而無需創建類的實體，
3. 靜態方法可以訪問靜態資料成員，并可以更改靜態資料成員的值，
   對于第一點我們應該怎么理解呢？
   有靜態變數，我們發現，靜態變數要用類名實作，而不能使用類名new出來的物件實作，所以我們說靜態方法屬于類，而不屬于類的物件，
   那么第二句話呢？我們可以看一個代碼
   
   其實第二句話的意思就是，我們使用靜態方法的時候 直接使用類名.方法 即可不需要再new出來一個老婆，再用老婆召喚這個方法了，
   下面開始理解第三句話，

    public static void show(){
        System.out.println("Hello World!!!");
        count = 10;
    }

    public void exitInt(){
        count = 20;
    }

小編建議大家將這一步放到編譯器上，交換順序看列印結果，，我們會發現，count始終等于10；
當然在這里 靜態變數不能呼叫非靜態變數的值，

還有一點大家一定要避坑，就是非靜態方法不能改變靜態變數的值，但是訪問并不報錯，所以以后如果在這里寫錯 可是會很頭疼的哦！！！

封裝

下面我們開始介紹封裝，什么叫封裝呢？封裝就是將資料保存起來，提高java資料的安全型，不讓別人看見，

<<代碼大全>> 開篇就在討論一個問題: 軟體開發的本質就是對程式復雜程度的管理. 如果一個軟體代碼復雜程
度太高, 那么就無法繼續維護. 如何管理復雜程度? 封裝就是最基本的方法.
在我們寫代碼的時候經常會涉及兩種角色: 類的實作者和類的呼叫者.
封裝的本質就是讓類的呼叫者不必太多的了解類的實作者是如何實作類的, 只要知道如何使用類就行了.
這樣就降低了類使用者的學習和使用成本, 從而降低了復雜程度

1. 被 public 修飾的成員變數或者成員方法, 可以直接被類的呼叫者使用.
2. 被 private 修飾的成員變量或者成員方法, 不能被類的呼叫者使用.
   下面我們開始使用private以及public 當然public我們前面就一直使用 就是公開的，大家都可以用啊
   但是我們如果把這些每個資料都公開了，又誰想用誰用，豈不是一點安全性沒有了，
   其實在這里我們主要是會用這些就好啦，我直接用代碼表示使用吧，

class Person { 
 private String name = "張三"; 
 private int age = 18; 
 
 public void show() { 
 System.out.println("我叫" + name + ", 今年" + age + "歲"); 
 } 
} 
class Test { 
 public static void main(String[] args) { 
 Person person = new Person(); 
 person.show(); 
 } 
}

這個代碼可以看出，我們的private 修飾完名字和年齡后，再主方法里并不能訪問名字和年齡了，只能通過類內的方法進行訪問，這樣就提高了java語言的安全程度，

注意事項

1. private 不光能修飾欄位, 也能修飾方法
2. 通常情況下我們會把欄位設為 private 屬性, 但是方法是否需要設為 public, 就需要視具體情形而定. 一般我們希望一個類只提供 “必要的” public 方法, 而不應該是把所有的方法都無腦設為 public.

在類內使用方法這一塊對外使用介面，

這一塊我不怎么建議大家使用，因為有很多邏輯上的問題，尤其是對于初學者，這些省事的方法不好，下面我就簡單介紹一下省事的方法把，還是alt+ins鍵之后選擇 getter或者setter 然后選擇你需要對外使用的介面即可，—再次強調，不建議使用

main方法為什么要使用static呢？

首先我們知道，不用static便需要在main 執行前對main進行開辟空間，而main又是程式首先執行的，我們想想都矛盾啊，是不是，

this 的使用

this有三種方法，下面我介紹一種：看一下代碼

    class Person{
       public  String name;
       public  void setName(String name){
           name = name;
       }

       
    }
    public class Test{
        public static void main(String[] args) {
            Person p = new Person();
            p.setName("Weiran");
            System.out.println(p.name);
        }

大家猜猜這一塊代碼的執行結果是多少呀！！ 毫無疑問，是Weiran，哎！！其實沒有疑問歸沒有疑問，對不對看運行結果把！

哇哦最后的結果居然是null 為什么呢？ 聽我解釋把，，是因為區域變數優先，那么我們如何杜絕這個呢？我們在第一個name前面加一個this.即可

大家看 這樣就沒問題了，在這里，我就不說this的用法了，我相信，只要你比我聰明你就能理解this的用法了，

構造方法

1.如果類中沒有提供任何的建構式，那么編譯器會默認生成一個不帶有引數的建構式
2.若類中定義了構造方法，則默認的無參構造將不再生成.
3.構造方法支持多載. 規則和普通方法的多載一致
以上三點給大家介紹，系統會自帶一個建構式，但是，建構式內什么都沒有，而第二點定義建構式的方法是什么呢？

看到沒有，建構式的使用，實在類實體化的時候就已經執行了滴！！
當然 構造方法也是方法也有引數，那么他就支持多載 這里無需多言，

代碼塊

普通代碼塊

普通代碼塊是定義在方法種的

public class Main{ 
 public static void main(String[] args) { 
 { 
 int x = 10 ; 
 System.out.println("x1 = " +x); 
 } 
 int x = 100 ; 
 System.out.println("x2 = " +x); 
 } 
}

直接{}的代碼那一塊就是普通代碼塊 這種方法很少用，因為用了和沒用并沒啥區別啊，

構造代碼塊

構造代碼塊是在類中，不是構造方法，也叫實體代碼塊

class Person{ 
 private String name;//實體成員變數
 private int age; 
 private String sex; 
 public Person() { 
 System.out.println("I am Person init()!"); 
 } 
 //實體代碼塊
 { 
 this.name = "bit"; 
 this.age = 12; 
 this.sex = "man"; 
 System.out.println("I am instance init()!"); 
 } 
 public void show(){ 
 System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
 } 
} 
public class Main { 
 public static void main(String[] args) { 
 Person p1 = new Person(); 
 p1.show(); 
 } 
}

在方法里 建構式的那一塊就是構造代碼塊，
注意事項: 實體代碼塊優先于建構式執行，

靜態代碼塊

 static { 
 count = 10;//只能訪問靜態資料成員 
 System.out.println("I am static init()!"); 
 }

就像這樣 直接使用static 定義的代碼塊就是靜態代碼塊！！
靜態代碼塊優先于 實體代碼塊
其實通過上面的介紹，我相信大家對類與方法這一部分都能有非常深入的理解

匿名物件

匿名只是表示沒有名字的物件
注意事項有三點

1. 沒有參考的物件稱為匿名物件.
2. 匿名物件只能在創建物件時使用.
3. 如果一個物件只是用一次, 后面不需要用了, 可以考慮使用匿名物件.
   下面我直接放一個代碼把”

class Person { 
 private String name; 
 private int age; 
 public Person(String name,int age) { 
 this.age = age; 
 this.name = name; 
 } 
 public void show() { 
 System.out.println("name:"+name+" " + "age:"+age); 
 } 
} 
public class Main { 
 public static void main(String[] args) { 
 new Person("caocao",19).show();//通過匿名物件呼叫方法
 } 
}

這就是使用了，配上上面的內容我相信大家都能很容易的理解了，

總結

1. 一個類可以產生無數的物件，類就是模板，物件就是具體的實體，
2. 類中定義的屬性，大概分為幾類：類屬性，物件屬性，其中被static所修飾的資料屬性稱為類屬性, static修飾的
3. 方法稱為類方法，特點是不依賴于物件，我們只需要通過類名就可以呼叫其屬性或者方法，
4. 靜態代碼塊優先實體代碼塊執行，實體代碼塊優先建構式執行，
5. this關鍵字代表的是當前物件的參考，并不是當前物件，

關于小編

小編是一名正在奮斗的大一小騷年，希望能與大家一起學習哦，在編程的路上也希望能有朋友一起學習！！！這篇博客 是小編自己理解的寫的，所以，有些地方可能有所不足，忘大家給予指點，錯的越多后期越吃香，
小編qq號：2206730228
希望能與大家一起學習哦！！！！！！