抽象类和接口

抽象类和接口

Java抽象类

类里面可以写的，在抽象类里也能写，而且抽象类里还可以写抽象方法；

抽象类特有的抽象方法；

抽象方法只有方法名，没有方法体，但是可以加形参；比如：

静态抽象方法是不存在在，即abstract和static不能同时出现；

 

//Java抽象类

//抽象类和抽象方法都用abstract修饰，抽象方法只有方法名，没有方法体；

public abstract class AbstractClass {

    // 定义一个成员变量

    public String AbstractVariable = "抽象类的修饰符有：public、private、protected";

    {

        System.out.println("抽象类中的初始化块");

    }

    public AbstractClass() {

        System.out.println("抽象类的无参构造器");

    }

    public AbstractClass(int num) {

        System.out.println("抽象类的参数为num的构造器");

    }

    public void say() {

        System.out.println("抽象类中的普通方法");

    }

    // 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类

    // 定义抽象方法，抽象方法没有方法体

    public abstract void fly();

    public abstract void eat();

    public abstract void height();

    public static void main(String[] args) {

        ExtendAbst ext = new ExtendAbst();

        ext.fly();

        ext.eat();

        System.out.println("1000000000");

        ext.say();

        // ExtAbst exa=new ExtAbst(); //抽象类不能实例化对象

//所有的抽象类必须被继承才能被使用

    }

}

class ExtendAbst extends AbstractClass {// 定义一个类继承抽象类

    @Override

    public void fly() {// 对抽象类方法fly的实现

        // TODO Auto-generated method stub

        System.out.println("我会飞哦！");

    }

    @Override

    public void eat() {// 对抽象类方法eat()的实现

        // TODO Auto-generated method stub

        System.out.println("我能吃鱼哦！");

    }

    @Override

    public void height() {

        // TODO Auto-generated method stub

    }

    public void say() {// 对父类方法进行重写

        System.out.println("我是父类的say()方法重写后的");

    }

    public void say(int age) {// 对父类方法进行重载

        System.out.println("我是父类方法的say()方法的重载");

    }//子类可以重载父类的方法

    public ExtendAbst() {

        // TODO Auto-generated constructor stub

    }

}

// 类可以不实现抽象类声明的所有方法，但是这个类必须被声明为抽象的。

abstract class ExtAbst extends AbstractClass {// 定义一个抽象类继承抽象类

    public void sayHello() {

        System.out.println("sayHello!");

    }

}

结果展示图：

接口

接口可以继承多个接口，但是接口只能继承接口，不能继承类；

接口不能被实例化，但是可以被实现；

一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类；

无法实例化接口，但是可以实例化接口的类；

接口的格式：

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

{

    //零到多个静态常量定义...

    //零到多个抽象方法定义....

}

 

在InterfaceDemo接口中：

//接口

//接口的修饰符有：public、abstract

public interface InterfaceDemo {

    int NUM_ONE = 1;

    // 在定义成员变量的时候可以不写public static final，

    // 编译时系统会自动默认在成员变量前增加public static final修饰符；

    public static final int NUM_TWO = 1;

    // 定义一个抽象方法；

    public abstract void doubleHoleSocket();// 双孔插座

    void socket();// 插座

    // 编译时系统自动为接口里定义的方法添加public abstract修饰符；

}

//在InterfaceDemoOne接口中：

public interface InterfaceDemoOne {

    //定义一个抽象方法

    public abstract void threeholeSocket();//三孔插座

}

 

接口的实现：

类使用implements关键字来实现接口，在类声明中，implements关键字就放在class声明后面；

实现的格式：

[修饰符] class 类名 implements 接口1[, 接口2, 接口3..., ...]

{……}

实例化实现类的格式：

//接口的实现

//接口允许多继承；

public class InterfaceImplements implements InterfaceDemo, InterfaceDemoOne {

    // 接口的实现继承了接口1和接口2，具有双孔插座和三孔插座

    @Override

    public void doubleHoleSocket() {

        // TODO Auto-generated method stub

        System.out.println("双孔插座");

    }

    @Override

    public void socket() {

        // TODO Auto-generated method stub

        System.out.println("插座");

    }

    @Override

    public void threeholeSocket() {

        // TODO Auto-generated method stub

        System.out.println("三孔插座");

    }

    public static void main(String[] args) {

        InterfaceImplements intimp = new InterfaceImplements();

        intimp.doubleHoleSocket();

        intimp.socket();

        intimp.threeholeSocket();

    }

}

效果展示：