java的面向對象是什么

本篇文章給大家分享的是有關java的面向對象是什么，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

11、接口(interface)

引入：抽象類是從多個類中抽象出來的模板，若要將這種抽象進行得更徹底，就得用到一種特殊的“抽象類”→ 接口;

例子：

生活中聽說過的USB接口其實并不是我們所看到的那些插槽,而是那些插槽所遵循的一種規范;而我們看到的那些插槽是根據USB規范設計出來的實例而已,也就說插槽是USB的實例;

對應不同型號的USB設備而言,他們各自的USB插槽都需要遵循一個規范,遵守這個規范就可以保證插入插槽的設備能與主板正常通信;

對于同一種型號的主板上的多個USB插槽,他們有相同的數據交換方式,相同的實現細節,可認為他們都是同一個類的不同實例

我的總結：

接口只定義了類應當遵循的規范,卻不關心這些類的內部數據和其方法內的實現細節.

接口只規定了這些類里必須提供的方法;從而分離了規范和實現.增強了系統的可拓展性和維護性;

使用接口的好處,拓展性,維護性更好,所以我們在開發中會經常用到接口.（相當于定義了一種標準）

interface定義

接口定義一種規范,規定一個類必須做什么,但它不管如何具體去做;

[修飾符] interface 接口名 extends 父接口1,父接口2....

沒有構造方法,不能實例化;

接口只能繼承接口,不能繼承類

接口里沒有普通方法,方法全是抽象的;

接口里的方法默認修飾符是public abstract；

接口里的字段全是全局常量,默認修飾符是public static final;

接口里的成員包括(主要是前兩個)：

全局常量

公共的抽象方法

內部類(包括內部類,內部接口,內部枚舉類);

我的總結：

接口沒有構造方法，不能實例化！

接口里的方法全部是抽象的，沒有普通方法，有默認的修飾符 public abstract，必須全部覆寫！

12、接口的使用

格式:public class SubImpl  extends Super  implements IA,IB

接口可以多繼承,但是只能繼承接口,不能繼承類。

實現接口(支持多實現)

[修飾符] class 類名 implements 接口1，接口2...

接口的實現必須在 extends 之后；

實現接口的方法必須是 public 類型

接口與類之間的關系：

實現關系或者說是繼承關系.

可以說類實現了接口的方法，也可以說類繼承了接口的方法，不同情況下不同的理解！

13、面向接口編程之制定標準和簡單工廠模式

制定一個標準，讓別人去實現或者說滿足它！

Eg：
interface USB{//定義USB標準
    void useUSB();//USB有使用USB的行為
}

簡單工廠模式

構建一個工廠出來，在里面進行生產，用的時候直接拿

我的總結：

好處:屏蔽不同子類實現的差異，提高代碼的可拓展性和可維護性;

package reviewDemo;
 
//簡單工廠模式
 
 
 
interface Phone{//制定標準，都要實現send()方法
 
   public void send();
 
}
 
 
 
class Iphone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("Iphone手機在發短信");
 
   }
 
}
 
 
 
class AndroidPhone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("AndroidPhone手機在發短信");
 
   }
 
}
 
 
 
class MyPhone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("MyPhone手機在發短信");
 
   }
 
}
 
 
 
class Factory{
 
   public static void show(String type){//傳入參數，根據不同的類型個性化定制
 
      if(type.equals("")){//為空的情況，不用往下執行
 
         System.out.println("對不起，類型為空！,請重新輸入！");
 
         return;
 
      }
 
      Phone p = null;
 
      if("Iphone".equals(type)){//判斷類型
 
         p = new Iphone();
 
      }else if("AndroidPhone".equals(type)){
 
         p = new AndroidPhone();
 
      }else{
 
         p = new MyPhone();
 
      }
 
      p.send();
 
   }
 
}
 
 
 
public class FactoryDemo17 {
 
   public static void main(String[] args) {
 
     
 
      new Factory().show("Iphone");//調用方法
 
      new Factory().show("AndroidPhone");
 
      new Factory().show("MyPhone");
 
      new Factory().show("YourPhone");
 
      new Factory().show("");
 
   }
 
}

輸出：

Iphone手機在發短信

AndroidPhone手機在發短信

MyPhone手機在發短信

MyPhone手機在發短信

對不起，類型為空！

14、面向接口編程之適配器模式

使用一個現成的類，但是它的接口不完全符合你的需求,我只想要它其中的一個方法，不想覆寫其他的方法。

比如,窗體有變大,變小,關閉的行為,但是我現在只需要關閉行為;

package reviewDemo;
 
//適配器模式：只想用其中的某一個方法，用適配器作為中間的過渡
 
 
 
interface Windows{
 
   void max();
 
   void min();
 
   void close();
 
}
 
 
 
//適配器模式，實現接口所有的方法，但是不寫方法體！
 
class AdapterWindows implements Windows{
 
 
 
   @Override
 
   public void max() {
 
   }
 
 
 
   @Override
 
   public void min() {
 
   }
 
 
 
   @Override
 
   public void close() {
 
   }
 
  
 
}
 
 
 
class MyWindows extends AdapterWindows{
 
   //覆寫父類的方法
 
   public void close(){
 
      System.out.println("這個實現的是關閉功能！");
 
   }
 
}
 
 
 
public class Demo17 {
 
   public static void main(String[] args) {
 
      new MyWindows().close();
 
   }
 
}

接口和抽象類的比較

相同點:

都位于繼承的頂端,用于被其他實現或繼承;

都不能實例化;

都包含抽象方法,其子類都必須覆寫這些抽象方法;

區別:

抽象類為部分方法提供實現,避免子類重復實現這些方法,提供代碼重用性;接口只能包含抽象方法;

一個類只能繼承一個直接父類(可能是抽象類),卻可以實現多個接口;(接口彌補了Java的單繼承)

二者的選用:

優先選用接口,盡量少用抽象類;

需要定義子類的行為,又要為子類提供共性功能時才選用抽象類;

總結：接口不能有構造函數，抽象類是可以有構造函數的，

abstract可以定義構造函數（包括帶函數的構造函數），因為要保證其子類在創建的時候能夠進行正確的初始化，但是Abstract類不能被實例化。

知識點：如果不可以或者沒有創建對象，那么我們必須加上static修飾，不能用對象調用，就只好用類去調用。

16、匿名內部類

適合只使用一次的類

不能是抽象類，因為系統在創建匿名內部類的時候，會立即創建匿名內部類的對象。

匿名內部類不能定義構造器，因為匿名內部類沒有類名。

格式：
new 父類構造器([實參列表]) 或 接口()
{
//匿名內部類的類體部分
}

17、枚舉類

使用enum聲明,默認直接繼承了java.lang.Enum類，而不是Object類；

枚舉類的對象是固定的,實例個數有限,不可以再new( ),枚舉對象后可以跟()。

枚舉元素必須位于枚舉類體中的最開始部分,枚舉元素后要有分號與其他成員分隔。

枚舉類的構造方法的權限修飾符默認是private；

一旦枚舉對象后面加上{},那么該對象實際是枚舉匿名內部類對象;

所有枚舉類都提供一個靜態的values()方法(返回該枚舉類所有對象組成的數組),便于遍歷所有枚舉對象；

所有枚舉類都提供一個靜態的valueOf(String name)方法, 返回枚舉類中對象名等于 name的對象。

Eg：public enum Color{
 
        RED(), GREEN(){}, BLUE{};
 
}
 
 
 
 
 
package reviewDemo;
 
//枚舉
 
 
 
enum Color{
 
   Green,Blue,Yellow;
 
  
 
   @Override
 
   public String toString() {
 
      String ret = super.toString();
 
      switch (this) {
 
      case Green:
 
         ret = "綠色";
 
         break;
 
        
 
      case Blue:
 
         ret = "藍色";
 
         break;
 
        
 
      case Yellow:
 
         ret = "黃色";
 
         break;
 
 
 
      default:
 
         break;
 
      }
 
     
 
      return ret;
 
   }
 
  
 
}
 
 
 
class Personp{
 
   Color c = Color.Blue;
 
   void show(){
 
      System.out.println(c);
 
   }
 
}
 
 
 
public class Demo18 {
 
   public static void main(String[] args) {
 
      Color []color = Color.values();
 
      for (Color c : color) {
 
         System.out.println(c);
 
      }
 
      new Personp().show();
 
   }
 
}

輸出：

綠色

藍色

黃色

藍色

枚舉類覆寫接口抽象方法的兩種方式：

在枚舉類中實現接口的抽象方法；

在枚舉匿名內部類中實現接口的抽象方法；

interface I{
 
    void show();
 
}
 
 
 
enum Color implements I{
 
    RED(){
 
   public void show(){
 
        }
 
    }, GREEN{
 
   public void show(){
 
        }
 
    }, BLUE{
 
   public void show(){
 
        }
 
    };
 
}
 
 
 
enum Color implements I{
 
    RED(), GREEN, BLUE;
 
    public void show() {
 
    }
 
}

總結：枚舉不可以new();即便是反射也不可以！

備注：一個類如果沒有構造方法，那么一定有相對應的某個方法可以獲取對象！

以上就是java的面向對象是什么，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。