从零开始学java--抽象类、接口、枚举类-优快云博客

// 抽象类：被abstract修饰的类
public abstract class Person {
    // 抽象类也是类，也可以增加普通方法和属性
    String name;
    int age;
    String sex;

    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    // 抽象方法：被abstract修饰的方法，没有方法体
    protected abstract void exam();

}

抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

抽象类特性：

抽象类不能直接实例化对象。

抽象方法不能是 private 的。
抽象方法不能被ﬁnal和static修饰，因为抽象方法要被子类重写。
抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰。
抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

接口

接口可以看成是：多个类的公共规范，是一种引用数据类型。

新建<-Java类<-接口

语法规则：

public interface Study {  //使用interface表示这是一个接口
    public abstract void study();  // public abstract 是固定搭配，可以不写
}

接口使用：

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

public class Student extends Person implements Study{ //使用imlements关键字来实现接口
    public Student(String name, int age, String sex) {
        super(name, age, sex);
    }

    public void study(){  //实现接口时，同样需要将接口中的所有抽象方法全部实现
        System.out.println("我爱学习");
    }
    
}

接口特性：

1、接口类型是一种引用类型，但是不能直接new接口的对象

    public static void main(String[] args) {
        Study student=new Student("小明",18,"男");
        student.study();
    }
//只能使用Study中定义的方法，以及Object类中的方法

接口同样支持向下转型。

2、接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

3、接口中的方法是不能在接口中实现的，只能由实现接口的类来实现：

因为接口抽象方法不能带有主体。

4、重写接口中方法时，不能使用默认的访问权限

5、接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static ﬁnal 变量

可以存在静态变量和静态方法：

public interface Study {  
    void study();  

    static void test(){
        System.out.println("我是静态方法");
    }
}


//通过接口名.的方式使用静态内容：
Study.test();

6、接口中不能有静态代码块和构造方法

7、接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8、如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

9、从Java8开始，接口中可以存在方法的默认实现。

public interface Study {  
    public abstract void study();  
    
    default void test(){  //使用default关键字为接口中的方法添加默认实现
        System.out.println("我是默认实现");
    }
}

如果方法在接口中存在默认实现，那么现实类中不强制要求进行实现，也可进行重写：

    @Override
    public void test() {
        Study.super.test();//使用Study原本的默认实现
    }

实现多个接口：

接口不同于继承，接口可以同时实现多个：

public class Student extends Person implements Study,A,B,C{
     //多个接口的实现使用逗号隔开
}

一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

接口间的继承：

接口是可以继承自其他接口的，且没有继承数量限制：

public interface Study extends A,B{
}

接口间的继承相当于把多个接口合并在一起。

若父类和接口中方法相同，则无需再实现。

父类和接口中相同默认实现，优先执行父类的实现。

抽象类和接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。

区别	抽象类（abstract）	接口（interface）
结构组成	普通类+抽象方法	抽象方法+全局变量
子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
权限	各种权限	public
关系	一个抽象类可以实现若干个接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口

枚举类

枚举类的使用：

新建<-Java类<-枚举：

public enum Status {
    RUNNING,STUDY,SLEEP;  //后面没有其他内容可以不加分号
}

定义的每一个状态其实就是一个public static final的Status类型成员变量。

Student中类型变成刚刚定义的枚举类：

public class Student{
    private Status status;

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }
}

在Main中使用时：

我们也可以给枚举类型添加独有的成员方法：

public enum Status {
    RUNNING("跑步"),STUDY("学习"),SLEEP("睡觉");

    private final String name;
    Status(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }
}

这样，枚举就可以按照我们想要的中文名称打印：

    public static void main(String[] args) {
        Student student=new Student();
        student.setStatus(Status.RUNNING);
        System.out.println(student.getStatus().getName());//输出：跑步
        System.out.println(student.getStatus().name());//输出：RUNNING
    }

...终于学完面向对象基础篇了o(╥﹏╥)o