5、Java中的面向對象(1)筆記_ZenDei技術網路在線

1、面向對象 VS 面向過程 2、面向對象的編程關註於類的設計！ 2.1、一個項目或者工程不管多龐大一定是有一個一個的類構成的。 2.2、類是抽象的，好比是製造汽車的圖紙。而具體的一輛一輛的車，是根據圖紙製造的，實際上就是類的實例化 3、完成一個項目(或功能)的思路 3.1、所要完成的功能對應的類的 ...

1、面向對象 VS 面向過程

 1 /*
 2  * 理解一：人開門
 3  * 面向過程：人 打開門
 4  * 面向對象：
 5  * 人{
 6  *    打開(){
 7  *        門。開開();
 8  *    }
 9  * }
10  * 門{
11  *     開開(){
12  *     }
13  * }
14  * 
15  * 理解二：人把大象裝進冰箱
16  * 面向過程：
17  *     1、打開冰箱；
18  *     2、把大象放進去；
19  *     3、關閉冰箱門；
20  * 面向對象：
21  * 人{
22  *     打開(冰箱){冰箱.開開()}
23  *     操作(大象){大象。進入(冰箱)}
24  *     關閉(冰箱）{冰箱。合上()}
25  * }
26  * 大象{
27  *     進入(冰箱){}
28  * }
29  * 冰箱{
30  *     開開(){}
31  *     合上(){}
32  * }
33  */

2、面向對象的編程關註於類的設計！

　　2.1、一個項目或者工程不管多龐大一定是有一個一個的類構成的。

　　2.2、類是抽象的，好比是製造汽車的圖紙。而具體的一輛一輛的車，是根據圖紙製造的，實際上就是類的實例化

 1 /*
 2  * 1、面向對象的編程關註於類的設計
 3  * 2、設計類實際上就是設計類的成員
 4  * 3、基本的類的成員，屬性(成員變數或Field)&方法（Method）
 5  */
 6 public class TestPerson {
 7     public static void main(String[] args) {
 8         Person p1 = new Person();
 9         p1.info();
10         
11         p1.name = "鐘超";
12         p1.age = 21;
13         p1.sex = true;
14         p1.info();
15         
16         p1.setName("張三");//p1.name = "張三"
17         p1.info();
18         
19         Person p2 = p1;
20         System.out.println("P1:" + p1);
21         System.out.println("P2:" + p2);
22         p2.info();
23         
24         p2 = new Person();
25         System.out.println("P2:" + p2);
26         p2.info();
27         //實例化Scanner類的對象，通過此對象.nextXxx的方法進行調用，完成相應的功能；
28         Scanner s = new Scanner(System.in);
29         int i = s.nextInt();
30         
31         Person p3 = new Person();
32         p3.info();
33     }
34 }
35 //類：是抽象的。
36 class Person{
37     //1.屬性
38     String name;
39     int age = 10;
40     boolean sex;
41     
42     //2.方法
43     public void eat(){
44         System.out.println("人吃飯");
45     }
46     public void sleep(){
47         System.out.println("人睡覺");
48     }
49     
50     public String getName(){
51         return name;
52     }
53     public void setName(String n){
54         name = n;
55     }
56     
57     public void info(){
58 //        eat();
59 //        sleep();
60         System.out.println("name:" + name + "age:" + age + "sex:" + sex);
61     }
62 }

3、完成一個項目(或功能)的思路

　　3.1、所要完成的功能對應的類的對象是否存在；

　　3.2、若存在，則通過對象直接調用對應的類中的屬性或方法即可；

　　3.3、若不存在，需要創建類的對象。甚至說，類都不存在就需要設計類；

4、面向對象編程的三條主線：

　　1、類以及類的構成成分：屬性方法構造器代碼塊內部類

　　2、面向對象編程的特征：封裝性繼承性多態性 (抽象性)

　　3、其他的關鍵字：this super package import static final abstract interface...

類：

1、關註於類的設計

2、類的組成成分：

　　1、屬性(成員變數，Field)

　　2、方法(成員方法，函數，Method)

3、關於屬性：

4、方法：

  1 /*
  2  * 一、面向對象思想的落地法則一：
  3  * 1.設計類並設計類的成員（成員變數&方法）
  4  * 2.通過類來創建類的對象（也稱作類的實例化）
  5  * 3、通過“對象。屬性”或“對象。方法”來調用，完成相應的功能
  6  * 
  7  * 二、創建的多個對象，彼此各自擁有一套類的屬性，當對其中一個對象的屬性進行修改時。
  8  * 不會影響到其他對象的屬性值。
  9  * 
 10  * 三、類的屬性(成員變數)
 11  *     成員變數    VS     局部變數
 12  *     相同點：1、遵循變數聲明的格式；數據類型 變數名 = 初始化值；
 13  *          2、都有作用域：
 14  *     不同點：1、聲明的位置的不同：成員變數：生命在類里，方法外邊；
 15  *                               局部變數：聲明在方法內，方法的形參部分，代碼塊內
 16  *          2、成員變數的修飾符有四個：public(公共的) private(私有的) protected 預設
 17  *                    局部變數沒有修飾符：與所在的方法的修飾符一樣；
 18  *          3、初始化值：一定會有初始化值；
 19  *                   成員變數：如果在聲明的時候，不顯示的賦值，那麼不同的數據類型會有不同的預設初始化值；
 20  *                 byte short int long = 0；
 21  *                 float double = 0。0；
 22  *                 char = 空格；
 23  *                 boolean = false；
 24  *                 引用類似的變數  = null；
 25  *                  局部變數：一定要顯示的賦值（局部變數沒有預設初始化值）；
 26  *          4、二者在記憶體中存放的位置不同，成員變數在堆空間中，局部變數在棧空間中；
 27  * 總結：關於變數的分類：1、按照數據類型的不同：基本數據類型(8種)&引用數據類型
 28  *                  2、按照聲明位置的不同：：成員變數&局部變數
 29  * 
 30  * 四、類的方法：提供某種功能的實現
 31  *         1、實例    public void eat(){方法體}
 32  *               public String getName(){}
 33  *               public void setName(String n){}
 34  *         2、格式：許可權修飾符  返回值類型(void：無返回值/具體返回值) 方法名(形參){}
 35  *         3、關於返回值類型 void：表名此方法不需要返回值 
 36  *                     有返回值的：在方法的最後一定有return + 返回值類型對應的變數
 37  *           記憶：void與return不可以同時出現在一個方法內。
 38  *         4、方法內可以調用本類的其他方法和屬性，但是不能再方法內在定義其他方法；
 39  * 
 40  * ClassRoom Car ...
 41  */
 42 public class Zoo {
 43     public static void main(String[] args) {
 44         //基本數據類型的聲明：數據類型 變數名 = 初始化值；
 45         int i = 10;
 46         //1.類的實例化：如下的a1就是一個實實在在的對象
 47         Animal a1 = new Animal();
 48         //int[] arr = new int[10];
 49         //通過對象調用屬性
 50         a1.name = "花花";
 51         a1.age = 3;
 52         System.out.println("name:" + a1.name + "\t" + "age:" + a1.age);
 53         //通過對象調用方法
 54         a1.eat();
 55         a1.sleep();
 56         
 57         //在創建一個對象
 58         Animal a2 = new Animal();
 59         System.out.println("name:" + a2.name + "\t" + "age:" + a2.age);
 60         a2.name = "小花";
 61         System.out.println("name:" + a1.name + "\t" + "age:" + a1.age);
 62         System.out.println("name:" + a2.name + "\t" + "age:" + a2.age);
 63         //a3與a1一樣,a3不意味著相較於a1重新創建的一個對象，而是a1與a3共用一個對象實體
 64         Animal a3 = a1;
 65         System.out.println("name:" + a3.name + "\t" + "age:" + a3.age);
 66         a3.name = "維尼熊";
 67         System.out.println("name:" + a1.name + "\t" + "age:" + a1.age);
 68         
 69         System.out.println(a2.getName());
 70         System.out.println(a2.desc());
 71     }
 72 }
 73 
 74 class Animal{
 75     //1.屬性
 76     String name;
 77     int age;
 78     //2.方法
 79     public void eat(){
 80         System.out.println("動物進食");
 81     }
 82     public void sleep(){
 83         System.out.println("動物休眠");
 84         //return;
 85     }
 86     public String getName(){
 87         return name;
 88     }
 89     public int getAge(){
 90         return age;
 91         //其後不可以聲明語句
 92         //System.out.println("Hello");
 93     }
 94     //當通過對象調用此方法是，會將方法的返回值提供給方法的調用者，也就是當前的對象。
 95     public String desc(){
 96         if(age > 2){
 97             return "恰同學少年";
 98         }else{
 99             return "還是看動畫片的 年齡";
100         }
101     }
102     public void setName(String n){
103         name = n;
104     }
105     public void addAge(){
106         int i = 2;
107         age += i;
108     }
109     public void info(){
110         //可以在方法內調用本類的其他方法，但是不可以在方法內在定義新德爾方法
111         eat();
112         sleep();
113 //        public void breathJ(){
114 //            System.out.println("呼吸");
115 //        }
116     }
117     //System.out.println("Hello!");
118 }

5、面向對象編程思想的落地法則一：

　　1、設計並創建類以及類的成分；

　　2、實例化類的對象；

　　3、通過“對象.屬性”或“對象.方法”的形式完成某項功能

6、類的初始化記憶體解析：

　　6.1、記憶體劃分的結構：

　　棧(stack)：局部變數、對象的引用名、數組的引用名

　　堆(heap)：new出來的“東西”(比如：對象的實體，數組的實體)，含成員變數

　　方法區：含字元串常量

　　靜態域：聲明為static的變數

　　6.2、理解的基礎上，要學會基本的創建的類的對象在記憶體中的運行。

7、方法的重載(overload)：

要求：1、同一個類中；
* 2、方法名必須相同；
* 3、方法的參數列表不同；1、參數的個數不同；
* 2、參數類型不同；
* 4、方法的重載與方法的返回值類型沒有關係；

 1 /*
 2  * 方法的重載(overload)
 3  * 要求：1、同一個類中；
 4  *        2、方法名必須相同；
 5  *        3、方法的參數列表不同；1、參數的個數不同；
 6  *                       2、參數類型不同；
 7  *        4、方法的重載與方法的返回值類型沒有關係；
 8  */
 9 public class TestOverLoad {
10 
11 }
12 class OverLoad{
13     //定義兩個int型變數的和
14     public int getSum(int i, int j){
15         return i + j;
16     }
17     //定義三個int型變數的和
18     public int getSum(int i, int j, int k){
19         return i + j + k;
20     }
21     //不能與其他幾個方法構成重載
22 //    public int getSum1(int i, int j, int k){
23 //        return i + j + k;
24 //    }
25 //    public void getSum(int i, int j, int k){
26 //        System.out.println(i + j + k);
27 //    }
28     //定義兩個double型的數據的和
29     public double getSum(double d1, double d2){
30         return d1 + d2;
31     }
32     //定義三個double型數據的和
33     public void getSum(double d1,double d2,double d3){
34         System.out.println(d1 + d2 + d3);
35     }
36     //以下兩個方法也構成重載
37     public void method1(int i, String str){
38         
39     }
40     public void method1(String str1, int j){
41         
42     }
43 }