java04 方法、面向對象、封裝

1方法的概念

抽取提純某一動作的即可為方法，若干語句的功能集合

public class Hello{
    public static void main(String[] args){
        //男人
        System.out.println("買房");
        //女人
        System.out.println("結婚");


    }
}

需要注意定義格式  參數和返回值

2如何定義它的格式

定義方法的完整格式：

修飾符  返回值類型  方法名稱（參數類型 參數名稱，參數類型 參數名稱。。。。）{

     方法體

      return 返回值；//  參數如果有多個，用逗號分隔

}

格式 

         public  static void 方法名稱（）{

                 方法體

          }

方法名稱： 使用小駝峰 xiaoMiFeng

方法體：使用大括號當中可以包含任意條語句

程序入口：

public static void main（String[] args）{

     方法名稱（）；

}

調用格式：方法名稱（）；

注意事項：

1 方法定義的先后順序，不重要；

2 方法定義不可以嵌套或包含的關系；不可嵌套定義。

3 方法定義OK，不會執行，如果想執行，一定要進行調用（執行方法）；也就是在main或其他地方進行調用中進行調用。

public class Hello{
    public static void main(String[] args){
        //男人 調用女人方法
        woMen(args);
        System.out.println("買房");
        //女人
    }
    public static void woMen(String[] args)    {
        System.out.println("結婚");


    }
}

結果

買房

結婚

3如何使用（調用）

方法其實就是若干語句的集合，好比是一個工廠。

參數 就是進入方法的數據

返回值 就是從方法中出來的數據，也就是產物

-----------------

定義方法的完整格式：

修飾符  返回值類型  方法名稱（參數類型 參數名稱，參數類型 參數名稱。。。。）{

     方法體

      return 返回值；//  參數如果有多個，用逗號分隔

}

修飾符 現階段的固定寫法  public  static

返回值類型  也就是方法最終產生的數據結構是什么類型

方法名稱 ： 方法的名字，規則和變量一樣，小駝峰；

參數名稱： 進入方法的數據對於的變量名稱；

return ：兩個作用

             1 停止當前方法

              2 將后面的返回值還給調用處；

舉例 ： 定義一個兩個int 類型數字相加的方法

三要素考慮  返回值類型 int  方法名稱 sum  參數列表 int a  int b

2）調用方法的三種格式： 單獨調用（結果無法使用） 打印調用  賦值調用（給變量）

1 單獨調用： 方法名稱（參數）；void 只能單獨調用類型

public class HelloWorld2 {
    public static void main(String[] args){
        //單獨調用
        int c = sum(10,20);

  // 打印調用
        System.out.println(c);
    }
    public static int sum(int a ,int b){
        int result1 = a + b;
        return result1;
    }
}
結果 30

2、打印調用：System.out.println();

public class HelloWorld2 {
    public static void main(String[] args){
        //單獨調用
        int c = sum(10,20);  // 賦值調用

  // 打印調用
        System.out.println(c);
    }
    public static int sum(int a ,int b){
        int result1 = a + b;
        return result1;
    }
}
結果 30

3 賦值調用  數據類型  變量名稱 = 方法名稱（參數）；

public class HelloWorld2 {
    public static void main(String[] args){
        //單獨調用
        int c = sum(10,20);

  // 打印調用
        System.out.println(c);
    }
    public static int sum(int a ,int b){
        int result1 = a + b;
        return result1;
    }
}
結果 30

3）整個程序執行過程

4） 對比參數方法 有參數和無參數

有參數： 當一個方法需要一些數據條件 ，才能完成任務的時候，就是有參數。

              例如方法是計算兩個數據的和

下面是有參數：

public class HelloWorld2 { public static void main(String[] args){ method1(10,20); //兩個數字相乘，做乘法，得知道兩個數據的值，否則無法計算
 } public static void method1(int a ,int b){ //void 類型，可以使用打印println（結果）
        int result2 = a + b; System.out.println("結果是" + result2); } } 結果30

無參數：小括號中留空，一個方法不需要任何數據條件，自己就能獨立完成任 

              務，就是無參數。例如定義一個方法，打印固定10次的helloworld。

下面是無參數（你只需調用我這個方法，不需要傳參數據，直接執行）

public class HelloWorld2 {
    public static void main(String[] args) {
        method2();
    }

    public static void method2() {
        for (int i = 0; i < 5; i++) {
            System.out.println("愛我中華");
        }
    }
}
結果
愛我中華
愛我中華
愛我中華
愛我中華
愛我中華

5）有無返回值案例：

原始題目 定義一個方法，用來計算兩個數字的和（你幫我算，算完把結果給我）

有返回值的 可以單獨調用  打印調用 或者賦值調用

無返回值的  也就是 void 只能單獨調用。不可以打印調用或者賦值調用。

public class HelloWorld2 {
    public static void main(String[] args) {
        //我是main方法，我來調用你，你來幫我算一下，算完結果給我
        int num2 = getSum(10, 20);
        System.out.println(num2);
        }
    //我是一個方法，我負責兩個數字相加
    //我有返回值int，誰調用我，我就把計算結果告訴誰。
    public static int getSum( int a,int b) {
        int sum1 = a + b;
        return sum1;
        }
}

結果30

變形題目 定義一個方法，用來打印兩個數字的和（你幫我算，自己負責算完把結果打印）

public class HelloWorld2 {
    public static void main(String[] args) {
        //我是main方法，我來調用你，你來幫我算一下，算完結果給我
        int num2 = getSum(10, 20);
        System.out.println(num2);
        System.out.println("----------");
        getSum1(10,20);
        }
    //我是一個方法，我負責兩個數字相加
    //我有返回值int，誰調用我，我就把計算結果告訴誰。
    public static int getSum( int a,int b) {
        int sum1 = a + b;
        return sum1;
        }
    //我是一個方法，我負責兩個數字相加
    //我沒有返回值，不會把計算結果告訴任何人。
    public static void getSum1( int a,int b) {
        int sum1 = a + b;
        System.out.println(sum1);
    }
}
結果
30
----------
30

整體效果如下：

定義一個方法，用來判斷兩個數字是否相同

//定義一個方法，用來判斷兩個數字是否相同
public class HelloWorld2 {
    public static void main(String[] args) {
        //方法的三要素  返回值類型 boolean    方法名稱 isNum 參數列表 int a int b
        boolean issame2 = isSame(10,20);
        System.out.println(issame2);
    }
    public static boolean isSame(int a, int b){
        boolean same;
        if(a == b){
            same = true;

        }else {
            same = false;
        }
        return same;
    }
}
結果
false

定義一個方法，用來判斷兩個數字是否相同

//定義一個方法，用來判斷兩個數字是否相同
public class HelloWorld2 {
    public static void main(String[] args) {
        //方法的三要素  返回值類型 boolean    方法名稱 isNum 參數列表 int a int b
        boolean issame2 = isSame(10,20);
        System.out.println(issame2);
    }
    public static boolean isSame(int a, int b){
        boolean same;
        if(a == b){
            same = true;

        }else {
            same = false;
        }
        return same;
    }
}

結果 false

定義一個方法，求出1-100之間的和

//定義一個方法，求出1-100之間的和
public class HelloWorld2 {
    public static void main(String[] args) {
        System.out.println(getSum1());
    }
        //返回值 int
        //參數列表 i++
        //方法名稱getSum
    public static int getSum1 () {
        int sum1 = 0;
        for (int i = 1; i < 100; i++) {
            sum1 = sum1 + i;
        }
        return sum1;
        }
}
結果 4950

5 使用方法的注意事項

• 方法應該定義在類當中，不可以在方法中再定義一個方法。
• 方法定義的前后順序無所謂
• 方法定義之后不會執行，如果希望執行，一定要調用；
• 如果方法有返回值，必須寫上return 返回值；不能沒有
• return 后面的返回值類型，必須和方法的返回值類型一一對應；
• 對於一個void沒有返回值的方法，不能寫return后面的返回值，只能return自己。也就是return；語句
• 對於方法中最后一行的return可以省略不寫。
• 一個方法中，可以有多個return，但不可以同時執行2個，只能1個。

方法的重載

    假設一個方法 實現多個數字相加，可能兩個 ，可能三個，可能四個，但是調用時候可能調用選擇困難，對於功能類似的方法，那么如何減少調用選擇而快速實現相加方法的執行，因此方法的重載，方便撰寫方法，也方便調用。

定義：多個方法的名稱一樣，但參數列表不一樣，而方法遵守小駝峰原則

方法的重載的關鍵點

• 1.參數個數不同，上圖已演示；
• 2.參數個數相同但參數的類型不同，return可強壯類型
• 3.參數個數相同的多類型順序不同
• 4.與方法的返回值類型無關

2.面向對象

    面向對象也就是面向誰開發，面向過程就是每個過程每個細節進行開發，而面向對象就是當實現某個功能的時候，找具備該功能的進行即可。

     面向過程就是分析出解決問題所需要的步驟，然后用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就可以了；面向對象是把構成問題事務分解成各個對象，建立對象的目的不是為了完成一個步驟，而是為了描敘某個事物在整個解決問題的步驟中的行為。

     可以拿生活中的實例來理解面向過程與面向對象，例如五子棋，面向過程的設計思路就是首先分析問題的步驟：1、開始游戲，2、黑子先走，3、繪制畫面，4、判斷輸贏，5、輪到白子，6、繪制畫面，7、判斷輸贏，8、返回步驟2，9、輸出最后結果。把上面每個步驟用不同的方法來實現。

       如果是面向對象的設計思想來解決問題。面向對象的設計則是從另外的思路來解決問題。整個五子棋可以分為1、黑白雙方，這兩方的行為是一模一樣的，2、棋盤系統，負責繪制畫面，3、規則系統，負責判定諸如犯規、輸贏等。第一類對象（玩家對象）負責接受用戶輸入，並告知第二類對象（棋盤對象）棋子布局的變化，棋盤對象接收到了棋子的變化就要負責在屏幕上面顯示出這種變化，同時利用第三類對象（規則系統）來對棋局進行判定。

      可以明顯地看出，面向對象是以功能來划分問題，而不是步驟。兩者之間的優缺點

• 面向過程：
• 優點：性能比面向對象高，因為面向對象時的類調用時需要實例化，開銷較大，比較消耗資源;比如單片機、嵌入式開發、 Linux/Unix等一般采用面向過程開發，性能是最重要因素。
  缺點：沒有面向對象易維護、易復用、易擴展
• 面向對象
• 優點：易維護、易復用、易擴展，由於面向對象有封裝、繼承、多態性的特性，可以設計出低耦合的系統，使系統 更加靈活、更加易於維護
  缺點：性能比面向過程低

package cn.itcast.day04.demo01;
import java.util.Arrays;

public class HelloWorld {

    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        System.out.print("[");//面向過程
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
        System.out.println("==========");//分割線，找個Arrays類，tostring現成的方法
        System.out.println(Arrays.toString(array));//面向對象
    }
}

2.1.面向對象的特點與組成部分： 成員屬性（也叫成員變量（是什么））與成員方法（能干啥）

 

成員變量（屬性）

   數據名稱 變量名稱； int num = 10；

成員方法（行為）：成員方法特殊的地方就是沒有static 即     public void eat（）；

  寫在方法內部的叫局部變量

  寫在類中間叫成員變量。

類定義： public class 類名（）{

                        成員變量；

                        成員方法；

} 其中public可寫可不寫；

package cn.itcast.day04.demo01;  2 public class HelloWorld {  3 int name; //成員變量，寫在類當中，而不是方法中  4 public void eat(){  5 int age;// 寫在成員方法中的局部變量  6 System.out.println("吃飯飯");  7 }  8 // 成員方法沒有static的，跟返回值和參數類型無關  9 public void sleep() {  10 System.out.println("睡覺");  11 }  12 }

2.2.類的使用步驟：

1.導包，也就是導入正常需要使用的類，在什么位置；導包語句格式

import 包名稱.類名稱 假設導上面HelloWorld類

import cn.itcast.day04.demo01.HelloWorld;

2.創建格式

類名稱 對象名 = new 類名稱（）；

Student stu  =  new Student（）;

3.使用：成員變量和成員方法的使用方法

    對象名.成員變量 HelloWorld.name；

   對象名.成員方法（參數）HelloWorld.eat(參數)；

package cn.itcast.day04.demo01;
import cn.itcast.day04.demo01.HelloWorld;
public class Demo02 {
    public static void main(String[] args) {
        HelloWorld hw = new HelloWorld();
        hw.eat();
        hw.sleep();
    }
}

package cn.itcast.day04.demo01;
public class HelloWorld {
    int name; //成員變量，寫在類當中，而不是方法中
    public void eat(){
        int age;// 寫在成員方法中的局部變量
        System.out.println("吃飯飯");
    }
// 成員方法沒有static的，跟返回值和參數類型無關
    public void sleep() {
        System.out.println("睡覺");
    }
}

如果成員變量未給值，則是默認值，規則和數組一樣

int 為0；float為0.0，String是null，Boolean 為false，引用類型none

當我們創建一個對象，調用了成員方法和成員變量，那么內存中發生了什么變化。

      通常運行main方法之前，方法區有數據-方法區保存的是.class數據

棧 Stack，含義書架，也就是先進后出

• 每個線程包含一個棧區，棧中只保存基礎數據類型的對象和自定義對象的引用(不是對象)，對象都存放在堆區中
• 每個棧中的數據(原始類型和對象引用)都是私有的，其他棧不能訪問。
• 棧分為3個部分：基本類型變量區、執行環境上下文、操作指令區(存放操作指令)。

堆 Heap 許多 也就是先進先出

• 存儲的全部是對象，每個對象都包含一個與之對應的class的信息。(class的目的是得到操作指令)
• jvm只有一個堆區(heap)被所有線程共享，堆中不存放基本類型和對象引用，只存放對象本身

方法區 Method Area

• 方法區又叫靜態區，跟堆一樣，被所有的線程共享。方法區包含所有的class和static變量。
• 方法區中包含的都是在整個程序中永遠唯一的元素，如class，static變量。

02-兩個對象使用同一個方法的內存圖

03-兩個引用指向同一個對象的內存圖

      使用對象對方法進行參數傳遞。帶static的方法是普通方法，不需要用對象點即可調用，直接使用。實際上傳遞的是地址值。

格式  public satatic void 方法名稱（類名 對象名）{

                對象名.成員變量；

                對象名.成員方法；

            }

package cn.itcast.day04.demo01;
import cn.itcast.day04.demo01.HelloWorld;
public class Demo02 {
    public static void main(String[] args) {
        HelloWorld hw = new HelloWorld();
        System.out.println(hw.name);
        hw.eat();
        hw.sleep();
        hw.dd();
        Method(hw);
    }
    public static void Method(HelloWorld HH){
        System.out.println(HH.name);
    }
}

package cn.itcast.day04.demo01;
public class HelloWorld {
    Boolean  name; //成員變量，寫在類當中，而不是方法中
    public void eat(){
        int age;// 寫在成員方法中的局部變量
        System.out.println("吃飯飯");
    }
// 成員方法沒有static的，跟返回值和參數類型無關
    public void sleep() {
        System.out.println("睡覺");
    }
    public static void dd(){
        System.out.println("跑步");
    }
}

       使用對象對方法進行參數傳遞。帶static的方法是普通方法，不需要用對象點即可調用，直接使用。實際上傳遞的是地址值。

格式  public satatic 類名 方法名稱（）{

               類名  對象名 = new 類名；

               方法體（對象名.成員變量  賦值）

               return 對象名； 此處返回地址值

         }

而接收方 需要進行賦值調用。

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

1.定義的位置不一樣

局部變量：在方法內部

成員變量：在方法的外部；

2.作用范圍不一樣

局部變量：只有方法當中才可以使用，出了方法就不能再用

成員變量：整個類都已可以通用

3.默認值不一樣

局部變量：沒有默認值，如果要使用，需賦值，方法的參數也是局部變量。

成員變量：如果沒有賦值，有默認值，和數組一樣。

4.內存的位置不一樣

局部變量 ：位於棧內存

成員變量：位於堆內存

5.生命周期不一樣

局部變量：隨着方法進棧而誕生，隨着方法出棧而消失

成員變量：隨着對象創建而誕生，隨着對象被垃圾回收而消失

2.4.面向對象的三大特征、封裝性、繼承性、多態性。

封裝性體現在：

1.方法就是一種封裝

2.關鍵字private也是一種封裝。

舉例子：1.完成代碼整合成方法，進行封裝

舉例子2 關鍵字private（私有化）的例子

private 私有化，main方法將無法調用，需要提供一對getAge和setAge方法

對於 setAge（int age）必須有參數（參數類型必須與成員變量對應），無返回值。

對於 getAge（）無參數，有返回值，返回值類型與成員變量對應。

快速生成setAge（）方法  alt + insert 選擇set和get方法即可

特別注意：布爾值類型 是 setXXX和isXXX

       當方法的參數的局部變量和類的成員變量重名的時候，根據就近原則，方法的調用將優先使用方法傳參的局部變量，如果是想用類的成員變量，可使用this.成員變量，從而進行區分。this關鍵字將是解決變量名重名的問題。調用誰的方法，this就是誰，this點的就是誰的成員變量而不是方法的局部變量（this也就是誰的地址）。

2.5 構造方法

為什么需要構造方法

• 面向對象的強制性要求

（1）構造方法是對象時用new關鍵字必須要調用的

（2）自己不定義任何構造方法時，編譯器默認生成一個

• 初始化對象或其他任務

（1）完成對象屬性初始化

（2）傳遞參數

（3）還可以完成信息的讀取，或其他對象的初始化等任務

• 構造方法調用問題

（1）main方法進行構造方法的調用就是new的過程；

（2）類中構造方法直接調用使用this.變量名或者this（）代表構造方法

public class Person {
        private String name;
        private int age;
        //構造方法一
        public Person() {
            this(null);
        }
        //構造方法二
        public Person(String n) {
            this(n, 12);//調用第三個
        }
        //構造方法三
        public Person(String n, int a) {
            this.name = n;
            this.age = a;
        }
    }

        構造方法的名稱必須和類名稱一致，定義格式，構造方法的名稱和類名稱一樣，首字符也得大寫，構造方法沒有返回值，連void都不寫

public 類名稱（）{方法體}

      構造方法的關鍵點：

1.如果沒有寫構造方法，將默認有無參構造方法；

2。構造方法也是可以進行重載的

package cn.itcast.day04.demo01.demo04;

public class Demo01 {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println("========");
        Person p2 = new Person("zhao",20);
        System.out.println(p2.name);
        System.out.println(p2.age);
        System.out.println("========");
        System.out.println(p2.getAge());
        System.out.println(p2.getName());
        p2.setAge(21);
        System.out.println(p2.getAge());
    }
}

package cn.itcast.day04.demo01.demo04;

public class Person {
    String name;
    int age;
    public Person(){
        System.out.println("無參構造方法執行");
    }
    public Person(String name , int num){
        this.name = name;
        this.age = num;
        System.out.println("全參數構造執行");
    }

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

一旦需要改變參數中的內容，則需要使用set、get。因為一旦類成員變量進行private私有化，構造初始化是快捷、方便的。

由此 一個標准類（jave bean）的組成部分是：

1、所有的成員變量，進行私有化 private標注；

2. 所有的成員變量進行set/get方法

3.編寫一個無參數的構造方法

4.編寫一個有參數的構造方法；

或者說：

1、所有屬性（成員變量）為private
2、提供默認構造方法
3、提供getter和setter
4、實現serializable接口（Java實體對象為什么一定要實現Serializable接口呢，因為實現Serilizable接口是為了序列化啊）