抽象类和接口
1. 抽象类
2. 抽象方法
3. 接口
第一节: 抽象类
1.1 为什么使用抽象类
- 有些类创建对象没有意义。需要把这个定义为抽象类
- 1 Animal animal=new Animal();
- 2 Pet pet=new Pet()
- 使用abstract修饰类变成抽象类:不能实例化,只能被继承
- 抽象类的构造方法不能直接使用,只能被子类调用。
1.2 abstract 关键字
关键字:abstract:抽象
可以修饰类:叫做抽象类
可以修饰方法:叫做抽象方法,没有方法体,需要使用分号表示声明结束,抽象方法所在的类必须是抽象类
子类必须重写父类的抽象方法,除非子类也是抽象类
1.3 抽象方法
使用abstract关键字修饰,只表示声明了一个方法,但是没有任何的实现
特点:
1)没有方法体,需要使用分号表示方法声明结束
2)如果一个类中有一个方法是抽象的,那么这个类必须是抽象的
3)抽象方法必须被子类重写,除非子类也是抽象类
1.4 抽象类:
使用abstract关键字修饰
特点:
1)抽象类中可以包含抽象方法,也可以包含普通方法。
2)抽象类中有构造方法,但是不能创建对象,构造方法目的在子类中会被调用。
3)抽象类的存在就是为了被继承,子类必须重写父类的抽象方法,除非子类也是抽象类。
1.5 抽象类和普通类的区别:
1)抽象类需要abstract,而普通类不需要
2)构造方法:都有,但是抽象类不能实例化对象,普通类可以
3)成员方法:抽象类中可以存在抽象的成员方法也可以存在非抽象成员方法,而普通类中只能存在非抽象成员方法
思考:final和abstract是否可以连用?
1)两个关键字修饰方法时,final修饰的方法特点:可以被继承不能被重写;abstract修饰的方法特点:必须被重写;所以这两个关键字不能同时修饰同一个方法
2)两个关键字修饰类时:final修饰的类特点:不能被继承;abstract修饰的类特点:必须被继承;所以这两个关键字不能同时修饰同一个类
综上所述:final和abstract不可以连用
final的类中能否有abstract方法?不能
abstract类中能否有final方法?可以
上机练习1:
编写交通工具类,具有前进run()功能,子类有自行车、小轿车、地铁,重写父类方法,主人有属性name,age属性,方法回家goHome(交通工具),需要使用交通工具,使用抽象类优化程序
TrafficTool
Bicycle
Car
Subway
Master
package com.qf.day12;
/**
* 编写交通工具类,具有前进run()功能,子类有自行车、小轿车、地铁,重写父类方法,主人有属性name,age属性,方法回家goHome(交通工具),需要使用交通工具,使用抽象类优化程序
TrafficTool
Bicycle
Car
Subway
Master
* @author wgy
*
*/
public abstract class TracficTool {
//品牌
private String brand;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public TracficTool() {
// TODO Auto-generated constructor stub
}
public TracficTool(String brand) {
super();
this.brand = brand;
}
/**
* 前进方法
*/
public abstract void run();
}
package com.qf.day12;
public class Bicycle extends TracficTool {
public Bicycle() {
// TODO Auto-generated constructor stub
}
public Bicycle(String brand) {
super(brand);
}
@Override
public void run() {
System.out.println(getBrand()+"的自行车,在行驶...............");
}
}
package com.qf.day12;
public class Car extends TracficTool{
public Car() {
// TODO Auto-generated constructor stub
}
public Car(String brand) {
super(brand);
// TODO Auto-generated constructor stub
}
@Override
public void run() {
System.out.println(getBrand()+"轿车正在飞速的前进............");
}
}
package com.qf.day12;
public class Subway extends TracficTool {
public Subway() {
// TODO Auto-generated constructor stub
}
public Subway(String brand) {
super(brand);
// TODO Auto-generated constructor stub
}
@Override
public void run() {
System.out.println(getBrand()+"地铁,在高速前进..............");
}
}
package com.qf.day12;
/**
* 主人
* @author wgy
*
*/
public class Master {
private String name;
private int 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 Master() {
// TODO Auto-generated constructor stub
}
public Master(String name, int age) {
super();
this.name = name;
this.age = age;
}
//回家
public void goHome(TracficTool tool) {
System.out.println(getName()+"下班了,要回家...");
tool.run();
System.out.println(getName()+"到家了...");
}
}
package com.qf.day12;
public class Test {
public static void main(String[] args) {
Master zhengshuai=new Master("郑帅", 29);
Bicycle fenghuang=new Bicycle("凤凰牌");
Car baoshijie=new Car("保时捷");
Subway shuaishuai=new Subway("北京地铁");
zhengshuai.goHome(fenghuang);
zhengshuai.goHome(baoshijie);
zhengshuai.goHome(shuaishuai);
}
}
1.6 static,final,abstract总结
修饰符 修饰对象 规则
static 属性 表示类公共的属性,使用类来调用,推荐使用类调用(类名.属性名)
方法 表示类公共的方法,在静态方法中只能直接调用静态变量或静态方法,不能使用this,super,如果要想调用非静态方法和属性,需要创建对象。
代码块 静态代码块,程序一加载静态代码块就运行,而且只运行一次
final 属性、局部变量 常量,final int i=12;或者final int i;i=12;只能赋值一次。
方法 该方法不能被子类重写,可以被继承。
类 该类不能被继承。
abstract 方法 抽象方法,该方法只有方法声明,没有方法体
构造方法和static方法、final方法不能是抽象的
有该方法的类称为抽象类,类名前必须加abstract
类 抽象类不能被实例化
抽象类可以指向子类对象的引用
抽象类可以有普通方法,可以被子类继承
父类的抽象方法必须在子类中实现,除非子类也是抽象类
第二节: 接口
生活中的接口:USB,插座…
USB:物理:必须满足USB接口的宽度和厚度
内部:需要遵守磁片的个数
插座:首先需要满足插头的个数
满足电压和电流一些规则
2.1 接口的概念
从语法上讲:
接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有方法的实现。
从功能上讲:接口表示一种约定或能力
2.2 使用接口的好处
- 扩展类的功能,保持对外接口一致
- 接口实现了多重继承,完成类和任何实现接口子类的通信和交互
- 降低代码之间的耦合性
2.3 接口的特点:
1)接口不能创建对象,而且接口中没有构造方法;
2)接口中的方法一般都是共有抽象方法:public abstract
3)接口中所有的属性都是共有静态常量属性:public static final
在一个接口中声明方法时,若没有声明访问权限,默认也是public,若没其他修饰默认也是abstract;声明属性时,若没有声明访问权限和静态常量,默认也是public static final
public abstract void fun();
接口中可以使用一下格式声明方法:
void fun();
public static final int a = 9;
int a = 9;
2.4 接口的声明语法
关键字interface:表示一个接口,接口interface和类class是平级关系
接口命名:
如果接口表示一种能力,命名采用:名字+后缀able ,比如 Serializable Comparable
如果接口表示一种约定或规范 ,按照命名规范正常命名 USB , Comparator,CharSequence
语法:
public interface 接口名{
//接口中的成员:抽象方法和静态常量
}
2.5 接口的实现类
接口与类的关系:implements
语法:
pulbic interface I{
public abstract void fun();
}
public class Impl implements I {
public void fun(){}
}
思考:一个类实现某个接口之后,是否可以存在父类?
可以,实现接口和继承类不冲突
注意:1.若一个类有父类同时也实现接口,声明类时,必须先继承再实现接口
2.一个类可以实现多个接口
语法:
public class Dog extends Animal implements I{
public void fun(){}
}
2.6 接口的分类:
1)普通接口:在接口中可以声明抽象方法,和静态常量属性
2)常量群接口:在接口中只声明一组静态常量属性
3)标志性接口:在接口中没有抽象方法,也没有静态常量,作用为了标记某个类具有某个功能
2.7 接口和接口的关系:
继承关系:使用关键字extends实现接口与接口的继承关系
接口继承的特点:
1)接口中没有私有成员,所以父类接口中的所有成员都会被子接口继承
2)父子关系中都是接口,所以在子接口中不需要实现任何的抽象方法
3)接口可以多继承
2.7 接口中特殊的方法:
1)jdk1.8之后接口中使用static关键字修饰的方法有方法体
静态方法需要有方法体
2)jdk1.8之后接口中使用default关键字修饰的方法有方法体
2.8 接口的使用:
1.USB接口
public interface USBInterface {
public void server();
}
public class Fan implements USBInterface {
public void server() {
// TODO Auto-generated method stub
System.out.println("风扇和电脑连接成功,开始工作");
}
}
public class Mouse implements USBInterface{
public void server() {
// TODO Auto-generated method stub
System.out.println("鼠标和电脑连接成功,开始工作");
}
}
public class Computer {
//面向接口编程,而不面向具体的实现
public USBInterface usb1;
public USBInterface usb2;
public USBInterface usb3;
public void Run(){
System.out.println("电脑启动成功");
if(usb1!=null) {
usb1.service();
}
if(usb2!=null) {
usb2.service();
}
if(usb3!=null) {
usb3.service();
}
}
}
2.在一个平台或系统中,如果多个类都需要使用到某些方法(功能),可以将这些方法定义到一个接口中,所有需要这些方法的类,可以实现这个接口,有效地实现解耦。
案例:现有交通工具类Transport类
Transport有三个子类,飞机Plane,车Car,船Ship
Plane有,客机,货机,战斗机
Car有客车,货车,坦克
Ship船有客船,货船,航母
战斗机,坦克,航母都有开火攻击的功能,通过分析,此功能不能来自于父类,所以可以将开火攻击的功能设置在一个接口中
//交通工具类
public class Transport {
//成员方法
public void yun(String goods) {
System.out.println("运输"+goods);
}
}
//飞机类
public class Plane extends Transport {}
//船类
public class Ship extends Transport {}
//车类
public class Car extends Transport {}
//开火攻击接口
public interface Fire {
public abstract void fire();//开火攻击方法
}
//航母类:继承Ship,实现Fire
public class Carrer extends Ship implements Fire {
@Override
public void fire() {
// TODO Auto-generated method stub
System.out.println("xiu~~~");
}
}
//战斗机:继承Plane,实现Fire
public class FightingPlane extends Plane implements Fire {
@Override
public void fire() {
// TODO Auto-generated method stub
System.out.println("piupiupiu~~");
}
}
//坦克类:继承Car,实现Fire
public class Tank extends Car implements Fire {
@Override
public void fire() {
// TODO Auto-generated method stub
System.out.println("轰轰轰~~~");
}
}
//测试
public class TestTransport {
public static void main(String[] args) {
Fireable fireable1=new FightPlane();
Fireable fireable2=new Tank();
Fireable fireable3=new Carrer();
fight(fireable1);
fight(fireable2);
fight(fireable3);
}
//战斗方法
public static void fight(Fireable fireable) {
for(int i=0;i<10;i++) {
fireable.fire();
}
}
}
2.9 抽象类和接口区别
语法:
1>抽象类使用abstract,接口使用interface
2>抽象类中可以包含抽象方法,也可以包含非抽象方法,接口中只能包含抽象方法和静态常量,jdk1.8之后接口可以包含静态方法和默认方法。
3>抽象类和接口都不能实例化。
4>抽象类可以包含构造方法,接口中没有构造方法。
功能:
1>抽象类一般用来表示同类事物,接口可以表示不是同类事物。
2>抽象类可以实现代码的重用,也可以约束子类的功能。接口就是约束实现类的功能,降低代码之间的耦合性。
使用场景:
1>程序或模块内部使用抽象类(开发中使用比较少)
2>程序架构或模块之间使用接口(比较多)
总结
1 抽象类:
实例化对象没有意思,所以使用抽象类,
抽象类不能实例化
2 abstract关键字
abstract 修饰类表示抽象类
abstract 修饰方法 抽象方法
4 抽象方法
抽象方法没有方法体
抽象方法被子类重写
包含抽象方法的类一定是抽象类
5 抽象类
抽象类不能实例化对象
抽象类可以包含抽象方法,也可以包含非抽象方法
抽象类的抽象方法必须被子类重写,除非子类也是抽象类
6 static final abstract
final 和 abstract 不能一起使用
static和abstract不能一起使用
7接口 :语法:就是特殊的抽象类
功能:表示一个约定或能力
接口好处:
- 扩展类的功能,保持对外接口一致
- 接口实现了多重继承,完成类和任何实现接口子类的通信和交互
- 降低代码之间的耦合性
定义接口
public interface 接口名{
常量
抽象方法
}
jdk1.8 静态方法和默认方法
实现接口
class 类名 implements 接口名{
重写接口中抽象方法
}
一个类可以实现多个接口,只能继承一个类
接口与接口的关系: extends ,多继承
public interface Inter1{
}
public interface Inter2{
}
public interface Inter3 extends Inter1,Inter2{
}
接口案例:
Usb案例 表示接口是一个约定
开火案例 表示接口是一个能力
面试题
接口和抽象类有什么区别?