• 接口的基本概念


    接口是java中最重要的概念,接口可以理解为一种特殊的类,里面全部是由全局常量公共的抽象方法所组成。

    如果一个类中完全是由全局常量(static final)和抽象方法组成,就可以将其定义成一个接口

    接口定义格式:

    interface 接口名称
    {
          全局常量;
          抽象方法;    
    }    

    例子:

    interface A{        // 定义接口A
        public static final String AUTHOR = "李兴华" ;    // 全局常量
        public abstract void print() ;    // 抽象方法
        public abstract String getInfo() ;    // 抽象方法
    }

    对于接口来讲,因为在其定义的时候已经定义了其组成就是全局常量和抽象方法,所以开发中往往可以简化定义。

    interface A{        // 定义接口A
        String AUTHOR = "李兴华" ;    // 全局常量
        void print() ;    // 抽象方法
        String getInfo() ;    // 抽象方法
    }

    以上两种定义方式是完全一样的,没有任何区别(对于第二种,程序在编译的时候会自动加上 public abstract)。

    接口的图形表示形式

    接口图形表示既可以按照类图的形式表示,也可以使用一个“0”表示:

    接口的使用中也必须要有子类子类必须覆写全部抽象方法,子类通过“implements”关键字实现,一个子类可以实现多个接口

    则子类如果不是抽象类的话,肯定要覆写全部抽象方法。

    interface A{        // 定义接口A
        public String AUTHOR = "李兴华" ;    // 全局常量
        public void print() ;    // 抽象方法
        public String getInfo() ;    // 抽象方法
    }
    interface B{    // 定义接口B
        public void say() ;    // 定义抽象方法,省略了abstract
    }
    class X implements A,B{    // X类同时实现A和B两个接口
        public void say(){
            System.out.println("Hello World!!!") ;
        }
        public String getInfo(){
            return "HELLO" ;
        }
        public void print(){
            System.out.println("作者:" + AUTHOR) ;
        }
    };
    public class InterfaceDemo03{
        public static void main(String args[]){
            X x = new X() ;    // 实例化子类对象
            x.say() ;
            x.print() ;
        }
    };

    以上程序,一个子类实现两个接口,这样在子类中必须同时覆写两个接口中全部抽象方法。

    继承抽象类,实现接口

    一个子类同时继承抽象类,和实现接口。

    格式如下:class 子类 extends  抽象类  implements  接口A,接口B,,,,,{}

    interface A{        // 定义接口A
        public String AUTHOR = "李兴华" ;    // 全局常量
        public void print() ;    // 抽象方法
        public String getInfo() ;    // 抽象方法
    }
    abstract class B{    // 定义抽象类B
        public abstract void say() ;    // 定义抽象方法
    }
    class X extends B implements A{    // X类线继承B类,再实现A接口
        public void say(){
            System.out.println("Hello World!!!") ;
        }
        public String getInfo(){
            return "HELLO" ;
        }
        public void print(){
            System.out.println("作者:" + AUTHOR) ;
        }
    };
    public class InterfaceDemo04{
        public static void main(String args[]){
            X x = new X() ;    // 实例化子类对象
            x.say() ;
            x.print() ;
        }
    };

    在使用中,一个抽象类可以实现一个接口,那么对于抽象类的子类,则必须覆写抽象类和接口的全部(未实现的)抽象方法。(即如果接口中的某类方法在抽象类中实现了(覆写了),那么在抽象类的子类中就可以不用覆写了。因为继承,在父类中的方法,被子类继承了,相当于子类覆写了,子类照样可以调用,覆写该方法。

    interface A{        // 定义接口A
        public String AUTHOR = "李兴华" ;    // 全局常量
        public void print() ;    // 抽象方法
        public String getInfo() ;    // 抽象方法
    }
    abstract class B implements A{    // 定义抽象类B,实现接口A
        public abstract void say() ;    // 定义抽象方法
    }
    class X extends B{    // X类线继承B类
        public void say(){
            System.out.println("Hello World!!!") ;
        }
        public String getInfo(){
            return "HELLO" ;
        }
        public void print(){
            System.out.println("作者:" + AUTHOR) ;
        }
    };
    public class InterfaceDemo05{
        public static void main(String args[]){
            X x = new X() ;    // 实例化子类对象
            x.say() ;
            x.print() ;
        }
    };

    如果抽象类中实现了接口中的一些方法,那么,抽象类子类就可以不用覆写该方法。

    package methoud;
    interface A{        // 定义接口A
        public String AUTHOR = "李兴华" ;    // 全局常量
        public void print() ;    // 抽象方法
        public String getInfo() ;    // 抽象方法
    }
    abstract class B implements A{    // 定义抽象类B,实现接口A
        public abstract void say() ;    // 定义抽象方法
        public void print(){};
    }
    class X extends B{    // X类线继承B类
        public void say(){
            System.out.println("Hello World!!!") ;
        }
        public String getInfo(){
            return "HELLO" ;
        }
      
    };
    public class ThisDemo06{
        public static void main(String args[]){
            X x = new X() ;    // 实例化子类对象
            x.say() ;
            x.print() ;
        }
    };

    一个接口虽然不能继承抽象类,但是一个接口可以继承多个接口(使用的是extends),实现接口的多继承。

    interface A{        // 定义接口A
        public String AUTHOR = "李兴华" ;    // 全局常量
        public void printA() ;    // 抽象方法
    }
    interface B{
        public void printB() ;
    }
    interface C extends A,B{    //注意,这里接口继承接口是extends,而不是implements
        public void printC() ;
    }
    class X implements C{    // X类线继承B类
        public void printA(){
            System.out.println("A、Hello World!!!") ;
        }
        public void printB(){
            System.out.println("B、Hello MLDN") ;
        }
        public void printC(){
            System.out.println("C、Hello LXH") ;
        }
    };
    public class InterfaceDemo06{
        public static void main(String args[]){
            X x = new X() ;    // 实例化子类对象
            x.printA() ;
            x.printB() ;
            x.printC() ;
        }
    };

    总结

    一,接口只是一个特殊的类,只包含全局常量和抽象方法,

    1)接口的抽象方法可以不加abstract。

    2)抽象类的抽象方法必须有abstract关键字。

    二,一个类只能继承一个父类,但是可以同时实现多个接口。

    三,一个接口可以同时继承多个接口(extends),以实现接口的多继承。

    四,接口和抽象类一样,都必须依靠子类。

    五,一个抽象类可以实现多个接口,但是一个接口不能继承一个抽象类。

  • 相关阅读:
    从另一个角度看奋斗史——01.小人之为
    出差!出差!!又是烦人的出差!!!奋斗史无奈暂缓更新~
    出差!出差!!又是烦人的出差!!!奋斗史无奈暂缓更新~
    从另一个角度看奋斗史——01.小人之为
    《那些年啊,那些事——一个程序员的奋斗史》——124
    出差!出差!!又是烦人的出差!!!奋斗史无奈暂缓更新~
    《那些年啊,那些事——一个程序员的奋斗史》——123
    《那些年啊,那些事——一个程序员的奋斗史》——123
    《那些年啊,那些事——一个程序员的奋斗史》——124
    TSINGSEE研发的RTMP视频推流网关是什么?如何使用?
  • 原文地址:https://www.cnblogs.com/alsf/p/5528741.html
Copyright © 2020-2023  润新知