11.抽象类和接口
抽象类
抽象类概述
java中,一个没有方法体的方法应该定义为抽象方法, 二类中如果有抽象方法, 该类必须定义为抽象类.
特点:
- 抽象类和抽象方法必须使用abstract关键字修饰
- public abstract class 类名{}
- public abstract void eat();
- 抽象类中不一定有抽象方法, 有抽象方法的类一定是抽象类
- 抽象类不能直接实例化, 可以参照多态的方式, 通过子类对象实例化, 这叫抽象类多态
- 抽象类的子类: 要么重写抽象类的所有抽象方法, 要么是抽象类
Animal
package abstractClass.abstractDemo;
// 定义抽象类
public abstract class Animal {
// 定义抽象方法
public abstract void eat();
public void sleep() {
System.out.println("睡觉");
}
// 有抽象方法,一定是抽象类, 但是抽象类中不一定有抽象方法
}
Cat
package abstractClass.abstractDemo;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
Dog
package abstractClass.abstractDemo;
public abstract class Dog extends Animal {
}
Demo
package abstractClass.abstractDemo;
public class Demo {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
a.sleep();
}
}
抽象类成员特点
成员变量:
- 可以是变量
- 可以是常量
构造方法:
- 有构造方法, 但不能实例化
- 用于子类访问父类数据的初始化
成员方法:
- 可以有抽象方法: 限定子类必须完成某些动作
- 也可以有非抽象方法: 提高代码复用性
Animal
package abstractClass.member;
public abstract class Animal {
private int age = 20;
private final String city = "北京";
public Animal() {}
public void show() {
age = 40;
System.out.println(age);
System.out.println(city);
}
public abstract void eat();
}
Cat
package abstractClass.member;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
Demo
package abstractClass.member;
public class Demo {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
a.show();
}
}
接口
概述
接口是一种公共的规范, 只要符合规范标准,大家都可以通用
java的接口更多的体现在对行为的抽象.
接口特点
接口用关键字interface修饰
- public interface 接口名 {}
类实现接口用implements表示
- public class 类名 implements 接口名 {}
接口不能直接实例化
- 实例化需要参照多台方式, 通过实现类对象实例化, 称为接口多态
- 多态的形式: 具体类多态, 抽象类多态, 接口多态
- 多态前提: 有继承或者实现关系; 有方法重写; 有父(类/接口)引用指向(子/实现)类对象
接口的实现类:
- 要么重写接口中的所有抽象方法
- 要么是抽象类
Jumpping
package javaInterface.interfaceDemo;
public interface Jumpping {
public abstract void jump();
}
Cat
package javaInterface.interfaceDemo;
public class Cat implements Jumpping { // 接口的继承使用inplements关键字
@Override
public void jump() {
System.out.println("猫跳高");
}
}
Dog
package javaInterface.interfaceDemo;
public abstract class Dog implements Jumpping {
// 抽象类继承接口,可以不重写方法
}
Demo
package javaInterface.interfaceDemo;
public class Demo {
public static void main(String[] args) {
// Jumpping j = new Jumpping(); // 接口是一个抽象类, 不能被实例化
Jumpping j = new Cat(); // 接口实例化采用多态方式
j.jump();
}
}
接口成员的特点
成员变量:
- 只能是常量
- 默认修饰父: public static final
构造方法:
- 接口没有构造方法, 因为接口主要是对行为进行抽象的, 没有具体存在
- 一个类如果没有父类, 默认继承自Object类
成员方法:
- 只能是抽象方法
- 默认修饰符: public abstract
- 关于接口中的方法, JDK8和JDK9有一些新特性
Inter
package javaInterface.member;
public interface Inter {
// 成员变量
public int num = 10;
public final int num2 = 20;
int num3 = 30; // 等价于 public static final int num3 = 30;
// 构造方法
// public Inter(){} // 接口中没有构造方法
// 成员方法
// public void show() {} // 接口中没有非抽象方法
public abstract void method(); // 只能是抽象方法
void show(); // 默认也是抽象方法
}
InterImpl
package javaInterface.member;
// public class InterImpl implements Inter {
// 上述等价于 public class InterImpl extends Object implements Inter,
// 也就是访问父类构造方法的时候, 访问的是object的无参构造方法, 而不是Inter的
public class InterImpl extends Object implements Inter {
public InterImpl() {
super();
}
@Override
public void method() {
System.out.println("method");
}
@Override
public void show() {
System.out.println("show");
}
}
Demo
package javaInterface.member;
public class Demo {
public static void main(String[] args) {
Inter i = new InterImpl();
// i.num = 15; // 接口中的变量默认为final修饰的
System.out.println(i.num);
// i.num2 = 30; // 常量不能赋值
System.out.println(i.num2);
System.out.println(Inter.num2); // 接口中的变量默认是静态的
}
}
猫和狗案例接口板
Jumpping
package javaInterface.catAndDog;
public interface Jumpping {
public abstract void jump();
}
Animal
package javaInterface.catAndDog;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
Cat
package javaInterface.catAndDog;
public class Cat extends Animal implements Jumpping {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void jump() {
System.out.println("猫可以跳高");
}
}
Demo
package javaInterface.catAndDog;
public class Demo {
public static void main(String[] args) {
// 创建对象,调用方法
Jumpping j = new Cat();
j.jump();
System.out.println("--------");
Animal a = new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName() + "," + a.getAge());
a.eat();
// a.jump();
a = new Cat("加菲", 5);
System.out.println(a.getName() + "," + a.getAge());
a.eat();
System.out.println("--------");
Cat c = new Cat();
c.setName("加菲");
c.setAge(5);
System.out.println(c.getName() + "," + c.getAge());
c.eat();
c.jump();
}
}
类和接口的关系
类和类的关系
- 继承关系, 只能单继承, 但是可以多层继承
类和接口的关系
- 实现关系, 可以单实现, 也可以多实现, 还可以在继承一个类的同时实现多个接口
接口和接口的关系
- 继承关系, 可以单继承, 也可以多继承
inter1
package javaInterface.interfaceAndClass;
public interface Inter1 {
}
Inter2
package javaInterface.interfaceAndClass;
public interface Inter2 {
}
Inter3
package javaInterface.interfaceAndClass;
public interface Inter3 extends Inter1, Inter2 {
// 接口和接口可以多继承
}
InterImpl
package javaInterface.interfaceAndClass;
public class InterImpl extends Object implements Inter1, Inter2, Inter3 {
// 类可以实现多个接口
}
抽象类和接口的区别
成员区别
- 抽象类: 变量,常量; 有构造方法; 有抽象方法, 也有非抽象方法
- 常量; 抽象方法
关系区别
- 类与类: 继承, 单继承
- 类与接口: 实现, 单实现, 多实现
- 接口与接口: 继承, 单继承, 多继承
设计理念
- 抽象类: 对类抽象, 包括属性,行为
- 接口: 对行为抽象, 主要是行为
使用案例:门和报警器
Alarm
package javaInterface.doorAndAlarm;
public interface Alarm {
void alarm();
}
Door
package javaInterface.doorAndAlarm;
public abstract class Door {
public abstract void open();
public abstract void close();
}
AlarmDoor
package javaInterface.doorAndAlarm;
public class AlarmDoor extends Door implements Alarm {
@Override
public void open() {
System.out.println("开门");
}
@Override
public void close() {
System.out.println("关门");
}
@Override
public void alarm() {
System.out.println("报警");
}
}
抽象是对事物的抽象, 接口是对行为的抽象.
形参和返回值
抽象类作为形参和返回值
方法的形参是抽象类名, 其实需要的抽象类的子类对象
方法的返回值是抽象类名, 其实返回的是该抽象类的子类对象
Animal
package paramAndReturn.abstractAndReturn;
public abstract class Animal {
public abstract void eat();
}
Cat
package paramAndReturn.abstractAndReturn;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
AnimalOperator
package paramAndReturn.abstractAndReturn;
public class AnimalOperator {
public void useAnimal(Animal a) {
a.eat();
}
public Animal getAnimal() {
Animal a = new Cat();
return a;
}
}
Demo
package paramAndReturn.abstractAndReturn;
public class Demo {
public static void main(String[] args) {
// 创建对象
AnimalOperator ao = new AnimalOperator();
Animal a = new Cat();
ao.useAnimal(a);
Animal a2 = ao.getAnimal();
a2.eat();
}
}
接口作为形参和返回值
方法的形参是接口名, 其实需要的接口的实现类对象
方法的返回值是接口名, 其实返回的是该接口类的实现类对象
Jumpping
package paramAndReturn.interfaceAndReturn;
public interface Jumpping {
void jump();
}
Cat
package paramAndReturn.interfaceAndReturn;
public class Cat implements Jumpping {
@Override
public void jump() {
System.out.println("猫可以跳跃");
}
}
JumppingOperator
package paramAndReturn.interfaceAndReturn;
public class JumppingOperator {
public void useJumpping(Jumpping j) {
j.jump();
}
public Jumpping getJumpping() {
Jumpping j = new Cat();
return j;
}
}
Demo
package paramAndReturn.interfaceAndReturn;
public class Demo {
public static void main(String[] args) {
// 创建操作类, 调用方法
JumppingOperator jo = new JumppingOperator();
Jumpping j = new Cat();
jo.useJumpping(j);
Jumpping j2 = jo.getJumpping();
j2.jump();
}
}
衣带渐宽终不悔，为伊消得人憔悴！
