一同學 Java 面向對象（二）

函數也稱為辦法，就是定義在類中的具有特定功用的一段獨立代碼。用於定義功用，進步代碼的復用性。

函數的特點
1> 定義函數可以將功用代碼停止封裝，便於對該功用停止復用；
2> 函數只要被調用才會被執行；
3> 關於函數沒有詳細前往值的狀況，前往值類型用關鍵字void表示，那麼該函數中的return語句假如在最後一行可以省略不寫，零碎會幫你自動加上；
4> 函數中只能調用函數，不可以在函數外部定義函數。

　　修飾符  前往值類型  辦法名(參數類型 方式參數1，參數類型 方式參數2，..)
　　{  
　　　　辦法體;
　　　　return 前往值;
　　}

//修飾符: 可選，通知編譯器如何調用該辦法。定義了該辦法的訪問類型。
//前往值類型：函數運轉後的後果的數據類型
//參數類型：方式參數的數據類型

主函數 main()：
1> 保證該類的獨立運轉；
2> 順序的入口，自動調用；
3> jvm調用。

函數的重載 （overload）

重載的概念：
　　在同一個類中，允許存在一個以上的同名函數，只需它們的參數個數或許參數類型不同即可。
重載的特點：
　　與前往值類型有關，只看參數列表。
重載的益處：
　　方便於閱讀，優化了順序設計。Java編譯器依據辦法簽名判別哪個辦法應該被調用。

什麼時分用重載？

　　當定義的功用相反，但參與運算的未知內容不同。

　　那麼，這時就定義一個函數稱號以表示起功用，方便閱讀，而經過參數列表的不同來區分多個同名函數。

      重載的辦法必需擁有不同的參數列表。你不能僅僅根據修飾符或許前往類型的不同來重載辦法。

重載示例：
　　前往兩個整數的和
　　　　int add(int x,int y){return x+y;}
　　前往三個整數的和
　　　　int add（int x,int y, int z）{return x+y+z;}
　　前往兩個小數的和
　　　　double add(double x,double y){return x+y;}

// 重載區分， 重載和前往值類型沒關系
void show(int a,char b,double c){}

a. void show(int x,char y,double z){}//沒有，由於和原函數一樣。
b. int show(int a,double c,char b){} //重載，由於參數類型不同。
c. void show(int a,double c,char b){}//重載，由於參數類型不同。

public class functc {
    public static void draw(int row, int col){
        for (int i=0; i<row; i++){
            for (int n=0; n<col; n++){
                System.out.print('@');
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        draw(5, 9);
    }
}

public class funcsj {
    }
    public static void main(String[] args) {
        print99();
    }
    
    public static void print99(){
        for (int i=1; i<10; i++){
            for (int n=1; n<i+1; n++){
                System.out.print(n+"*"+i+"="+i*n+" ");
            }
            System.out.println();
        }
    }
}

// 後果
1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

public class funcol {
    public static void main(String[] args) {
        int num = add(5, 8, 9);
        System.out.print(num);    //22
    }
     public static int add(int x,int y){
         return x+y;
     }
     public static int add(int x,int y,int z){
         return add(x,y)+z;
     }
}

當一個對象被創立時分，結構辦法用來初始化該對象。結構辦法和它所在類的名字相反，但結構辦法沒有前往值。

通常會運用結構辦法給一個類的實例變量賦初值，或許執行其它必要的步驟來創立一個完好的對象。

不論你與否自定義結構辦法，一切的類都有結構辦法，由於Java自動提供了一個默許結構辦法，它把一切成員初始化為0。

一旦你定義了自己的結構辦法，默許結構辦法就會生效。

public class myfunc {
    int x;
    myfunc(int i){
        x = i;
    }
}

// myfunc.java

public class myfunc {
    int x;
    myfunc(int i){
        x = i;
        System.out.println(x);
    }
}


// MyDemoTest.java

public class MyDemoTest {
    public static void main(String args[]) {
        myfunc t1 = new myfunc(9);
        myfunc t2 = new myfunc(5);
        System.out.println(t1.x + " " + t2.x);
      }
}

// 輸入後果
9
5
9 5

JDK 1.5 開端，Java支持傳遞同類型的可變參數給一個辦法。

在辦法聲明中，在指定參數類型後加一個省略號(...) 。

一個辦法中只能指定一個可變參數，它必需是辦法的最後一個參數。任何普通的參數必需在它之前聲明。

//typeName... parameterName
public static void My( double... nums){...}

public class myfunc {
    
    public static void printNum( double... numbers) {         
        double result = numbers[0];
        System.out.println("The value index eq 0: " + result);
         
        for (int i = 1; i <  numbers.length; i++){
            System.out.println("The value is " + numbers[i]);
        }
    }
    
    public static void main(String args[]) {
      // 調用可變參數的辦法
        printNum(1, 2, 9, 5, 8);
        printNum(new double[]{1, 2, 6});
     }
    
}


// 輸入後果
The value index eq 0: 1.0
The value is 2.0
The value is 9.0
The value is 5.0
The value is 8.0
The value index eq 0: 1.0
The value is 2.0
The value is 6.0

Java 允許定義這樣的辦法，它在對象被渣滓搜集器析構(回收)之前調用，這個辦法叫做 finalize( )，它用來肅清回收對象。

例如，你可以運用 finalize() 來確保一個對象翻開的文件被封閉了。

在 finalize() 辦法裡，你必需指定在對象銷毀時分要執行的操作。

finalize() 普通格式是：

protected void finalize()
{
   // 在這裡終結代碼
}

關鍵字 protected 是一個限定符，它確保 finalize() 辦法不會被該類以外的代碼調用。

當然，Java 的內存回收可以由 JVM 來自動完成。假如你手動運用，則可以運用下面的辦法。

public class myfunc {    
    public static void main(String args[]) {
        Cake c1 = new Cake(1);  
        Cake c2 = new Cake(2);  
        Cake c3 = new Cake(3);  
          
        c2 = c3 = null;  
        System.gc(); //調用Java渣滓搜集器
     }
}



class Cake extends Object {  
      private int id;  
      public Cake(int id) {  
        this.id = id;  
        System.out.println("Cake Object " + id + "is created");  
      }  
        
      protected void finalize() throws java.lang.Throwable {  
        super.finalize();  
        System.out.println("Cake Object " + id + "is disposed");  
      }
}

// 輸入後果
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed

public 類：類屬變量及辦法，包內及包外的任何類均可以訪問；
protected 類：類屬變量及辦法，包內的任何類，及包外的那些承繼了此類的子類才干訪問；
private 類：類屬變量及辦法，包內包外的任何類均不能訪問；
friendly 類：類屬變量及辦法不以上這三種修飾符來修飾，那麼包內的任何類都可以訪問它，而包外的任何類都不能訪問它(包括包外承繼了此類的子類)，因而，這品種、類屬變量及辦法對包內的其他類是敵對的，開放的，而對包外的其他類是封閉的。

訪問修飾符 修飾符 class 類稱號 extends 父類稱號 implement 接口稱號
（訪問修飾符與修飾符的地位可以互換）

訪問修飾符 修飾符 前往類型 辦法稱號（參數列表）throws 違例列表

• 子類擁有父類非private的屬性，辦法和結構器。

• 子類可以擁有自己的屬性和辦法，即子類可以對父類停止擴展。

• 子類可以用自己的方式完成父類的辦法。

• Java的承繼是單承繼，但是可以多重承繼，單承繼就是一個子類只能承繼一個父類，多重承繼就是，例如A類承繼B類，B類承繼C類，所以依照關系就是C類是B類的父類，B類是A類的父類，這是java承繼區別於C++承繼的一個特性。

• 進步了類之間的耦合性（承繼的缺陷，耦合度高就會形成代碼之間的聯絡）。

    承繼可以運用 extends 和 implements 這兩個關鍵字來完成承繼，而且一切的類都是承繼於 java.lang.Object，當一個類沒有承繼的兩個關鍵字，則默許承繼object（這個類在 java.lang 包中，所以不需求 import）祖先類。

extends關鍵字

    在Java中，類的承繼是單一承繼，也就是說，一個子類只能擁有一個父類，所以 extends 只能承繼一個類。

implements關鍵字

    運用 implements 關鍵字可以變相的使java具有多承繼的特性，運用范圍為類承繼接口的狀況，可以同時承繼多個接口（接口跟接口之間采用逗號分隔）。

super 與 this 關鍵字

    super關鍵字：我們可以經過super關鍵字來完成對父類成員的訪問，用來援用以後對象的父類。

    this關鍵字：指向自己的援用

final關鍵字

    final 關鍵字聲明類可以把類定義為不能承繼的，即最終類；或許用於修飾辦法，該辦法不能被子類重寫：

聲明類：
    final class 類名 {//類體}
聲明辦法：
    修飾符(public,private,void,protected等) final 前往值類型 辦法名(){//辦法體}

實例變量也可以被定義為final，被定義為final的變量不能被修正。被聲明為final的內的辦法自動地聲明為final，但是實例變量並不是final。

    子類不能承繼父類的結構器（結構辦法或許結構函數），但是父類的結構器帶有參數的，則必需在子類的結構器中顯式地經過super關鍵字調用父類的結構器並配以適當的當屬列表。

    假如父類有無參結構器，則在子類的結構器中用super調用父類結構器不是必需的，假如沒有運用super關鍵字，零碎會自動調用父類的無參結構器。

class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("Hello everyone, my cardid is "+ id + ", and my name is " + name + "."); 
    } 
}


class Bird extends Animal { 
    public Bird(String myName, int myid) { 
        super(myName, myid); 
    } 
}

class Dog extends Animal { 
    public Dog(String myName, int myid) { 
        super(myName, myid); 
    } 
}


class SuperClass {
      private int n;
      SuperClass(){
        System.out.println("SuperClass()");
      }
      SuperClass(int n) {
        System.out.println("SuperClass(int n)");
        this.n = n;
        System.out.println("SuperClass(int n):"+this.n);
      }
}

class SubClass extends SuperClass{
      private int n;
      SubClass(){
        super(300);
        System.out.println("SuperClass");
      }
      public SubClass(int n){
        super(500);
        System.out.println("SubClass(int n):"+n);
        this.n = n;
        System.out.println("n:"+n+", this.n:"+this.n);
      }
}    

public class AnimalMain {
    public static void main(String[] args){
        Animal Mouseobjone = new Dog("小虎", 9);
        Mouseobjone.eat();    //小虎正在吃
        Mouseobjone.introduction();    //Hello everyone, my cardid is 9, and my name is 小虎.
        Animal Mouseobjtwo = new Dog("貝貝", 5);
        Mouseobjtwo.eat();    //貝貝正在吃
        Mouseobjtwo.introduction();    //Hello everyone, my cardid is 5, and my name is 貝貝.
        
        
        SubClass sc = new SubClass();
        //輸入
        //SuperClass(int n)
        //SuperClass(int n):300
        //SuperClass
        SubClass sc2 = new SubClass(200);
        //輸入
        //SuperClass(int n):500
        //SubClass(int n):200
        //n:200, this.n:200
    }
}

辦法的重寫(Overriding)和重載(Overloading)是java多態性的不同表現，重寫是父類與子類之間多態性的一種表現，重載是一類中多態性的一種表現。

• 參數列表必需完全與被重寫辦法的相反；
• 前往類型必需完全與被重寫辦法的前往類型相反；
• 訪問權限不能比父類中被重寫的辦法的訪問權限更低。例如：假如父類的一個辦法被聲明為public，那麼在子類中重寫該辦法就不能聲明為protected。
• 父類的成員辦法只能被它的子類重寫。
• 聲明為final的辦法不能被重寫。
• 聲明為static的辦法不能被重寫，但是可以被再次聲明。
• 子類和父類在同一個包中，那麼子類可以重寫父類一切辦法，除了聲明為private和final的辦法。
• 子類和父類不在同一個包中，那麼子類只可以重寫父類的聲明為public和protected的非final辦法。
• 重寫的辦法可以拋出任何非強迫異常，無論被重寫的辦法能否拋出異常。但是，重寫的辦法不能拋出新的強迫性異常，或許比被重寫辦法聲明的更普遍的強迫性異常，反之則可以。
• 結構辦法不能被重寫。
• 假如不能承繼一個辦法，則不能重寫這個辦法。
• 當需求在子類中調用父類的被重寫辦法時，要運用super關鍵字。

class Animal{
    public void move(){
        System.out.println("植物可以行走");
    }
}

class Dog extends Animal{
    public void move(){
        super.move();
        System.out.println("狗會跳");
    }
    public void bark(){
        System.out.println("狗會叫");
    }
}


public class Override {
    public static void main(String args[]){
        Animal animalobj = new Animal();
        Dog dogobj = new Dog();
        
        animalobj.move();
        dogobj.move();
        //dogobj.bark();    //會報錯！！！拋出一個編譯錯誤，由於dogobj的援用類型Animal沒有bark辦法。
    }
}

是在一個類外面，辦法名字相反，而參數不同。前往類型可以相反也可以不同。

每個重載的辦法（或許結構函數）都必需有一個無獨有偶的參數類型列表。

只能重載結構函數

重載規則：

• 被重載的辦法必需改動參數列表(參數個數或類型或順序不一樣)；
• 被重載的辦法可以改動前往類型；
• 被重載的辦法可以改動訪問修飾符；
• 被重載的辦法可以聲明新的或更廣的反省異常；
• 辦法可以在同一個類中或許在一個子類中被重載。
• 無法以前往值類型作為重載函數的區分規范。

public class Overloading {
    public int test(){
        System.out.println("This is one.");
        return 1;
    }
    
    public void test(int a){
        System.out.println("This is two.");
    }
    
    public String test(int a,String s) {
        System.out.println("This is three.");
        return "3";
    }
    
    public static void main(String args[]) {
        Overloading olobj = new Overloading();
        System.out.println(olobj.test());    //This is one.、1
        olobj.test(1);    //This is two.
        System.out.println(olobj.test(1, "test3"));    //This is three.、3
    }
}

• 1. 消弭類型之間的耦合關系
• 2. 可交換性
• 3. 可擴大性
• 4. 接口性
• 5. 靈敏性
• 6. 簡化性

• 承繼
• 重寫
• 父類援用指向子類對象

當運用多態方式調用辦法時，首先反省父類中能否有該辦法，假如沒有，則編譯錯誤；假如有，再去調用子類的同名辦法。

多態的益處：可以使順序有良好的擴展，並可以對一切類的對象停止通用途理

public class Polymorphism {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 對象調用 show 辦法
        show(new Dogo());  // 以 Dogo 對象調用 show 辦法
            
        Animalo a = new Cat();  // 向上找辦法  
        a.eat();               // 調用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下找辦法  
        c.work();        // 調用的是 Cat 的 catchMouse
    }
    
    public static void show(Animalo a)  {
        a.eat();  
        // 類型判別
        if (a instanceof Cat)  {  // 貓做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dogo) { // 狗做的事情 
            Dogo c = (Dogo)a;  
            c.work();  
        }  
    } 
}


abstract class Animalo {  
    abstract void eat();  
}  
  
class Cat extends Animalo {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dogo extends Animalo {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

假如你想設計這樣一個類，該類包括一個特別的成員辦法，該辦法的詳細完成由它的子類確定，那麼你可以在父類中聲明該辦法為籠統辦法。

Abstract關鍵字異樣可以用來聲明籠統辦法，籠統辦法只包括一個辦法名，而沒無方法體。

籠統辦法沒有定義，辦法名前面直接跟一個分號，而不是花括號。

聲明籠統辦法會形成以下兩個後果：

• 假如一個類包括籠統辦法，那麼該類必需是籠統類。
• 任何子類必需重寫父類的籠統辦法，或許聲明本身為籠統類。

承繼籠統辦法的子類必需重寫該辦法。否則，該子類也必需聲明為籠統類。最終，必需有子類完成該籠統辦法，否則，從最初的父類到最終的子類都不能用來實例化對象。

• 2. 籠統類中不一定包括籠統辦法，但是有籠統辦法的類肯定是籠統類。

• 3. 籠統類中的籠統辦法只是聲明，不包括辦法體，就是不給出辦法的詳細完成也就是辦法的詳細功用。

• 4. 結構辦法，類辦法（用static修飾的辦法）不能聲明為籠統辦法。

• 5. 籠統類的子類必需給出籠統類中的籠統辦法的詳細完成，除非該子類也是籠統類。

abstract class Employeem {
    private String name;
    private String address;
    private int number;
    
    public abstract double macPany();
}


class Salary extends Employeem{
    private double salary=1;
    public double macPany(){
        System.out.println("Welcome to macPany.");
        return salary;
    }
}


public class Employee {    
    public static void main(String[] args){
        Salary macPanyobj = new Salary();
        macPanyobj.macPany();
    }
}

在面向對象程式設計辦法中，封裝（Encapsulation）是指，一種將籠統性函式接口的實作細節部份包裝、隱藏起來的辦法。

封裝可以被以為是一個維護屏障，避免該類的代碼和數據被內部類定義的代碼隨機訪問。

要訪問該類的代碼和數據，必需經過嚴厲的接口控制。

封裝最次要的功用在於我們能修正自己的完成代碼，而不必修正那些調用我們代碼的順序片段。

適當的封裝可以讓程式碼更容易了解與維護，也增強了程式碼的平安性。

• 1. 良好的封裝可以增加耦合。

• 2. 類外部的構造可以自在修正。

• 3. 可以對成員變量停止更准確的控制。

• 4. 隱藏信息，完成細節，普通限制為private。

public class EncapBase {
    public static void main(String[] args){
        EncapTmp encaptmpobj = new EncapTmp();
        System.out.println(encaptmpobj.getName());    //null
        encaptmpobj.setName("nick");
        System.out.println(encaptmpobj.getName());    //nick
    }
}


class EncapTmp{
    
    private String name;
    private int age;
    
    public String getName(){
        return name;
    }
    
    public int getAge(){
        return this.age;
    }
    
    public void setName(String namenew){
        name = namenew;
    }
    
    public void setAge(int age){
        this.age = age;
    }
}

接口（Interface），在JAVA編程言語中是一個籠統類型，是籠統辦法的集合，接口通常以interface來聲明。一個類經過承繼接口的方式，從而來承繼接口的籠統辦法。

接口並不是類，編寫接口的方式和類很類似，但是它們屬於不同的概念。類描繪對象的屬性和辦法。接口則包括類要完成的辦法。

除非完成接口的類是籠統類，否則該類要定義接口中的一切辦法。

接口無法被實例化，但是可以被完成。一個完成接口的類，必需完成接口內所描繪的一切辦法，否則就必需聲明為籠統類。另外，在 Java 中，接口類型可用來聲明一個變量，他們可以成為一個空指針，或是被綁定在一個以此接口完成的對象。

• 一個接口可以有多個辦法。
• 接口文件保管在 .java 開頭的文件中，文件名運用接口名。
• 接口的字節碼文件保管在 .class 開頭的文件中。
• 接口相應的字節碼文件必需在與包稱號相婚配的目錄構造中。

• 接口不能用於實例化對象。
• 接口沒有結構辦法。
• 接口中一切的辦法必需是籠統辦法。
• 接口不能包括成員變量，除了 static 和 final 變量。
• 接口不是被類承繼了，而是要被類完成。
• 接口支持多重承繼。

• 接口中每一個辦法也是隱式籠統的,接口中的辦法會被隱式的指定為 public abstract（只能是 public abstract，其他修飾符都會報錯）。
• 接口中可以含有變量，但是接口中的變量會被隱式的指定為 public static final 變量（並且只能是 public，用 private 修飾會報編譯錯誤。
• 接口中的辦法是不能在接口中完成的，只能由完成接口的類來完成接口中的辦法。
• 接口是隱式籠統的，當聲明一個接口的時分，不用運用abstract關鍵字。
• 接口中每一個辦法也是隱式籠統的，聲明時異樣不需求abstract關鍵子。
• 接口中的辦法都是私有的。

• 籠統類中的辦法可以無方法體，就是能完成辦法的詳細功用，但是接口中的辦法不行。
• 籠統類中的成員變量可以是各品種型的，而接口中的成員變量只能是 public static final 類型的。
• 接口中不能還有靜態代碼塊以及靜態辦法(用 static 修飾的辦法)，而籠統類是可以有靜態代碼塊和靜態辦法。
• 一個類只能承繼一個籠統類，而一個類卻可以完成多個接口。

[可見度] interface 接口稱號 [extends 其他的類名] {
        // 聲明變量
        // 籠統辦法
}

當類完成接口的時分，類要完成接口中一切的辦法。否則，類必需聲明為籠統的類。

類運用implements關鍵字完成接口。在類聲明中，Implements關鍵字放在class聲明前面。

完成一個接口的語法，可以運用這個公式：

...class...implements 接口稱號[, 其他接口, 其他接口..., ...] ...

// Animal.java
interface Animal {
    public void eat();
    public void travel();
}

// Dog.java
public interface Dog extends Animal {
    public void FallInLove();
    public void HomePolice();
}

// Pig.java
public interface Pig {
    public void BigEat();
    public void Sleep();
}

// Sheep.java
public interface Sheep extends Animal, Pig {
    
}

// Animal.java
interface Animal {
    public void eat();
    public void travel();
}

// MammalInt.java
public class MammalInt implements Animal {
    
    public void eat(){
        System.out.println("Animal eat..");
    }
    
    public void travel(){
        System.out.println("Animal travel..");
    }
    
    public static void main(String args[]){
        MammalInt mobj = new MammalInt();
        mobj.eat();    //Animal eat..
        mobj.travel();    //Animal travel..
    }
    
}

為了更好地組織類，Java 提供了包機制，用於區別類名的命名空間。

• 1、把功用類似或相關的類或接口組織在同一個包中，方便類的查找和運用。

• 2、好像文件夾一樣，包也采用了樹形目錄的存儲方式。同一個包中的類名字是不同的，不同的包中的類的名字是可以相反的，當同時調用兩個不同包中相反類名的類時，應該加上包名加以區別。因而，包可以防止名字抵觸。

• 3、包也限定了訪問權限，擁有包訪問權限的類才干訪問某個包中的類。

Java 運用包（package）這種機制是為了避免命名抵觸，訪問控制，提供搜索和定位類（class）、接口、枚舉（enumerations）和正文（annotation）等。

package pkg1[．pkg2[．pkg3…]];

例如,一個Something.java 文件它的內容:
package net.java.util
public class Something{
   ...
}
# 它的途徑應該是 net/java/util/Something.java 這樣保管的

包聲明應該在源文件的第一行，每個源文件只能有一個包聲明，這個文件中的每個類型都使用於它。

假如一個源文件中沒有運用包聲明，那麼其中的類，函數，枚舉，正文等將被放在一個無名的包（unnamed package）中。

payroll 包名
Employee 類名

payroll.Employee    # 全名導入
import payroll.*;    
import payroll.Employee;