一起學 Java 面向對象（二），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
打印一個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）是指，一種將抽象性函式接口的實作細節部份包裝、隱藏起來的方法。
封裝可以被認為是一個保護屏障，防止該類的代碼和數據被外部類定義的代碼隨機訪問。
要訪問該類的代碼和數據，必須通過嚴格的接口控制。
封裝最主要的功能在於我們能修改自己的實現代碼，而不用修改那些調用我們代碼的程序片段。
適當的封裝可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。
封裝的優點
![]()
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 中，接口類型可用來聲明一個變量，他們可以成為一個空指針，或是被綁定在一個以此接口實現的對象。
接口與類相似點：
- 一個接口可以有多個方法。
- 接口文件保存在 .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..
}
}
practice
九、包（package）
為了更好地組織類，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;
