接口和抽象类
一、抽象类
1.1什么是抽象类?
抽象类是一种特殊的类
被abstract关键字修饰的类就是抽象类
修饰符 abstract class 类别{
类体
}
在Java中,有些类不适合创建对象,这时可以把类定义成抽象类。
抽象类是不可以创建对象的,但是可作为父类使用。
例:门:开门、关门
防火门:防火
防盗门:防盗
public abstract class Door {
// 使用abstract 修饰类,Door就变成了抽象类,不能创建对象
// 行为
public void open(){
System.out.println("开门");
}
/*
* 对于不同的门,关门的动作是不一样的
* 在父类中没有办法统一去实现
* 把关门的方法定义成抽象的
* */
public abstract void close();
}
```java
public class FireProofDoor extends Door{
@Override
public void close() {
System.out.print("关门:");
FireProof();
}
public void FireProof() {
System.out.println("启动防火功能");
}
}
public class AntiTheftDoor extends Door{
@Override
public void open() {
System.out.println("输入密码才能开门");
}
@Override
public void close() {
System.out.print("关门:");
antiTheft();
}
public void antiTheft(){
System.out.println("启动防盗功能");
}}
public class Main {
public static void main(String[] args) {
Door door1=new AntiTheftDoor();
door1.open();
door1.close();
System.out.println("*******************");
Door door2=new FireProofDoor();
door2.open();
door2.close();
}
}
1.2抽象方法
被abstract修饰的方法就是抽象方法。
抽象方法只有方法的定义,没有方法的实现(没有方法体),结尾必须是;
抽象方法必须由子类实现。
抽象类与抽象方法的关系:
1)抽象类可以拥有类所拥有的一次,包括:属性、方法、构造方法等
抽象类可以拥有抽象方法
2)有抽象方法的类必须是抽象类
3)抽象类的子类有两个选择
a.实现抽象类中的所有抽象方法,子类就可以是一个普通类
b. 如果没有实现抽象父系的所有抽象方法,子类必须也是抽象类。
1.3总结
1、抽象方法是没有方法体,如果这个类里面有抽象方法,这个类必须变成抽象类。
2、如果这个类是抽象类,并不要求这个类一定要有抽象方法
3、抽象类里面可以有普通方法,也可以有抽象方法。
4、如果一个类是抽象类,那么这个类就不能被new实例化,只能被其他类继承。
5、抽象方法可以理解为父类(抽象类)定义的一个模板或者规范(自己本身不实现),
子类必须实现这个抽象方法,如果子类不想实现这个方法,那么这个子类也必须要变成抽象类。
二、接口
2.1什么是接口?
接口是一种数据类型.
接口是一种比抽象类更抽象的数据类型
1)接口中定义的变量都是公共的静态的常量,默认使用public static final 关键字修饰
2)接口中定义的方法,默认使用public abstract 关键字修饰
接口是一个纯粹的抽象类(接口里面所有的方法都是抽象方法)
接口就是一个规范,他没有提供任何是实现,具体的功能由实现接口的子类去实现。
接口就是一个规范,可插拔(可以被替换,首先定义一个标准(接口),大家都遵守这个标准,就可以实现互相之间替换)
1、接口是一个纯粹的抽象类,接口里面的方法都是抽象方法 public abstract。
2、接口里面所有的属性public static final
注意:
Java中一个类最多只能有一个直接父类,单继承
但Java中可以让一个类同时实现多个接口,多实现
一个接口也可以继承另一个接口,使用extends
接口也可以继承父接口的所有方法,而且也是单继承
2.2JDK1.8中新特征:
1)函数式接口:接口中只有一个抽象方法
2)允许接口中有静态方法
static void test(){ 方法体 }
3)允许接口中有默认方法
default void test(){int i=0;}
注意:
接口的实现类,要么实现接口中所有的抽象方法,
要么实现类就只能是一个抽象类
三、接口和抽象的异同
抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性,方法,静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法,那么当前类一定是抽象类;抽象类中不一定有抽象方法。
5.抽象类中的抽象方法,需要有子类实现,如果子类不实现,则子类也需要定义为抽象的。
java类是单继承的。classB Extends classA
java接口可以多继承。Interface3 Extends Interface0, Interface1, interface……
接口
1.在接口中只有方法的声明,没有方法体。
2.在接口中只有常量,因为定义的变量,在编译的时候都会默认加上
public static final
接口可以有default、static方法
3.在接口中的方法,永远都被public来修饰。
4.接口中没有构造方法,也不能实例化接口的对象。
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现,如果实现类不能实现接口中的所有方法.则实现类定义为抽象类。
同:
1)都不能创建对象
2)都可以有抽象方法
3)接口抽象类在使用时,基本上都是上转型
异:
1)抽象类是类,类和接口是不同的数据类型
2)抽象类在继承时使用的时extends,接口在实现时使用implements
3)抽象类可以有属性,构造方法,普通方法,接口不行。
四、抽象类和接口类结合实例
实例1
public abstract class 英雄 {
public abstract void 攻击力();
public abstract void 法术强度();
public abstract void 物理防御();
public abstract void 法术防御();
public abstract void 物理吸血();
public abstract void 法术吸血();
public abstract void 物理穿透();
public abstract void 法术穿透();
public abstract void 装备1();
public abstract void 装备2();
public abstract void 装备3();
public abstract void 装备4();
public abstract void 装备5();
public abstract void 装备6();
public abstract void 英雄信息();
}
public interface 增益buff {
public abstract void 洞察之力();
public abstract void 无敌金身();
public abstract void 狂暴之力();
public abstract void 疾射火炮();
public abstract void 天人合一();
}
public class 人物 extends 英雄 implements 增益buff{
String name;
public 人物(String name) {
this.name = name;
}
@Override
public void 攻击力() {
System.out.print("攻击力:650"+" ");
}
@Override
public void 法术强度() {
System.out.print("法术强度:1500"+" ");
}
@Override
public void 物理防御() {
System.out.print("物理防御:2000"+" ");
}
@Override
public void 法术防御() {
System.out.print("法术防御:2000"+" ");
}
@Override
public void 物理吸血() {
System.out.print("物理吸血:90%"+" ");
}
@Override
public void 法术吸血() {
System.out.print("法术吸血:90%"+" ");
}
@Override
public void 物理穿透() {
System.out.print("物理穿透:80%"+" ");
}
@Override
public void 法术穿透() {
System.out.print("法术穿透:80%"+" ");
}
@Override
public void 装备1() {
System.out.print("装备1:无尽战刃"+" ");
}
@Override
public void 装备2() {
System.out.print("装备2:幽梦之灵"+" ");
}
@Override
public void 装备3() {
System.out.print("装备3:死亡之舞"+" ");
}
@Override
public void 装备4() {
System.out.print("装备4:不朽盾弓"+" ");
}
@Override
public void 装备5() {
System.out.print("装备5:鬼索的狂暴之刃"+" ");
}
@Override
public void 装备6() {
System.out.print("装备6:饮血剑");
}
@Override
public void 英雄信息(){
System.out.println("英雄:"+this.name);
System.out.print("基础属性:");
攻击力();
法术强度();
物理防御();
法术防御();
物理吸血();
法术吸血();
物理穿透();
System.out.println();
System.out.print("装备信息:");
装备1();
装备2();
装备3();
装备4();
装备5();
装备6();
System.out.println();
System.out.println("六神装集齐,召唤神龙,获得神龙之力!");
System.out.println("增益buff:");
洞察之力();
无敌金身();
狂暴之力();
疾射火炮();
天人合一();
}
@Override
public void 洞察之力() {
System.out.println("洞察之力:无限视距,无视战争迷雾"+" ");
}
@Override
public void 无敌金身() {
System.out.println("无敌金身:全身散发金色光芒,开启后无视任何形式的伤害,开启期间可进行攻击"+" ");
}
@Override
public void 狂暴之力() {
System.out.println("狂暴之力:获得此buff攻速提升200%,吸血提升200%,攻击力提升30%"+" ");
}
@Override
public void 疾射火炮() {
System.out.println("疾射火炮:无限攻击距离"+" ");
}
@Override
public void 天人合一() {
System.out.println("天人合一:免疫控制效果并且减少所受到的伤害"+" ");
}
}
public class Main {
public static void main(String[] args) {
英雄 ZHC=new 人物("ZHC");
ZHC.英雄信息();
}
}
实例2
public abstract class AbstractBird {
public abstract void egg();
}
public interface IFly {
public abstract void fly();
}
public class DaYan extends AbstractBird implements IFly {
@Override
public void egg() {
System.out.println("DaYan.edd");
}
@Override
public void fly() {
System.out.println("DaYan.fly");
}
public void print(){
System.out.println("DaYan.print");
}
}
public class GeZi extends AbstractBird{
@Override
public void egg() {
System.out.println("GeZi.edd");
}
}
public class Demo {
@Test
public void test1(){
DaYan daYan=new DaYan();
daYan.egg();
daYan.fly();
daYan.print();
// bird是站在AbstractBird这个角度去看new出来的大雁,
// 只能看到下蛋这个功能
AbstractBird abstractBird=new DaYan();
abstractBird.egg();
// abstractBird.fly();
// abstractBird.print();
// fly是站在IFly这个角度去看new出来的大雁,
// 只能看到fly这个功能
IFly iFly=new DaYan();
iFly.fly();
}}
继承是严格的父子关系,你继承什么你就是什么:鸽子就是鸟。
父类是抽取了所有子类的共同特征,父类里面的属性和方法是所有子类所共有的属性和方法。
接口是一个标准,一般用在能不能具有某个功能。
把能不能飞定义称为一个接口IFly,实现了这个接口的类就具有了这个功能。