【Java基础】抽象类与接口

抽象类

定义

包含抽象方法的类就是抽象类。

• 抽象方法：abstract修饰，只包含一个方法名，没有方法体的方法。
• 抽象类：包含抽象方法的类。

注意事项

1. 不能直接创建抽象对象。

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

3. 可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

4. 抽象类的子类，必须重写抽象父类中的抽象方法，否则是抽象类

5. 抽象方法可以是public、protected、缺省值权限。

代码例子

public abstract class Animal {

     public Animal() {
            System.out.println("Animal构造方法。。。");
      }
      public abstract  void eat();
}

public class Cat extends Animal {
    public Cat() {
        System.out.println("cat构造方法。。。");
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼。。。");
    }

}

public class Dog extends Animal {
    public Dog() {
        System.out.println("dog构造方法。。。");
    }
    @Override
    public void eat() {
        System.out.println("狗啃骨头。。。");
    }
}

public class Demo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        Dog dog = new Dog();
        dog.eat();
    }
}

可以看出父类构造方法是在子类构造方法之前。

接口

接口概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么
接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

public interface Shape {

    public abstract void area();
    public abstract void zouChang();

}

public class Sanjiao implements  Shape {
    @Override
    public void area() {
        System.out.println("三角形的面积");
    }
    @Override
    public void zouChang() {
        System.out.println("三角形的周长");
    }
}

public static void main(String[] args) {
    Shape sjx = new Sanjiao();
    sjx.area();
    sjx.zouChang();
}

• 接口中的方法必须是public abstract的，可以不写，默认会有。
• 没有构造方法。

含有默认方法和静态方法（jdk8）

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。

public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句   
    }
}

• 默认方法必须通过子类对象来调用，可以重写。

接口：

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

实现类：

public class Animal implements LiveAble {
// 继承，什么都不用写，直接调用    
}

测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象 
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}

• 静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。

接口：

public interface LiveAble {
    public static void run(){
        System.out.println("跑起来~~~");
    }
}

实现类：

public class Animal implements LiveAble {
// 无法重写静态方法    
}

测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // Animal.run(); // 【错误】无法继承方法,也无法调用
        LiveAble.run(); //
    }
}
输出结果：
跑起来~~~

私有方法的使用(jdk9)

私有方法：只有默认方法可以调用。
私有静态方法：默认方法和静态方法可以调用。

public interface LiveAble {
    default void func(){
        func1();
        func2();
    }
    private void func1(){
        System.out.println("跑起来~~~");
    }
    private void func2(){
        System.out.println("跑起来~~~");
    }
}

• 一个类可以实现多个接口

其他特点

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用 public static final修饰(必须赋初值，没有默认值)。

• 接口中，没有构造方法，不能创建对象。

• 接口中，没有静态代码块。