一、面向對象 二、類與對象 三、局部變量和成員變量的關係 四、封裝思想 五、private,this關鍵字 六、隨機點名器

01面向對象和麪向過程的思想

* A: 面向過程與面向對象都是咱們編程中，編寫程序的一種思惟方式
    * a: 面向過程的程序設計方式，是遇到一件事時，思考「我該怎麼作」，而後一步步實現的過程。
    * b: 面向對象的程序設計方式，是遇到一件事時，思考「我該讓誰來作」，而後那個「誰」就是對象，他要怎麼作這件事是他本身的事，反正最後一羣對象協力能把事就好就好了。

02面向對象的思想的生活案例

* A: 買電腦（組裝機）
    * a: 面向過程：本身該怎麼作
    * b: 面向對象：找人幫咱們作

03面向對象好處

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

04大象裝進冰箱的代碼案例

* A: 需求：把大象裝冰箱裏
    * a: 面向過程         
        * 本身打開冰箱門
        * 本身將大象裝進去
        * 本身關閉冰箱門    
    * b: 面向對象
        * 分析發現打開、裝、關閉都是冰箱的功能。即冰箱對象具    備以下功能
        * 冰箱打開
        * 冰箱存儲
        * 冰箱關閉

* B: 經過僞代碼描述大象和冰箱
    * 描述大象：
        class 大象
        {
        }
    * 描述冰箱
        class冰箱
        {
            void 打開(){}
            void 存儲(大象){}
            void 關閉(){}
        }

        
* C: 使用對象：
    * 一、建立冰箱的對象
        * 冰箱 bx = new 冰箱();  
    * 二、調用冰箱的功能
        * 對象.功能()；
        * bx.打開();
        * bx.存儲(new 大象());
        * bx.關閉();
* D：總結：
    * 一、先按照名詞提煉問題領域中的對象
    * 二、對對象進行描述，其實就是在明確對象中應該具有的屬性和功能
    * 三、經過new的方式就能夠建立該事物的具體對象
    * 四、經過該對象調用它之後的功能。

05定義小汽車類

* A: 分析小汽車的屬性和功能
    * 屬性
        * 顏色
        * 輪胎個數
    * 功能
        * 運行    
* B: 經過僞代碼描述小汽車
    * 小汽車{
        * 顏色
        * 輪胎個數
        * 運行(){}
    * }
* C：經過JAVA代碼描述小汽車
    * public class Car {
        * String color;
        * int number;
    
        * void run() {
            * System.out.println(color + ":" + number);
        * }
    * }

01測試汽車類

* A: 創見對象的格式
    * a: 類名 變量名 = new 類名();
* B: 測試汽車類
    public class CarDemo {
        public static void main(String[] args) { 
            /*
             測試：Car類中的run方法。
             */
            // 1,建立Car的對象。給對象起個名字。
            Car c = new Car();// c是類類型的變量。c指向了一個具體的Car類型的對象。
            // 2,經過已有的對象調用該對象的功能。格式：對象.對象成員;
            // 3,能夠該對象的屬性賦值。
            c.color = "red";
            c.number = 4;
            c.run();
        }
    }

02對象的內存圖

* 見課後資料：對象的內存圖.JPG

03類和對象的關係

* A: 類和對象的關係
    * 類是對某一類事物的抽象描述，而對象用於表示現實中該類事物的個體
* B: 舉例
    * 能夠將玩具模型看做是一個類，將一個個玩具看做對象，從玩具模型和玩具之間的關係即可以看出類與對象之間的關係

04成員變量和局部變量的區別

• 區別一：定義的位置不一樣

  • 定義在類中的變量是成員變量

  • 定義在方法中或者{}語句裏面的變量是局部變量

• 區別二：在內存中的位置不一樣

  • 成員變量存儲在對內存的對象中

  • 局部變量存儲在棧內存的方法中

• 區別三：聲明週期不一樣

  • 成員變量隨着對象的出現而出如今堆中，隨着對象的消失而從堆中消失

  • 局部變量隨着方法的運行而出如今棧中，隨着方法的彈棧而消失

• 區別四：初始化不一樣

  • 成員變量由於在堆內存中，全部默認的初始化值

  • 局部變量沒有默認的初始化值，必須手動的給其賦值纔可使用。

01方法參數是基本數據類型和引用數據類型

* A.基本類型
    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;
            
        }
    }     
    基本類型做爲參數傳遞時，其實就是將基本類型變量x空間中的值複製了一份傳遞給調用的方法show()，當在show()方法中x接受到了複製的值，再在show()方法中對x變量進行操做，這時只會影響到show中的x。當show方法執行完成，彈棧後，程序又回到main方法執行，main方法中的x值仍是原來的值。
* B.引用類型
    class Demo 
    {
        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;
        }
    }     
    當引用變量做爲參數傳遞時，這時實際上是將引用變量空間中的內存地址(引用)複製了一份傳遞給了show方法的d引用變量。這時會有兩個引用同時指向堆中的同一個對象。當執行show方法中的d.x=6時，會根據d所持有的引用找到堆中的對象，並將其x屬性的值改成6.show方法彈棧。
    因爲是兩個引用指向同一個對象，不論是哪個引用改變了引用的所指向的對象的中的值，其餘引用再次使用都是改變後的值。
* C.結論
    * 對於基本類型形式參數改變不會影響到實際參數
    * 對於引用類型形式參數改變會影響到實際參數

02封裝的概述

* A.面向對象三大特徵
    * 封裝、繼承、多態
* B.封裝表現
    * 一、方法就是一個最基本封裝體
    * 二、類其實也是一個封裝體    
* C.封裝的好處
    * 一、提升了代碼的複用性
    * 二、隱藏了實現細節，還要對外提供能夠訪問的方式。便於調用者的使用。這是核心之一，也能夠理解爲就是封裝的概念
    * 三、提升了安全性

03封裝的生活中的舉例

* A.封裝的生活中的舉例
    機箱：
    一臺電腦，它是由CPU、主板、顯卡、內存、硬盤、電源等部件組長，其實咱們將這些部件組裝在一塊兒就可使用電腦了，可是發現這些部件都散落在外面，很容形成不安全因素，因而，使用機箱殼子，把這些部件都裝在裏面，並在機箱殼上留下一些插口等，若不留插口，你們想一想會是什麼狀況。
    總結：機箱其實就是隱藏了辦卡設備的細節，對外提供了插口以及開關等訪問內部細節的方式。
* B.總結
    * 機箱其實就是隱藏了辦卡設備的細節，對外提供了插口以及開關等訪問內部細節的方式

04private關鍵字

* A.private概述
    * private能夠修飾成員內容包括成員方法和成員變量
    * 被private修飾的內容不能在其餘類訪問
* B.使用步驟
    * 一、經過private修飾屬性
* C.完整代碼 
    class Person {
        private int age;
        private String name;
    
        public void show() {
            System.out.println("age=" + age + ",name" + name);
        }
    }

01get和set方法

* A.get和set方法
    * 年齡已被私有，錯誤的值沒法賦值，但是正確的值也賦值不了，這樣仍是不行，那腫麼辦呢？按照以前所學習的封裝的原理，隱藏後，還須要提供訪問方式。只要對外提供能夠訪問的方法，讓其餘程序訪問這些方法。同時在方法中能夠對數據進行驗證。

通常對成員屬性的訪問動做：賦值(設置 set)，取值(獲取 get)，所以對私有的變量訪問的方式能夠提供對應的 setXxx或者getXxx的方法。

class Person {
        // 私有成員變量
        private int age;
        private String name;
    
        // 對外提供設置成員變量的方法
        public void setAge(int a) {
            // 因爲是設置成員變量的值，這裏能夠加入數據的驗證
            if (a < 0 || a > 130) {
                System.out.println(a + "不符合年齡的數據範圍");
                return;
            }
            age = a; 
        }
    
        // 對外提供訪問成員變量的方法
        public void getAge() {
            return age;
        }
    }
    * 總結
        * 類中不須要對外提供的內容都私有化，包括屬性和方法。

之後再描述事物，屬性都私有化，並提供setXxx getXxx方法對其進行訪問

* 注意
        * 私有僅僅是封裝的體現形式而已

02私有化Person類帶get,set

* 標準代碼
    package cn.itcast.demo05;
    
    /*
     *   類描述人:
     *     屬性: 姓名和年齡
     *     方法: 說話
     *   
     *   私有化全部的屬性 (成員變量) ,必須寫對應的get/set方法
     *   凡是自定義的類,自定義成員變量,應該私有化,提供get/set
     *   
     *   this關鍵字:
     *     區分紅員變量和局部變量同名狀況
     *     方法中,方位成員變量,寫this.
     */
    public class Person {
        private String name;
        private int age;
    
        // set方法,變量name,age賦值
        public void setAge(int age) {
            this.age = age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        // get方法,變量name,age獲取值
        public int getAge() {
            return age;
        }
    
        public String getName() {
            return name;
        }
    
        public void speak() {
            String  name = "哈哈";
            int age = 16;
            
            System.out.println("人在說話  " + this.name + "..." + this.age);
        }
    }
* 標準測試代碼
    package cn.itcast.demo05;
    
    public class PersonTest {
        public static void main(String[] args) {
            Person p = new Person();
            //調用set方法,對成員變量賦值
            p.setAge(18);
            p.setName("旺財");
            p.speak();
            
            
            //調用get方法,獲取成員變量的值
    //        System.out.println(p.getName());
    //        System.out.println(p.getAge());
        }
    }

03this關鍵字_區分紅員變量和局部變量的同名

* A.何時用
    * 當類中存在成員變量和局部變量同名的時候爲了區分，就須要使用this關鍵字
* B.代碼
    class Person {
        private int age;
        private String name;
        
        public void speak() {
            this.name = "小強";
            this.age = 18;
            System.out.println("name=" + this.name + ",age=" + this.age);
        }
    }
    
    class PersonDemo {
        public static void main(String[] args) {
            Person p = new Person();
            p.speak();
        }
    }

04this內存圖

* A.this內存圖
    * 見附件：this內存圖.jpg

01this的年齡比較

* A.需求：在Person類中定義功能，判斷兩我的是不是同齡人
* B.代碼
    class Person {
        private int age;
        private String name;
        
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void speak() {
            System.out.println("name=" + this.name + ",age=" + this.age);
        }
    
        // 判斷是否爲同齡人
        public boolean equalsAge(Person p) {
            // 使用當前調用該equalsAge方法對象的age和傳遞進來p的age進行比較
            // 因爲沒法肯定具體是哪個對象調用equalsAge方法，這裏就可使用this來代替
            /*
             * if(this.age == p.age) { return true; } return false;
             */
            return this.age == p.age;
        }
    }

02隨機點名器案例重構

* A.需求：隨機點名器，即在全班同窗中隨機的找出一名同窗，打印這名同窗的我的信息
    它具有如下3個內容：
    存儲全部同窗姓名
    總覽全班同窗姓名
    隨機點名其中一人，打印到控制檯
* B.代碼
    import java.util.ArrayList;
    import java.util.Random;
    import java.util.Scanner;
    
    /**
     * 思路：
     * 第一步：存儲全班同窗信息
     * 第二步：打印全班同窗每個人的信息
     * 第三部：隨機對學生點名，打印學生信息
     */
    public class Test {
        public static void main(String[] args) {
            ArrayList<Student> list = new ArrayList<Student>(); //1.1建立一個能夠存儲多個同窗名字的容器
             //1.存儲全班同窗信息
            addStudent(list);
             //2.打印全班同窗每個人的信息（姓名、年齡）
            printStudent(list);
             //3.隨機對學生點名，打印學生信息
            randomStudent(list);
        }
        public static void addStudent(ArrayList<Student> list) {
            //鍵盤輸入多個同窗名字存儲到容器中
            Scanner sc = new Scanner(System.in);
            for (int i = 0; i < 3; i++) {
                //建立學生
                Student s = new Student();
                System.out.println("存儲第"+i+"個學生姓名：");
                String name = sc.next();
                s.setName(name);
                System.out.println("存儲第"+i+"個學生年齡：");
                int age = sc.nextInt();
                s.setAge(age);
                //添加學生到集合
                list.add(s);
            }
        }
        /**
         2.打印全班同窗每個人的信息（姓名、年齡）
         */
        public static void printStudent (ArrayList<Student> list) {
            for (int i = 0; i < list.size(); i++) {
                Student s = list.get(i);
                System.out.println("姓名："+s.getName() +",年齡："+s.getAge());
            }
        }
        /**
         3.隨機對學生點名，打印學生信息
         */
        public static void randomStudent (ArrayList<Student> list) {
            //在班級總人數範圍內，隨機產生一個隨機數
            int index = new Random().nextInt(list.size());
            //在容器（ArrayList集合）中，查找該隨機數所對應的同窗信息（姓名、年齡）
            Student s = list.get(index);
            System.out.println("被隨機點名的同窗："+s.getName() + "，年齡:" + s.getAge());
        }
    }

    /**
     * 學生信息類
     */
    public class Student {
        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;
        }
    }

03總結

• A.類與對象

  • 類，用於描述多個對象的共同特徵，它是對象的模板。

  • 對象，用於描述現實中的個體，它是類的實例。

  • 類的定義：使用關鍵字class來定義java中的類

  • 格式：

  • class 類名 {

  • //屬性

  • 數據類型 變量名;

  • …

  • //方法

  • 修飾符 返回值類型 方法名(參數){ }

  • …

  • }

• B.建立對象：

  • 格式：

  • 類名 對象名 = new 類名();

• C.封裝（private關鍵字）

  • 封裝，把對象的屬性與方法的實現細節隱藏，僅對外提供一些公共的訪問方式

  • 封裝的體現：

  • 變量:使用 private 修飾，這就是變量的封裝

  • 方法:也是一種封裝，封裝了多條代碼

  • 類： 也是一種封裝，封裝了多個方法

• D.private關鍵字，私有的意思

  • 它能夠用來修飾類中的成員(成員變量，成員方法)

  • private的特色：

  • private修飾的成員只能在當前類中訪問，其餘類中沒法直接訪問

• E.this關鍵字

  • this關鍵字，本類對象的引用

  • this是在方法中使用的，哪一個對象調用了該方法，那麼，this就表明調用該方法的對象引用

  • this何時存在的？當建立對象的時候，this存在的

  • this的做用：用來區別同名的成員變量與局部變量（this.成員變量）

  • public void setName(String name) {

  • this.name = name;

  • }