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();

     }

 }

Abstract class

二. 接口

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());
    }

}

Interface example

多态性：

方法的重载和重写

对象的多态性

向上转型：程序自动完成

向下转折：强制类型转换