拾叁——抽象类与接口
一、抽象类
在 Java 中可以创建一种类专门用来做父类,这种类称为 “ 抽象类 ”。抽象类实际上也是一个类,只是与之前的普通类相比,内部新增了抽象方法。
1.抽象类的基本概念
抽象方法是只声明而未实现的方法,所有的抽象方法必须使用 abstract 关键字声明,包含抽象方法的类也必须使用 abstract class 声明。
抽象类定义规则如下:
(1)抽象类和抽象方法都必须用 abstract 关键字来修饰;
(2)抽象类不能直接实例化,也就是不能直接用 new 关键字去产生对象;
(3)抽象类定义时抽象方法只需声明,而不需实现;
(4)含有抽象方法的类必须被声明为抽象类,抽象类的子类必须实现所有的抽象方法后才能被实例化,否则这个子类还是个抽象类。
抽象类定义格式如下:
abstract class 类名称 //定义抽象类
{
声明数据成员;
访问权限 返回值的数据类型 方法名称(参数……)
{
//定义一般方法
}
//定义抽象方法,在抽象方法里没有定义方法体
abstract 返回值的数据类型 方法名称(参数……);
}
例如:
abstract class Book //定义一个抽象类
{
private String title = "Java"; //属性
public void print()
{
//普通方法,有“{ }”表示有方法体
System.out.println(title);
}
//没有定义方法体,是一个抽象方法
public abstract void fun();
}
由此可知,抽象类的定义就是比普通类多了一些抽象方法的定义而已。虽然定义了抽象类,但是抽象类却不能直接使用。
Book book = new Book(); //错误:Book是抽象的,无法实例化
如果一个类可以实例化对象,那么这个对象可以调用类中的属性或者是方法,但是抽象类中存在抽象方法,而抽象方法没有方法体,没有方法体的方法无法使用。
所以,对于抽象类的使用原则如下:
(1)抽象类必须有子类,子类使用 extends 继承抽象类,一个子类只能够继承一个抽象类;
(2)子类( 如果不是抽象类 )则必须实现抽象类之中的全部抽象方法;
(3)如果要想实例化抽象类的对象,则可以使用子类进行对象的向上转型来完成。
提示:在 Java 中,当子类继承父类时,子类可由此得到父类的方法。我们可在子类中,重新改写继承父类的同名方法,我们称这个过程为覆盖重写,简称覆写( override )。
从抽象类的设计理念可知,抽象类生来就是被继承的。在其内的抽象方法,通常是没有方法体的,抽象方法的本意就是期望子类重新定义这个方法,赋予新的内涵。因此,在其子类中的非抽象( 具体 )定义,我们用 “ 实现 ”,而非 “ 覆盖 ”,来描述这个过程。用 “ 实现 ”,相当于在子类中,将来自父类的抽象方法 “ 给予 ” 生命。
举例抽象类的用法:
//抽象类的用法
abstract class Person //定义一个抽象类 Person
{
String name;
int age;
String occupation;
public abstract String talk(); //声明一个抽象方法talk()
}
class Student extends Person //Student类继承自Person类
{
public Student(String name,int age,String occupation)
{
this.name = name;
this.age = age;
this.occupation = occupation;
}
public String talk() //实现抽象方法talk()
{
return "name:" + this.name + "age:" + this.age + "occupation" + this.occupation;
}
}
class Worker extends Person //Worker类继承自Person类
{
public Worker(String name,int age,String occupation)
{
this.name = name;
this.age = age;
this.occupation = occupation;
}
public String talk() //实现抽象方法talk()
{
return "name:" + this.name + "age:" + this.age + "occupation" + this.occupation;
}
}
class AbstractClassDemo
{
public static void main(String[] args)
{
Student s = new Student("张三",20,"学生"); //创建Student类对象s
Worker w = new Worker("李四",25,"工人"); //创建Worker类对象w
System.out.println(s.talk()); //调用被实现过的方法
System.out.println(w.talk());
}
}
举例抽象类中构造方法的定义使用:
//抽象类中构造方法的定义使用
abstract class Person //定义一个抽象类 Person
{
String name;
int age;
String occupation;
public Person(String name,int age,String occupation) //定义构造函数
{
this.name = name;
this.age = age;
this.occupation = occupation;
}
public abstract String talk(); //声明一个抽象方法
}
class Worker extends Person //声明抽象类的子类
{
public Worker(String name,int age,String occupation)
{
//在这里必须明确调用抽象类中的构造方法
super(name,age,occupation);
}
public String talk() //实现抽象方法talk()
{
return "name:" + this.name + "age:" + this.age + "occupation" + this.occupation;
}
}
class AbstractConstructor
{
public static void main(String[] args)
{
Worker w = new Worker("李四",25,"工人"); //创建对象w
System.out.println(w.talk()); //调用被实现过的方法
}
}
举例验证 static 定义的内部抽象类:
//验证static定义的内部抽象类
abstract class Book
{
public abstract void print(); //抽象方法
static abstract class CD
{
//静态内部抽象类
public abstract void get(); //抽象方法
}
}
class JavaCD extends Book.CD //继承抽象类
{
public void get()
{
System.out.println("java");
}
}
public class StaticInnerAbstractClass
{
public static void main(String[] args)
{
Book.CD cd = new JavaCD(); //实例化对象
cd.get();
}
}
抽象类的特征:
(1)抽象类中可以有构造方法
与一般类相同,抽象类也可以拥有构造方法,但是这些构造方法必须在子类中被调用,并且子类实例化对象的时候依然满足类继承的关系,先默认调用父类的构造方法,而后再调用子类的构造方法,毕竟抽象类之中还是存在属性的,但抽象类的构造方法无法被外部类实例化对象调用。
抽象类也可以像普通类一样,有构造方法、一般方法和属性,更重要的是还可以有一些抽象方法,需要子类去实现,而且在抽象类中声明构造方法后,在子类中必须明确调用。
(2)抽象类不能够使用 final 定义
因为使用 final 定义的类不能有子类,而抽象类使用的时候必须有子类,这是一个矛盾的问题,所以抽象类上不能出现 final 定义。
(3)Static 声明,抽象类内外不同
在外部抽象类上无法使用 static 声明,但是内部抽象类却可以使用 static 定义,使用 static 定义的内部抽象类就表示一个外部类。