Java Abstract Class & Interface

一. 抽象类

1. 抽象类：包含了一个抽象方法的类就是抽象类

2. 抽象方法：声明而未被实现的方法，用关键字abstract声明

3. 抽象类被子类继承，子类（如果不是抽象类）必须重写（override）抽象类中的所有抽象方法

4. 定义格式:

abstract class className{
　　属性
　　方法
　　抽象方法
}

5. 抽象类不能被直接实例化，要通过其子类进行实例化

抽象类的应用

package com.bruceyo.absdemo;

//抽象类的应用
abstract class Person{
    private int age;
    private String name;
    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }
    public void tell(){
        
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void want();
    
}
class Student extends Person{
    private int score;
    
    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public Student(int age, String name, int score) {
        super(age, name);
        this.score = score;
        // TODO Auto-generated constructor stub
    }

    @Override
    public void want(){
        System.out.println("Name:"+getName()+", Age:"+getAge()+", Score:"+getScore());
    }
    
}
class Worker extends Person{
    private int money;
    

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public Worker(int age, String name, int money) {
        super(age, name);
        this.money = money;
        // TODO Auto-generated constructor stub
    }

    @Override
    public void want(){
        System.out.println("Name:"+getName()+", Age:"+getAge()+", money:"+getMoney());
    }
    
}

public class AbsDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student student = new Student(55,"Bruce",4);
        student.want();
        Worker worker = new Worker(66, "Json", 6666);
        worker.want();
        
    }

}

二. 接口

1. 接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成

2. 定义格式:

interface interfaceName{
    全局常量 //e.g. public static final int AGE = 100;
    抽象方法 //e.g. public abstract void tell();     
}

3. 接口实现必须通过子类，使用关键字implements, 而且接口是可以多实现的

4. 一个类可以同时继承抽象类和实现接口

5. 一个接口不能继承一个抽象类，但是可以通过extends关键字同时继承多个接口，实现接口多继承

接口的应用

package com.bruceyo.absdemo;

interface USB{   //制定一个标准，每一个USB必须按照这个标准进行工作
    void start();//可省略public abstract
    void stop();
}
class C{                    //接口的实例
    public static void work(USB u){
        u.start();
        System.out.println("Working");
        u.stop();
    }
}

class USBDisk implements USB{
    public void start(){
        System.out.println("USBDisk start Working");
    }
    public void stop(){
        System.out.println("USBDisk stop Working");
    }
}
class Printer implements USB{
    public void start(){
        System.out.println("Printer start Working");
    }
    public void stop(){
        System.out.println("Printer stop Working");
    }
}
public class InterfaceDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        C.work(new USBDisk());
        C.work(new Printer());
    }

}

多态性：

      方法的重载和重写

      对象的多态性

            向上转型：程序自动完成

            向下转折：强制类型转换