Braincao's Blog

抽象类介绍

包含一个或多个抽象方法的类本身必须声明为抽象的；抽象类也可以包含具体数据和具体方法

abstract class Person //抽象类
{
    private String name; //具体数据

    public Person(String n) //构造器
    {
        name = n;
    }

    public abstract String getDescription(); //抽象方法

    public String getName() //具体方法
     {
        return name;
    }
}

抽象类的抽象方法具体在子类中实现，在接口中可以看到更多的抽象方法

抽象类不能被实例化。可以定义一个抽象类的对象变量，但是只能引用非抽象子类的对象，如下：

Person p = new Student("Brain", "Economics");

抽象类助理解示例程序：

package test;

import java.util.*;

public class Test
{
    public static void main(String args[])
    {
        Person[] people = new Person[2];
        people[0] = new Employee("Bob", 10000, 2017, 6, 28);
        people[1] = new Student("brain", "Economics");

        for(Person p: people)
        {
            System.out.println(p.getName() + ", " + p.getDescription());
        }
    }
}

abstract class Person
{
    private String name;

    public Person(String n)
    {
        name = n;
    }

    public abstract String getDescription();

    public String getName()
    {
        return name;
    }
}

class Student extends Person
{
    private String major;

    public Student(String n, String m)
    {
        super(n);
        major = m;
    }

    public String getDescription()
    {
        return "a student majoring in" + major;
    }
}

class Employee extends Person
{
    private double salary;
    private Date hireDay;

    public Employee(String n, double s, int year, int month, int day)
    {
        super(n);
        GregorianCalendar cal = new GregorianCalendar(year, month-1, day);
        hireDay = cal.getTime();
    }

    public String getDescription()
    {
        return String.format("an employee with a salary of $%.2f", salary);
    }

    public void raiseSalary(double percent)
    {
        salary *= (1 + percent/100);
    }
}

output:

Bob, an employee with a salary of $0.00
brain, a student majoring inEconomics

一、抽象类–用extends继承实现（单继承）

package test;  

import java.util.*;  

abstract class Person  
{  
    private String name;  

    public Person(String n)  
    {  
        name = n;  
    }  

    public abstract String getDescription();  

    public String getName()  //抽象类也可以包含具体数据和具体方法
    {  
        return name;  
    }  
}  

class Student extends Person  
{  
    private String major;  

    public Student(String n, String m)  
    {  
        super(n);  
        major = m;  
    }  

    public String getDescription()  
    {  
        return "a student majoring in" + major;  
    }  
}  

class Employee extends Person  
{  
    private double salary;  
    private Date hireDay;  

    public Employee(String n, double s, int year, int month, int day)  
    {  
        super(n);  
        GregorianCalendar cal = new GregorianCalendar(year, month-1, day);  
        hireDay = cal.getTime();  
    }  

    public String getDescription()  
    {  
        return String.format("an employee with a salary of $%.2f", salary);  
    }  

    public void raiseSalary(double percent)  
    {  
        salary *= (1 + percent/100);  
    }  
}  

public class Test  
{  
    public static void main(String args[])  
    {  
        Person[] people = new Person[2];  
        people[0] = new Employee("Bob", 10000, 2017, 6, 28);  
        people[1] = new Student("brain", "Economics");  

        for(Person p: people)  
        {  
            System.out.println(p.getName() + ", " + p.getDescription());  
        }  
    }  
} 

二、接口–用implements实现（多接口）

interface ainterface //定义一个接口 
{
    int i = 10;    //定义的变量为fianal类型
    void method(); //声明接口方法，但不能有方法体{}
}

public class Test implements ainterface //实现接口
{
    public void method() //接口的方法在此必须被重写，注意访问修饰符为public
    {
        System.out.println("interface succeeds!");
    }
    public static void main(String args[])
    {
        Test a = new Test();
        //a.i = 20; error! 不能修改ｉ的值，为final类型
        a.method();    //output：interface succeeds!
    }
}

三、抽象类与接口混合编程例子

interface aInterface // 定义一个接口
{
    void inter_method(); //这里不需要访问修饰符，在实现中指定
}

abstract class aAbstractClass// 定义一个抽象类
{
    public abstract void inter_method(); // 加abstract
}

class Mix extends aAbstractClass implements aInterface // 继承抽象类，实现接口。
{
    public String st; // 定义自己的字段

    public void inter_method() // 实现接口，注意访问修饰符加public
    {
        System.out.println("接口方法已加public实现");
    }

    public void aAbstractClass()// 实现抽象方法
    {
        System.out.println("抽象类方法已实现");
    }
}

public class Test
{
    public static void main(String[] args) {
        Mix mixObj = new Mix();
        mixObj.st = "实现类的字段";
        System.out.println(mixObj.st);
        mixObj.inter_method();// 实现的接口方法调用
        mixObj.aAbstractClass();// 实现的抽象类的方法调用
    }
}

四、接口继承接口

interface Moveable
{
    void move(double x, double y);
}

interface Powered extends Moveable
{
    double SPEED_LIMIT = 95;
    double milesPerGallon();
}

五、几点比较

1、 抽象类在java语言中所表示的是一种“is-a”的继承关系，一个子类只能存在一个父类，但是可以存在多个接口。

2、 在抽象类中可以拥有自己的成员变量和非抽象类方法，但是接口中只能存在静态的不可变的成员数据（不过一般都不在接口中定义成员数据），而且它的所有方法都是抽象的。

3、接口中的所有方法自动地属于public。因此，在接口中声明方法时，不必提供关键字public

4、接口中可以定义常量，但是绝不能含有实例域，也不能在接口中实现方
法。因此，可以将接口看成是没有实例域没有实现方法的抽象类，但这两个概念不要混淆

---

欢迎转载，欢迎错误指正与技术交流，欢迎交友谈心