黑马程序员全套Java教程_Java基础教程_抽象类与接口(二十)
1、抽象类
1.1 抽象类概述
- 在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
1.2 抽象类的特点
- (1)抽象类和抽象方法必须使用abstract关键字修饰,如:
public abstract class 类名{}
public abstract void eat();
(2)抽象类中不一定有抽象方法,但有抽象方法的类一定是抽象类。
(3)实例化的方式:参照多态的方式,通过子类对象实例化,这叫抽象类多态。
(4)抽象类子类的特点:要么重写抽象类中的所有抽象方法,要么本身同为抽象类。
1.3 抽象类的成员特点
- (1)成员变量:可以是变量,也可以是常量
(2)构造方法:有构造方法,但是不能实例化。构造方法用于子类访问父类时数据的初始化。
(3)成员方法
可以有抽象方法:限定子类必须完成某些动作。
也可以有非抽象方法:提高代码复用性。
面试题:以下关于抽象的类描述正确的是?
(1)抽象类可以通过new关键字直接实例化。
错误。抽象类不能直接通过new实例化,抽象类实例化要按照多态的方式,通过子类对象实例化,这叫抽象类多态。虽然抽象类有构造方法,但构造方法起到的作用是用于子类访问父类时数据的初始化。
(2)有抽象方法的类一定是抽象类。
正确。“子不教,父之过”。
(3)抽象类没有构造方法。
错误。其构造方法的用于子类访问父类数据时的初始化。
(4)抽象类必须提供抽象方法。
错误。有抽象类中不一定有抽象方法。
案例:猫和狗
- 需求:请采用抽象类的思想实现猫和狗的案例,并在测试类中进行测试
- 思路及代码实现:(对比猫和鱼的多态案例,代码有变化的只有父类Animal加了abstract关键字,以及父类的eat方法删除了方法体加了abstract关键字):
(1)定义动物类(Animal)
成员变量:姓名,年龄
构造方法:无参,带参
成员方法:get/set方法,吃饭();
public abstract class Animal {
private String name;
private int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public Animal() {
}
public abstract void eat();
。。。。。。。。。。。。略set/get方法。。。。。。。。。。。。。。
}
(2)定义猫类(Cat),继承动物类
构造方法:无参,带参
成员方法:重写吃放(){…}
public class Cat extends Animal{
public Cat(String name, int age) {
super(name, age);
}
public Cat() {
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
(3)定义狗类(Dog),继承动物类
构造方法:无参,带参
成员方法:重写吃放(){…}
public abstract class Dog extends Animal{
public Dog(String name, int age) {
super(name, age);
}
public Dog() {
}
@Override
public void eat(){
System.out.println("狗吃骨头");
}
}
(4)定义测试类(AnimalDemo),写代码测试
public class AnimalDemo {
public static void main(String[] args) {
Animal a = new Cat();
a.setName("Jerry");
a.setAge(1);
a.eat();
Animal b = new Cat("CatKing",2);
b.eat();
}
}
2、接口
2.1 接口概述
- 接口就是一种公共的规范标准,只要符合规范标准,大家都可以使用
Java中的接口更多的体现在对行为的抽象
2.2 接口的特点
- (1)接口定义的方式:用关键字interface修饰,如:public interface 接口名{}
(2)类实现接口的方式:用implements关键字表示实现,如:public class 类名 implements 接口名{}
(3)接口实例化的方式:通过实现类对象实例化,这叫接口多态。
(4)接口的实现类,要么重写类中所有的抽象方法,要么本身同为抽象类。
2.3 基于抽象类和接口,得出的多态的形式和前提总结
- 多态的形式:具体类多态,抽象类多态,接口多态
- 多态的前提:
(1)有继承或者实现关系;
(2)有方法重写;
(3)有父(类/接口)引用指向(子/实现)类对象。
2.4 接口的成员特点
- (1)成员变量:只能是常量,默认修饰符为:public static final,所以接口中的变量也称之为常量。
(2)构造方法:接口没有构造方法,因为接口主要是对行为进行抽象的,没有具体存在。而其实现类可以有构造方法,是因为每个类都有一个共同的父类Object类。
(3)成员方法:只能是抽象方法,默认修饰符:public abstract。
(4)关于接口中的方法,JDK8和JDK9中有一些新的特性,后面再解释
案例:猫和狗
- 需求:对猫和狗进行训练,他们就可以调高了,这里加入了跳高功能。请采用抽象类和接口来实现猫狗案例。
- 思路:
(1)定义接口(Jumpping)
成员方法:跳高();
public interface Jumpping {
public abstract void jumpping();
}
(2)定义抽象动物类(Animal)
成员变量:姓名,年龄;
构造方法:无参,带参;
成员方法:get/set方法,吃饭();
public abstract class Animal {
private String name;
private int age;
public abstract void eat();
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
.............................
(3)定义猫类(Cat),继承动物类,实现跳高接口
构造方法:无参,带参;
成员方法:重写吃饭方法(){…},重写跳高方法(){…}
public class Cat extends Animal implements Jumpping{
@Override
public void jumpping() {
System.out.println("猫跳");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
}
(4)定义狗类(Dog),继承动物类,实现跳高接口
构造方法:无参,带参;
成员方法:重写吃饭方法(){…},重写跳高方法(){…}
public class Dog extends Animal implements Jumpping{
@Override
public void jumpping() {
System.out.println("狗跳");
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
}
(5)定义测试类(AnimalDemo),写代码测试
public class AnimalDemo {
public static void main(String[] args) {
Jumpping j = new Cat();
j.jumpping();
System.out.println("----------");
Animal a = new Cat();
a.setName("Jerry");
a.setAge(3);
a.eat();
System.out.println(a.getName() + "," + a.getAge());
a.eat();
// a.jump不可使用
System.out.println("----------");
a = new Cat("Jerry", 5);
System.out.println(a.getName() + "," + a.getAge());
a.eat();
System.out.println("----------");
Cat c = new Cat("Tom", 5);
System.out.println(a.getName() + "," + a.getAge());
a.eat();
j.jumpping();
}
}
2.5 类和接口的关系
- 类和类的关系:继承关系,只能单继承,不能多继承,但是可以多层继承。
- 类和接口的关系:实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口。
- 接口和接口的关系:继承关系,可以单继承,也可以多继承。
2.6 抽象类和接口的区别
- 成员区别:
(1)抽象类:变量,常量;有构造方法;有抽象方法,也有非抽象方法。
(2)接口:常量;抽象方法。 - 关系区别:
(1)类与类:继承,单继承。
(2)类与接口:实现,可以单实现,也可以多实现。
(3)接口与接口:继承,单继承,多继承。 - 设计理念区别:
(1)抽象类:对事物的抽象,包括属性、行为。
(2)接口:对行为的抽象,主要是行为。
(3)举例:门和警报的例子。每个门都有open()和close()两个动作。这个时候,我们可以分别使用抽象类和接口来定义这个抽象概念。
//抽象类
public abstract class Door{
public abstract void open();
public abstract void close();
}
//接口
public interface Door{
void open();
void close();
}
随着时代的发展,有些门具备了警报的功能,有两种实现方式:
(1)将三种方法都放在抽象类里面,但是这样一来,所有继承抽象类的子类都具备了警报功能,但问题是并不是所有的门都有警报功能。
(2)将三种方法都放在接口里面,需要报警功能的类就实现这个接口中方法,但问题是这个时候要连带实现方法中的open方法和close方法,也许这个类根本就不具备开门关门的功能(比如火灾报警器)。
由此可见两种方式都不好。
//抽象类
public abstract class Door{
public abstract void open();
public abstract void close();
public abstract void alarm();
}
//接口
public interface Door{
void open();
void close();
void alarm();
}
怎么解决呢?我们知道,open和close是门必须附带的功能, 而alarm是属于附加的行为,所以最简单的方法就是将alarm单独设计为一个接口,而将open和close放到一个抽象类里面,将来我们的报警门继承抽象类的门并且实现报警接口就可以了,如下:
public interface Alarm{
void alarm();
}
public abstract class Door{
public abstract void open();
public abstract void close();
}
public class AlarmDoor extends Door implements Alarm{
public void open(){
.......
}
public void close(){
.......
}
public void alarm(){
.......
}
}
面试题:以下对接口描述错误的有?
- 接口没有提供构造方法。
正确。接口没有构造方法,因为接口主要是对行为进行抽象的,没有具体存在。 - 接口中的属性默认使用public static final修饰。
正确。接口的成员变量默认修饰符为public static final;成员方法只能是抽象方法,默认修饰符为public abstract。 - 接口不允许多继承。
错误。接口和接口之间是可以多继承的。 - 接口中的方法默认使用public abstract修饰。
正确。
案例:运动员和教练
- 需求:我们现在有乒乓球和篮球运动员,乒乓球和篮球教练。为了出国交流,跟乒乓球相关的人员都需要学习英语。请用所学知识分析,这个案例中有哪些具体类,哪些抽象类,哪些接口,并用代码实现。
- 此类问题的分析方法:从具体到抽象,因为我们最终要提取出共性的内容。
在本题中,具体的事物有:乒乓球运动员、篮球运动员、乒乓球教练、篮球教练,他们都是具体的类。
运动员和教练这两个整体是有自己的共性的,所以我们提取出运动员和教练两个抽象类,他们分别有学习()和教()这两个抽象方法。教练和运动员也是有共性的,提取出人这一个类,他有吃饭这一抽象方法。
另外跟乒乓球相关的人员都需要学习英语,所以我们定义一个学习英语的接口,让乒乓球相关的具体类去实现这个接口即可。
- 此类问题的实现:从抽象到具体;使用:使用的是具体类的对象
实现思路:
(1)定义说英语接口
成员方法:说英语()。
public interface SpeakEnglish {
void speakEnglish();
}
(2)定义抽象人类
成员变量:姓名,年龄;
构造方法:无参,带参;
成员方法:get/set方法,吃饭()。
public abstract class Person {
private String name;
private int age;
public abstract void eat();
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
.............................................
(3)定义抽象教练类,继承人类
构造方法:无参,带参;
成员方法:教()。
public abstract class Coach extends Person{
public Coach() {
}
public Coach(String name, int age) {
super(name, age);
}
public abstract void teach();
}
(4)定义抽象运动员类,继承人类
构造方法:无参,带参;
成员方法:学习()。
public abstract class Athletes extends Person {
public abstract void study();
public Athletes() {
}
public Athletes(String name, int age) {
super(name, age);
}
}
(5)定义具体篮球教练类,继承教练类
构造方法:无参,带参;
成员方法:重写吃饭(){…},重写教(){…}。
public class BasketballCoach extends Coach{
@Override
public void eat() {
System.out.println("篮球教练吃大篮球");
}
public BasketballCoach() {
}
public BasketballCoach(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("教练开始教篮球");
}
}
(6)定义具体乒乓球教练类,继承教练类,实现说英语接口
构造方法:无参,带参;
成员方法:重写吃饭(){…},重写教(){…},重写说英语(){…}。
public class PingpongCoach extends Coach implements SpeakEnglish {
@Override
public void eat() {
System.out.println("乒乓球教练吃大乒乓球");
}
public PingpongCoach() {
}
public PingpongCoach(String name, int age) {
super(name, age);
}
@Override
public void speakEnglish() {
System.out.println("乒乓球教练说英语");
}
@Override
public void teach() {
System.out.println("乒乓球教练开始教乒乓球");
}
}
(7)定义具体篮球运动员类,继承运动员类
构造方法:无参,带参;
成员方法:重写吃饭(){…},重写教(){…}。
public class BasketballPlayer extends Athletes{
@Override
public void eat() {
System.out.println("篮球运动员吃小篮球");
}
public BasketballPlayer() {
}
public BasketballPlayer(String name, int age) {
super(name, age);
}
@Override
public void study() {
System.out.println("运动员打篮球");
}
}
(8)定义具体乒乓球教练类,继承教练类,实现说英语接口
构造方法:无参,带参;
成员方法:重写吃饭(){…},重写教(){…},重写说英语(){…}。
public class PingpongPlayer extends Athletes implements SpeakEnglish {
@Override
public void eat() {
System.out.println("乒乓球运动员吃小乒乓球");
}
public PingpongPlayer() {
}
public PingpongPlayer(String name, int age) {
super(name, age);
}
@Override
public void study() {
System.out.println("运动员打乒乓球");
}
@Override
public void speakEnglish() {
System.out.println("乒乓球运动员说英语");
}
}
(9)定义测试类,写代码测试
public class PersonDemoTest {
public static void main(String[] args) {
PingpongCoach pc = new PingpongCoach("pc",22);
pc.eat();
pc.speakEnglish();
pc.teach();
PingpongPlayer pp =new PingpongPlayer("pp",11);
pp.eat();
pp.speakEnglish();
pp.study();
BasketballCoach bc = new BasketballCoach("bb",23);
bc.eat();
bc.teach();
BasketballPlayer bp = new BasketballPlayer("bp",13);
bp.eat();
bp.study();
}
}
3、面向对象中的形参和返回值
1.1 类名作为形参和返回值
- (1)方法的形参是类名,其实需要的是该类的对象
(2)方法的返回值是类名,其实返回的是该类的对象
1.2 抽象类名作为形参和返回值
- (1)方法的形参是抽象类名,其实需要的是该抽象类的子类对象。
(2)方法的返回值是抽象类名,其实返回的是该抽象类的子类对象。
1.3 接口名作为形参和返回值
- (1)方法的参数是接口名,其实需要的是该接口的实现类对象。
(2)方法的返回值是接口名,其实返回的应该是接口的实现类对象。