java 跳转 oop_Java基础之：OOP——接口
Java基礎之：OOP——接口
usb插槽就是現實中的接口，可以把手機,相機,u盤都插在usb插槽上,而不用擔心那個插槽是專門插哪個的,原因是做usb插槽的廠家和做各種設備的廠家都遵守了統一的規定包括尺寸，排線等等。
而在java中我們也可以實現類似這樣的功能。
簡單案例
package class_interface;
?
public class Class_Test {
?
public static void main(String[] args) {
Computer computer = new Computer();
//使用USB接口，多態傳入
//1. 在java中， 允許 將一個實現了某個接口的 類的對象，傳遞給該接口的一個引用
//2. 在接口使用過程中，仍然遵守我們的多態和動態綁定機制
computer.work(new Phone()); //匿名對象做傳入參數
computer.work(new U_disk());
}
?
}
?
class Computer{
//Computer類使用了USB接口
public void work(USB usb) { //輸入參數實現接口的多態
usb.start();
usb.stop();
}
?
}
?
//聲明一個接口使用 interface 關鍵字
interface USB{
//對于接口內寫的所有方法而言，都是默認帶有abstract關鍵字修飾的，即抽象方法
public void start();
public void stop();
//在jdk8.0之后，接口中也可以實現方法，但必須是靜態方法與默認方法，例如：
//因為可能會出現一個接口我們會頻繁的使用，且對于接口中的某一個方法都實現一樣的作用。
//那么在接口中實現靜態/默認方法后，在實現接口的類中，直接調用此方法即可。不需要再重寫實現此方法
default public void hi() {
System.out.println("say hi....");
}
public static void hello() {
System.out.println("say hello....");
}
}
?
//實現一個接口使用 implements 關鍵字，接口與抽象類很類似
//實現了接口的類，也需要實現接口中的所有抽象方法
class Phone implements USB{
?
@Override
public void start() {
System.out.println("手機開始工作....");
}
?
@Override
public void stop() {
System.out.println("手機停止工作....");
hi();
}
}
?
class U_disk implements USB{
?
@Override
public void start() {
System.out.println("U盤開始工作....");
}
?
@Override
public void stop() {
System.out.println("U盤停止工作....");
}
}
程序輸出
手機開始工作....
手機停止工作....
say hi....
U盤開始工作....
U盤停止工作....
接口介紹
接口就是將沒有實現的抽象方法放在一起，當有類需要使用這些方法時，則根據實際情況將這個方法實現出來。
聲明語法：
創建接口
interface接口名{
//屬性
//抽象方法
}
使用接口
class 類名 implements接口名{
//類自己的屬性
//類自己的方法
//必須實現接口中的抽象方法
}
小結：接口是更加抽象的抽象的類，抽象類里的方法可以有方法體，接口里的所有方法都沒有
方法體。
接口使用細節
1) 接口不能被實例化
2) 接口中所有的方法是 public方法, 接口中抽象方法，可以不用abstract 修飾
3) 一個普通類實現接口,就必須將該接口的所有方法都實現。
4) 抽象類實現接口，可以不用實現接口的方法。
5) 一個類同時可以實現多個接口
6) 接口中的屬性,只能是final的，而且是 public static final 修飾符。比如： int a=1; 實際上是 public static final int a=1; (必須初始化)
7) 接口中屬性的訪問形式: 接口名.常量名
8) 一個接口不能繼承其它的類,但是可以繼承多個別的接口
9) 接口的修飾符 只能是 public 和默認，這點和類的修飾符是一樣的。
細節案例
package class_interface;
public class InterfaceDetail {
public static void main(String[] args) {
}
}
?
//接口命名習慣： 大寫I + 接口名 ， 例如：IUser
interface IA{
public void m1();
public void m2();
}
?
interface IB{
public void m1();
public void m3();
}
?
?
//細節1.一個普通類實現接口,就必須將該接口的所有方法都實現。
class CA implements IA{
?
@Override
public void m1() {
?
}
?
@Override
public void m2() {
}
}
?
//細節2.抽象類實現接口，可以不用實現接口的方法。
abstract class CB implements IA{
//這點很容易理解，因為抽象類中允許繼承下來的抽象方法不進行重寫實現。
}
?
//細節3：一個類同時可以實現多個接口 ,且必須實現多個接口中的所有抽象方法
//這里我們會發現，IA與IB接口中，m1()方法重名了，但在CC類中實現并沒有報錯。
//理解：因為m1()方法,僅是接口定義的一個規范，需要類來實現這個規范，而我們只要實現了m1()方法，則IA與IB接口可以使用
class CC implements IA,IB{
?
@Override
public void m3() {
}
?
@Override
public void m1() {
}
?
@Override
public void m2() {
}
}
?
//細節4：接口中的屬性,只能是final的，而且是 public static final 修飾符。
//比如： int a=1; 實際上是 public static final int a=1; (必須初始化)
interface IC{
int a = 1;
// private int b = 2;
/*
* 這里使用private聲明之后，報錯：
* Illegal modifier for the interface field IC.b; only public, static & final are permitted
*/
}
?
//細節5：接口中屬性的訪問形式: 接口名.常量名
class CD implements IC{
//這點也很好理解，因為屬性a是默認被static修飾的，所以只能使用接口名訪問
public void say() {
System.out.println(IC.a);
}
}
?
//細節6：一個接口不能繼承其它的類,但是可以繼承多個別的接口
interface ID extends /*CD*/ IA,IB,IC{
//如果繼承CD類的話，報錯：
//The type CD cannot be a superinterface of ID; a superinterface must be an interface
/*
* 這點容易出現混淆，因為我們之前說Java是單繼承的，但接口這里好像又出現了多繼承的情況
* 我們可以這樣理解，電腦通過USB接口連接上了USB轉換器，通過USB轉換器，我們連接上了讀卡器
* 那么就說，USB接口通過繼承USB連接器擴展了可以連接讀卡器的功能。
* 所以對于接口的繼承而言，并不像是父類與子類的關系，而是使用繼承機制，擴展單個接口的功能。
*/
}
?
//細節7:接口的修飾符 只能是 public 和默認，這點和類的修飾符是一樣的。
/*private*/ interface IE {
/*
* 使用private 報錯：Illegal modifier for the interface IE; only public & abstract are permitted
* 這里可以看到只能使用public與abstract修飾，當然也可以不修飾(即默認)。
* 而使用abstract修飾又顯得有一些多余，因為接口本來就是抽象的概念。
*/
}
實現接口與繼承父類之間的區別
繼承的價值主要在于：解決代碼的復用性和可維護性。
接口的價值主要在于：設計，設計好各種規范(方法)，讓其它類去實現這些方法。
接口比繼承更加靈活，繼承是滿足 is - a的關系，而接口只需滿足 like - a的關系。
接口在一定程度上實現代碼解耦。
簡單案例
package class_interface;
?
public class ImplementsVSExtends {
/*
* 討論實現接口 與 繼承類，到底有什么樣的區別
* 雖然兩者都具有實現功能擴展的能力
*/
public static void main(String[] args) {
/*
* 可以看到這里 對象a 即能夠使用 父類 Person中的eat也能夠使用接口IFish中的swimming
* 但我們可以這樣理解，為什么要使用接口來定義swimming方法。
* 人類與生俱來的能力就一定會吃東西，但游泳并不是與生俱來的能力。即繼承Person
* 那么運動員為了擁有游泳的能力就去向小魚學習，即實現接口IFish。
*
* 總結：
* 繼承：父類是通過子類擴展其已有的方法與功能。
* 實現：類通過接口擴展類所需要的方法與功能。
*/
Athletes a = new Athletes("小范");
a.eat();
a.swimming();
?
}
}
?
class Person{
private String name;
public String getName() {
return name;
}
?
public void setName(String name) {
this.name = name;
}
public Person(String name) {
super();
this.name = name;
}
?
public void eat() {
System.out.println(name + "吃東西....");
}
}
?
interface IFish{
public void swimming();
}
?
class Athletes extends Person implements IFish{
?
public Athletes(String name) {
super(name);
}
?
@Override
public void swimming() {
System.out.println(getName() + "游泳.....");
}
}
程序輸出
小范吃東西....
小范游泳.....
接口的多態特性
在前面的Usb接口案例，Usb usb ，既可以接收手機對象，又可以接收U盤對象，就體現了 接口 多態 (接口引用可以指向實現了接口的類的對象)
簡單案例
演示一個案例：給Usb數組中，存放 Phone 和 相機對象，Phone類還有一個特有的方法call()，請遍歷Usb數組，如果是Phone對象，除了調用Usb 接口定義的方法外，還需要調用Phone 特有方法 call。以及U盤的特有方法read。
package class_interface.InterfacePolyArray;
?
public class InterfacePolyArray {
?
public static void main(String[] args) {
USB[] u = new USB[2];
u[0] = new Phone();
u[1] = new U_disk();
for (int i = 0; i < u.length; i++) {
work(u[i]);
}
}
public static void work(USB usb) { //輸入參數實現接口的多態
usb.start();
usb.stop();
if(usb instanceof Phone) {
((Phone) usb).call();
}else if(usb instanceof U_disk) {
((U_disk) usb).read();
}
}
?
}
?
interface USB{
public void start();
public void stop();
}
?
class Phone implements USB{
?
@Override
public void start() {
System.out.println("手機開始工作....");
}
?
@Override
public void stop() {
System.out.println("手機停止工作....");
}
public void call() {
System.out.println("手機開始打電話......");
}
}
?
class U_disk implements USB{
?
@Override
public void start() {
System.out.println("U盤開始工作....");
}
?
@Override
public void stop() {
System.out.println("U盤停止工作....");
}
public void read() {
System.out.println("U盤開始讀取數據.....");
}
}
程序輸出
手機開始工作....
手機停止工作....
手機開始打電話......
U盤開始工作....
U盤停止工作....
U盤開始讀取數據.....
接口的多態傳遞
接口的多態傳遞解讀：
當一個類實現了某個接口
這個類的對象可以賦給該接口的引用
如果這個類被繼承，那么這個類的子類的對象，也可以賦給該接口的引用
如果這個接口是繼承來的，那么這個對象也可以賦給該接口的上層接口的引用
不限于一級，可以多級傳遞.
簡單案例
package class_interface.InterfacePolymorphicPass;
/**
下面程序的繼承關系：
IC 繼承于 IB ，IB 繼承于 IA
CA 實現了接口 IC，CB 繼承于 CA
show方法的實際傳入參數：
傳入參數是IC時，可以識別CA與CB的對象 ，因為CA實現了IC 且 CB繼承于CA
而傳入參數是IA時，也可以識別CA與CB的對象，因為CA實現的IC是繼承于IA的(子類對象可以賦值給父類引用)。
?
*/
public class InterfacePolymorphicPass {
?
public static void main(String[] args) {
CA ca = new CA();
CB cb = new CB();
show(ca);
show2(ca);
show3(ca);
System.out.println("=================");
show(cb);
show2(cb);
show3(cb);
}
public static void show(IC ic) {
ic.m4();
}
public static void show2(IB ib) {
ib.m3();
}
public static void show3(IA ia) {
ia.m1();
ia.m2();
}
}
?
interface IA{
void m1();
void m2();
}
?
interface IB extends IA{
void m3();
}
?
interface IC extends IB{
void m4();
}
?
class CA implements IC{
?
@Override
public void m1() {
System.out.println("CA--IA--m1");
}
?
@Override
public void m2() {
System.out.println("CA--IA--m2");
}
?
@Override
public void m3() {
System.out.println("CA--IB--m3");
}
?
@Override
public void m4() {
System.out.println("CA--IC--m4");
}
}
?
class CB extends CA{
@Override
public void m3() {
System.out.println("CB--IB--m3");
}
@Override
public void m4() {
System.out.println("CB--IC--m4");
}
}
程序輸出
CA--IC--m4
CA--IB--m3
CA--IA--m1
CA--IA--m2
============
CB--IC--m4
CB--IB--m3
CA--IA--m1
CA--IA--m2
總結
以上是生活随笔為你收集整理的java 跳转 oop_Java基础之：OOP——接口的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： “所说不如此”上一句是什么
- 下一篇： java升序问题_JAVA并发理解之重排