一起學 Java 面向對象（二）

来源:http://www.cnblogs.com/suoning/archive/2016/12/30/6139235.html
-Advertisement-
Play Games

一、方法函數 函數也稱為方法，就是定義在類中的具有特定功能的一段獨立代碼。用於定義功能，提高代碼的復用性。 函數的特點1> 定義函數可以將功能代碼進行封裝，便於對該功能進行復用；2> 函數只有被調用才會被執行；3> 對於函數沒有具體返回值的情況，返回值類型用關鍵字void表示，那麼該函數中的retu ...


一、方法函數

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

函數的特點
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
列印一個99乘法表 
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
可變參數實例

 

finalize() 方法

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
finalize() 方法實例

 

二、修飾符類型

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

類：

訪問修飾符 修飾符 class 類名稱 extends 父類名稱 implement 介面名稱
（訪問修飾符與修飾符的位置可以互換）
訪問修飾符
名稱 說明 備註
public 可以被所有類訪問（使用） public類必須定義在和類名相同的同名文件中
package 可以被同一個包中的類訪問（使用） 預設的訪問許可權，可以省略此關鍵字，可以定義在和public類的同一個文件中
修飾符
名稱 說明 備註
final 使用此修飾符的類不能夠被繼承  
abstract 如果要使用abstract類，之前必須首先建一個繼承abstract類的新類，新類中實現abstract類中的抽象方法。 類只要有一個abstract方法，類就必須定義為abstract，但abstract類不一定非要保護abstract方法不可
 

變數：

l         Java中沒有全局變數，只有方法變數、實例變數（類中的非靜態變數）、類變數（類中的靜態變數）。 l         方法中的變數不能夠有訪問修飾符。所以下麵訪問修飾符表僅針對於在類中定義的變數。 l         聲明實例變數時，如果沒有賦初值，將被初始化為null（引用類型）或者0、false（原始類型）。 l         可以通過實例變數初始化器來初始化較複雜的實例變數，實例變數初始化器是一個用{}包含的語句塊，在類的構造器被調用時運行，運行於父類構造器之後，構造器之前。 l         類變數（靜態變數）也可以通過類變數初始化器來進行初始化，類變數初始化器是一個用static{}包含的語句塊，只可能被初始化一次。  
訪問修飾符
名稱 說明 備註
public 可以被任何類訪問  
protected 可以被同一包中的所有類訪問 可以被所有子類訪問 子類沒有在同一包中也可以訪問
private 只能夠被當前類的方法訪問  
預設 無訪問修飾符 可以被同一包中的所有類訪問 如果子類沒有在同一個包中，也不能訪
修飾符
名稱 說明 備註
static 靜態變數（又稱為類變數，其它的稱為實例變數） 可以被類的所有實例共用。 並不需要創建類的實例就可以訪問靜態變數
final 常量，值只能夠分配一次，不能更改 註意不要使用const，雖然它和C、C++中的const關鍵字含義一樣 可以同static一起使用，避免對類的每個實例維護一個拷貝
transient 告訴編譯器，在類對象序列化的時候，此變數不需要持久保存 主要是因為改變數可以通過其它變數來得到，使用它是為了性能的問題
volatile 指出可能有多個線程修改此變數，要求編譯器優化以保證對此變數的修改能夠被正確的處理  

 

方法：

訪問修飾符 修飾符 返回類型 方法名稱（參數列表）throws 違例列表
l         類的構造器方法不能夠有修飾符、返回類型和throws子句 l         類的構造器方法被調用時，它首先調用父類的構造器方法，然後運行實例變數和靜態變數的初始化器，然後才運行構造器本身。 l         如果構造器方法沒有顯示的調用一個父類的構造器，那麼編譯器會自動為它加上一個預設的super()，而如果父類又沒有預設的無參數構造器，編譯器就會報錯。super必須是構造器方法的第一個子句。 l         註意理解private構造器方法的使用技巧。
訪問修飾符
名稱 說明 備註
public 可以從所有類訪問  
protected 可以被同一包中的所有類訪問 可以被所有子類訪問 子類沒有在同一包中也可以訪問
private 只能夠被當前類的方法訪問  
預設 無訪問修飾符 可以被同一包中的所有類訪問 如果子類沒有在同一個包中，也不能訪問
修飾符
名稱 說明 備註
static 靜態方法（又稱為類方法，其它的稱為實例方法） 提供不依賴於類實例的服務 並不需要創建類的實例就可以訪問靜態方法
final 防止任何子類重載該方法 註意不要使用const，雖然它和C、C++中的const關鍵字含義一樣 可以同static一起使用，避免對類的每個實例維護一個拷貝
abstract 抽象方法，類中已聲明而沒有實現的方法 不能將static方法、final方法或者類的構造器方法聲明為abstract
native 用該修飾符定義的方法在類中沒有實現，而大多數情況下該方法的實現是用C、C++編寫的。 參見Sun的Java Native介面（JNI），JNI提供了運行時載入一個native方法的實現，並將其於一個Java類關聯的功能
synchronized 多線程的支持 當一個此方法被調用時，沒有其它線程能夠調用該方法，其它的synchronized方法也不能調用該方法，直到該方法返回

 

介面：

訪問修飾符 interface 介面名稱 extends 介面列表 l         介面不能夠定義其聲明的方法的任何實現 l         介面中的變數總是需要定義為“public static final 介面名稱”，但可以不包含這些修飾符，編譯器預設就是這樣，顯示的包含修飾符主要是為了程式清晰
訪問修飾符
名稱 說明
public 所有 
無訪問修飾符（預設） 同一個包內

 

三、類的繼承

繼承的特性：

  • 子類擁有父類非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
    }
}
practice

 

四、重寫(Override)與重載(Overload)

方法的重寫(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方法。
    }
}
practice

 

重載(overloading)

是在一個類裡面，方法名字相同，而參數不同。返回類型可以相同也可以不同。

每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。

只能重載構造函數

重載規則：

  • 被重載的方法必須改變參數列表(參數個數或類型或順序不一樣)；
  • 被重載的方法可以改變返回類型；
  • 被重載的方法可以改變訪問修飾符；
  • 被重載的方法可以聲明新的或更廣的檢查異常；
  • 方法能夠在同一個類中或者在一個子類中被重載。
  • 無法以返回值類型作為重載函數的區分標準。
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
    }
}
practice

 

五、多態

多態的優點

  • 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("看家");  
    }  
}
practice

 

六、抽象類

如果你想設計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現由它的子類確定，那麼你可以在父類中聲明該方法為抽象方法。

Abstract關鍵字同樣可以用來聲明抽象方法，抽象方法只包含一個方法名，而沒有方法體。

抽象方法沒有定義，方法名後面直接跟一個分號，而不是花括弧。

聲明抽象方法會造成以下兩個結果：

  • 如果一個類包含抽象方法，那麼該類必須是抽象類。
  • 任何子類必須重寫父類的抽象方法，或者聲明自身為抽象類。

繼承抽象方法的子類必須重寫該方法。否則，該子類也必須聲明為抽象類。最終，必須有子類實現該抽象方法，否則，從最初的父類到最終的子類都不能用來實例化對象。

抽象類規定1. 抽象類不能被實例化(初學者很容易犯的錯)，如果被實例化，就會報錯，編譯無法通過。只有抽象類的非抽象子類可以創建對象。

  • 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();
    }
}
practice

 

七、封裝

在面向對象程式設計方法中，封裝（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;
    }
}
practice

 

八、介面

介面（Interface），在JAVA編程語言中是一個抽象類型，是抽象方法的集合，介面通常以interface來聲明。一個類通過繼承介面的方式，從而來繼承介面的抽象方法。

介面並不是類，編寫介面的方式和類很相似，但是它們屬於不同的概念。類描述對象的屬性和方法。介面則包含類要實現的方法。

除非實現介面的類是抽象類，否則該類要定義介面中的所有方法。

介面無法被實例化，但是可以被實現。一個實現介面的類，必須實現介面內所描述的所有方法，否則就必須聲明為抽象類。另外，在 Java 中，介面類型可用來聲明一個變數，他們可以成為一個空指針，或是被綁定在一個以此介面

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 開博第一天
    在園子也逛了快5年了，一直在學習別人的經驗，在工作中也是發現問題，網上找解決方案，然後照葫蘆畫瓢，每次都想著要留下點什麼，可總是以各種理由忘記寫。今天終於鼓起勇氣開通了博客，希望以後能把每次遇到問題的解決方案留下給後來者。同時把一些經驗分享給大家。 ...
  • CoreCRM 開發實錄——開始之新項目的技術選擇
    2016年11月，接受了一個工作，是對“悟空CRM”進行一些修補。這是一個不錯的 CRM，開源，並提供一個 SaaS 的服務。正好微軟的 .NET Core 和 ASP.NET Core 也發佈了。於是就有了這個想法：使用 ASP.NET Core 來開發一個 CRM。當然這裡面的私心是：朝後坦白講 ...
  • Html.DropDownLis綁定資料庫
    效果： 方法一： View: 註："f_GroupID"相當於name="f_GroupID"，我用的是KendoUI的Grid,所以name="f_GroupID"綁定的是kendo的schema的 f_GroupID Controller: 實體： 方法二： View: Controller: ...
  • Xamarin與Visual stuido2015離線安裝包分享
    Xamarin與VisualStudio2015離線安裝包打包方法介紹，以及最後分享打包好的離線包在百度網盤https://pan.baidu.com/s/1o8pWvBO（7Zip解壓）。幫助大伙擺脫無法正常安裝Xamarin開發環境的苦惱。 ...
  • Autofac - 屬性註入
    屬性註入不同於通過構造函數方式傳入參數. 這裡是通過註入的方式, 在類創建完畢之後, 資源釋放之前, 給屬性賦值. 這裡, 我重新弄一些類來演示這一篇吧. 1. 一般方法 這種方法, 不止可以註入屬性, 還可以給欄位賦值 2. 反射的方式 這裡需要註意一點, 由於ClassC中有ClassD格式的屬 ...
  • 水印第四版 ~ 非人水印（添加人臉識別）
    demo:https://github.com/dunitian/DNTLive/tree/master/Software/WaterMarkAPP/LoTWaterAPP 說起這個人臉識別，還真有點緣分。記得逆天以前在學生時代參加創新大賽的時候，題目就是人臉識別打卡 解決別人替人打卡的問題，想想看 ...
  • WPF 微信 MVVM 【續】修複部分用戶無法獲取列表
    看過我WPF 微信 MVVM這篇文章的朋友，應該知道我裡面提到了我有一個小號是無法獲取列表的，始終也沒找到原因。 前兩天經過GitHub上h4dex大神的指導，知道了原因，是因為微信在登錄以後，web微信採取了不同的功能變數名稱來相容各種用戶。 下麵是大神提供的js代碼和C#代碼 function () { ...
  • 【Java每日一題】20161230
    今日問題： 請問主程式輸出結果是什麼？（點擊以下“【Java每日一題】20161230”查看20161229問題解析） 題目原發佈於公眾號、簡書：【Java每日一題】20161230，【Java每日一題】20161230 註：weknow團隊近期開通並認證了分答，歡迎大家收聽，有問題也歡迎到分答來咨 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類