抽象类与接口

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