抽象类和接口

1、抽象类

//用abstract 修饰的类叫抽象类
// 抽象类不能实例化
//抽象类中可以有和普通类一样的成员 就是不能被实例化
//抽象方法不能被private和final修饰（他们要被重写）
abstract class Shape{

    public abstract void draw();//抽象方法没有具体的实现

}
//普通类要继承抽象类的得把抽象类中抽象方法重写
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("○");
    }
}
public class TestDemo {
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {

        drawMap(new Cycle());

    }
}

2、接口

// 接口是被interface修饰 接口中不能有具体的方法
//可以有默认的方法  是被default修饰
//接口当中的方法都默认是public abstract 修饰的
//接口中的成员变量都是 public static final 修饰
//接口不能被实例化
//类 可以继承一个类，也可以同时实现多个接口
//接口的出现是为了满足JAVA中多继承的要求
//接口中可以有静态方法
interface IShape{
    public int a = 10;
    public String b = "abcd";
    public abstract void draw();

    int a1 = 20;
    String b1 = "hello";
    void draw1();
    /*default public void func(){
        System.out.println("只是一个默认方法！");
    }*/

}
//一个类可以实现接口  被implements 修饰实现
class Cycle implements IShape{
    @Override
    public void draw() {
        System.out.println("○");
    }

    @Override
    public void draw1() {
        System.out.println("<(￣3￣)>");
    }
}
public class Test {
    public static void drawMap(IShape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        IShape iShape = new Cycle();//接口也可以发生向上转型
        drawMap(new Cycle());
    }
}

例如

interface IA {//接口
    void func();
}
interface ID{//接口
    void funcD();
}
interface IE{//接口
    void funcE();
}
//抽象类B实现接口
abstract class B implements IA{

    public abstract void func2();

}
//普通类C继承抽象类B 实现接口ID,IE
class C extends B implements ID,IE{
    @Override
    public void func() {

    }

    @Override
    public void func2() {

    }

    @Override
    public void funcD() {

    }

    @Override
    public void funcE() {

    }