抽象类、抽象方法以及接口

分手后的思念是犯贱 2022-05-12 07:22 233阅读 0赞

抽象方法声明语法：  
**abstract void f();**  
包含抽象方法的类叫做抽象类，如果一个类包含一个或多个抽象方法，该类必须被限定为**抽象类**，负责编译器就会报错。且抽象类**不允许被创建对象**。  
如果一个类继承自一个抽象类，如果想创建此类的对象，**就必须为父类（基类）中的抽象方法提供方法定义**，否则此类只能被**abstract**修饰成为抽象类。  
下面看一段代码

abstract class Animal{      //以abstract关键字修饰的抽象类中可以含有普通方法
        abstract void voice();
        abstract void run();    //抽象方法必须定义在抽象类中
        public void eat() {
            System.out.println("eating...");
        }
    }
    class Bird extends Animal{
        @Override
        void voice() {          //抽象方法在子类中必须进行重写
            System.out.println("zhazhazha...");
    
        }
        @Override
        void run() {
            System.out.println("flying...");
    
        }
    }
    public class Testabstract { 
        public static void main(String[] args) {
            Animal a = new Bird();
            a.voice();
            a.run();
            a.eat();
        }
    }
    /** * output: * zhazhazha... * flying... * eating... */

总结一下抽象类和抽象对象的几个要点：

*  有抽象方法的类只能定义抽象类
 *  抽象类不能实例化，即不能用new来实例化抽象类
 *  抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实力，只能被子类调用
 *  抽象类只能用来继承
 *  抽象方法必须被子类实现

接口：interface关键字使抽象的概念更向前迈了一步。这个关键字产生一个完全抽象的类，他不提供任何具体的实现，，允许创建者确定方法名、参数列表和返回类型，但是没有方法提。换句话说，接口只提供了形式，不提供任何具体实现。  
再来看一段代码:

public interface Testjiekou {        //所有接口都是由public所修饰
        public static int MAX_VALUE = 100;
        abstract void run();
        abstract void eat();
        abstract int num(int a,int b);
    
    }
    class Pig implements Testjiekou{    //实现接口时必须重写所有抽象方法
    
        @Override
        public void run() {
            System.out.println("running..");
    
        }
    
        @Override
        public void eat() {
            System.out.println("eating...");
    
        }
    
        @Override
        public int num(int a, int b) {
            System.out.println(a+b);
            return a+b;
        }   
    }
    public class Test01 { 
        public static void main(String[] args) {
            Testjiekou pig = new Pig();
            pig.run();
            pig.eat();
            pig.num(10,20);
        }
    }
    /** * output: * running.. * eating... * 30 */

接口可以实现多继承，我们用一段代码来看这一过程

interface Printtest1 { 
        abstract void test1();
    }
    
    interface Printtest2{ 
        abstract void test2();
    }
    
    interface Printtest3 extends Printtest1,Printtest2{ 
        abstract void test3();
    }
    class Test implements Printtest3{ 
    
        @Override
        public void test1() {
            System.out.println("test1()");
    
        }
    
        @Override
        public void test2() {
            System.out.println("test2()");
    
        }
    
        @Override
        public void test3() {
            System.out.println("test3()");
    
        }
    
    }
    public class Printtest{ 
        public static void main(String[] args) {
            Test t = new Test();
            t.test1();
            t.test2();
            t.test3();
        }
    }
    /** * output: * test1() * test2() * test3() */

可以看见，在Printtest3中继承了前面两个接口，所以当类Test实现Printtest3接口是需要重写三个接口的所有方法。