抽象类与接口

最新推荐文章于 2022-10-20 16:15:41 发布

原创最新推荐文章于 2022-10-20 16:15:41 发布 · 182 阅读

0 ·

CC 4.0 BY-SA版权

本文深入探讨了接口与抽象类的使用原则，包括接口的定义、实现方式、多继承特性，以及与抽象类的组合使用。同时，文章还介绍了接口间类型转换、抽象类实现多个接口、接口继承等高级主题。

定义：是抽象类与全局常量的集合
1.接口的使用优先原则：在抽象类和接口都可以使用的情况下，优先选择接口
2.接口使用interface定义；子类实现接口使用implements关键字

interface A{
    public static final String MSG = "some";
    void print();
}
class B implements A{
    public void print(){
    
    }
}

3.子类可以有多个父接口（接口多继承）；抽象类只能有一个父类

interface A{
    void print();
}
interface B{
    void fun();
}
interface C{
    void happy();
}
class D implements A,B,C{
    @Override
    public void print() {
        System.out.println("我是A");
    }

    @Override
    public void fun() {
        System.out.println("我是B");
    }

    @Override
    public void happy() {
        System.out.println("我是C");
    }
}
public class A11 {
    public static void main(String[] args) {
      D d = new D();
      d.print();
      d.fun();
      d.happy();

    }
}

4.两个接口之间若有相同的子类，则可以相互转换（向上转型，向下转型）

interface A{
    public static final String MSG = "blablabla";//全局常量
    public abstract void print();//抽象方法
}
interface B{
    public abstract String fun();
}
class D implements A,B{
    @Override
    public void print() {
        System.out.println(A.MSG);
    }

    @Override
    public String fun() {
        return A.MSG;
    }
}
public class A12 {
    public static void main(String[] args) {
        A a = new D();//向上转型，为父接口实例化对象
        a.print();//调用被覆写后的方法
        B b = (B) a;
        System.out.println(b.fun());
    }
}

5.当子类需要继承一个抽象类的又需要实现一个接口时，先extends一个抽象类，再implements一个接口

abstract class A{
    public abstract void print();
}
interface B{
    void fun();
}
class C extends A implements B{
    public void print(){
        System.out.println("***********");
    }

    @Override
    public void fun() {
        System.out.println("%%%%%%%%%%%");
    }
}
public class A13 {
    public static void main(String[] args) {
        A a = new C();
        B b = (B)a;
        b.fun();
        a.print();

    }
}

6.一个抽象类可以使用implements实现多个接口，但接口不可以继承抽象类

interface A{
    void print();
}
abstract class B implements A{
    public abstract void fun();
}
class C extends B{
    @Override
    public void print() {
        System.out.println("*****");
    }

    @Override
    public void fun() {
        System.out.println("%%%%%%");
    }
}
public class A14 {
    public static void main(String[] args) {
        A a = new C();
        a.print();
        B b = (B)a;
        b.fun();
    }
}

7.一个接口可以使用extends继承多个父接口

interface A{
    void print();
}
interface B{
    void fun();
}
interface C extends A,B{
    void happy();
}
class D implements C{
    @Override
    public void happy() {
    }
    
    @Override
    public void print() {
    }

    @Override
    public void fun() {
    }
}
public class A15 {
    public static void main(String[] args) {
     
    }
}

8.使用static定义的内部接口

interface A{
   public void print();
    static interface B{
        void fun();
    }
}
class C implements A.B{
    public void fun(){
        System.out.println("blablabla");
    }
}
public class A16 {
    public static void main(String[] args){
        new C().fun();
    }
}