JAVA介面與抽象類別詳細解析

本篇文章為大家帶來了關於java的相關知識，其中主要整理了介面與抽象類別的相關問題，當需要從幾個類別中派生出一個類，繼承他們所有的屬性和方法，JAVA沒有多重繼承需要用介面實現，下面一起來看一下，希望對大家有幫助。

推薦學習：《java影片教學》

介面

概述

1. #當需要從幾個類別中派生出一個類，繼承他們所有的屬性和方法，JAVA沒有多重繼承需要用介面實作
2. 從幾個類別中抽取一些共同的行為特徵，而他們之間又沒有is-a的關係，也需要藉助介面實作
3. 介面本質是契約，規範

#使用

1. 介面中使用interface來定義
2. #介面和類別是兩個不同的結構
3. 介面中無法定義建構器（也就不能實例化）
4. 介面透過類別來實作implements
5. JAVA類別可以實作多個介面格式：class AA extends BB interface CC,DD
6. 介面與介面之間可以繼承，並且可以多重繼承
##介面體現了多態性

7. public class UsbTest {
       public static void main(String[] args) {
           Computer com =new Computer();
           Flash flash=new Flash();
           com.transferData(flash); // USB usb =new Flash()
           com.transferData(new Printer());
           /*
   		* U盘开始工作
   		* 传输数据
   		* U盘结束工作
   		* 打印机开始工作
   		* 传输数据
   		* 打印机结束工作
   		* 
   		* */
       }}class Computer{
       public void transferData(USB usb){
           usb.start();
           System.out.println("传输数据");
           usb.stop();
       }}interface USB{
       void start();
       void stop();}class Flash implements USB{
   
       @Override
       public void start() {
           System.out.println("U盘开始工作");
       }
   
       @Override
       public void stop() {
           System.out.println("U盘结束工作");
   
       }}class Printer implements USB{
   
       @Override
       public void start() {
           System.out.println("打印机开始工作");
   
       }
   
       @Override
       public void stop() {
           System.out.println("打印机结束工作");
   
       }}

JDK8的寫法

介面中定義的
• 靜態方法，只能透過介面呼叫
透過實作類別的對象，可以實現接口中的預設方法
• 如果子類（或者實現類）繼承的父類和實現的接口中聲明了同名同參數方法，如果子類沒有重寫該方法，調用的是父類別中同名同參數方法

public class JDK8Test {
    public static void main(String[] args) {
        SubClass sub =new SubClass();
        CompareA.methods1();
        sub.methods2();
        /*
        * Compare 北京
		* Compare 上海
        */
    }}class SubClass implements CompareA{}interface CompareA{
    public static void methods1() {
        System.out.println("Compare 北京");
    }
    public default void methods2() {
        System.out.println("Compare 上海");
    }}

代理模式

代理模式就是為其他物件提供一個代理程式以控制對這個物件的存取
1. 實例

2. public class NetWorkTest {
       public static void main(String[] args) {
           Server server=new Server();
           ProxyServer proxyServer=new ProxyServer(server); // 放的是被代理对象进去
           proxyServer.browse(); // 调用的是代理对象，但结果是真实对象的方法被调用
           /*
           * 检查工作
   		* 真实服务器访问网络
           */
       }}interface NetWork{
       void browse();}// 被代理类class Server implements NetWork{
   
       @Override
       public void browse() {
           System.out.println("真实服务器访问网络");
       }}// 代理类class ProxyServer implements NetWork{
       private NetWork work;
       public ProxyServer(NetWork work){
           this.work=work;
       }
       public void check(){
           System.out.println("检查工作");
       }
   
       @Override
       public void browse() {
           check();
           work.browse();
       }}

內部類別

JAVA允許將一個類別A宣告在另一個類別B中，則類別A是內部類，類別B是外部類別
1. 內部類別分類

成員內部類別
• 靜態static
  • 非靜態
局部內部類別
• 方法內
  • 程式碼區塊內
  • 建構器內部

##實例化內部類別物件

3. public class InnerClassTest {
       public static void main(String[] args) {
           // 实例化Dog，静态类
           Pseson.Dog dog=new Pseson.Dog();
           dog.eat();
           // 吃骨头
           // 实例化Cat，非静态类
           Pseson p1 =new Pseson();
           Pseson.Cat cat=p1.new Cat();
           cat.eat();
           // 猫吃鱼
       }}class Pseson{
       String name;
       int age;
       public void eat(){
           System.out.println("吃饭");
       }
       static class Dog{
           String name;
           int age;
           public void eat(){
               System.out.println("吃骨头");
           }
       }
       class Cat{
           public void eat(){
               System.out.println("猫吃鱼");
           }
       }}

呼叫外部類別結構

4. public class InnerClassTest {
       public static void main(String[] args) {
           // 实例化Cat，非静态类
           Pseson p1 =new Pseson();
           Pseson.Cat cat=p1.new Cat();
           cat.eat();
           cat.display("小花");
           /*
           * 小花
           * 波斯猫
           * 人
           */ 
       }}class Pseson{
       String name="人";
       int age;
       public void eat(){
           System.out.println("吃饭");
       }
       static class Dog{
           String name;
           int age;
           public void eat(){
               System.out.println("吃骨头");
           }
       }
       class Cat{
           String name="波斯猫";
           public void eat(){
               System.out.println("猫吃鱼");
           }
           public void display(String name){
               System.out.println(name); // 方法中name
               System.out.println(this.name); // 内部类中name
               System.out.println(Pseson.this.name); // 外部类中name
   
           }
       }}

介面與抽象類別

相同點：不能實例化；都包含抽象方法；能被繼承

• 不同點：抽象類別有建構器，介面沒有建構器；抽象類別只有單一繼承，而介面可以多繼承；抽象類別extands繼承，介面implements實作
• 推薦學習：《

java影片教學

》

以上是JAVA介面與抽象類別詳細解析的詳細內容。更多資訊請關注PHP中文網其他相關文章！