16_抽象类和接口

16_抽象类和接口

一. 抽象类

1. 为什么使用抽象类

• 有些类创建的对象并不具体,需要把这个定义为抽象类:

Animal animal=new Animal();
Pet pet=new Pet();

• 使用abstract修饰类变成抽象类:不能实例化,只能被继承;

• 抽象类的构造方法不能直接使用,只能被子类调用.

2. abstract关键字

关键字:abstract:抽象 

可以修饰类: 叫做抽象类;
可以修饰方法: 叫做抽象方法,没有方法体,需要使用分号表示声明结束,抽象方法所在的类必须是抽象类;

子类必须重写父类的抽象方法,除非子类也是抽象类.

3. 抽象方法

使用abstract关键字修饰的方法,只表示声明了一个方法,但是没有任何具体的实现.

特点:

1).没有方法体,需要使用分号表示方法声明结束;
2).如果一个类中有一个方法是抽象的,那么这个类必须是抽象的;
3).抽象方法必须被子类重写,除非子类也是抽象类.

4. 抽象类

使用abstract关键字修饰的类.

特点:

1).抽象类中可以包含抽象方法,也可以不包含抽象方法;
2).抽象类中有构造方法,但是不能创建对象,构造方法可以在子类中会被调用;
3).抽象类的存在就是为了被继承,子类必须重写父类的抽象方法,除非子类也是抽象类.

5. 抽象类和普通类的区别

1).抽象类需要abstract,而普通类不需要;
2).构造方法: 都有,但是抽象类不能实例化对象,普通类可以; 
3).成员方法: 抽象类中可以存在抽象方法也可以存在非抽象方法,而普通类中只能存在非抽象方法.

思考1:

final和abstract是否可以连用?

1).两个关键字修饰方法时:
final修饰的方法特点: 可以被继承不能被重写;
abstract修饰的方法特点: 必须被重写; 
所以这两个关键字不能同时修饰同一个方法.

2).两个关键字修饰类时: 
final修饰的类特点: 不能被继承;
abstract修饰的类特点: 必须被继 承;
所以这两个关键字不能同时修饰同一个类.

综上所述: final和abstract不可以连用.

思考2:

final的类中能否有abstract方法?

不能 

思考3:

abstract类中能否有final方法?

可以.

6. 上机练习

package com.syc.day12;
/**
* 编写交通工具类,具有前进功能run();
* 子类有自行车、小轿车、地铁,重写父类方法;
* 主人有属性name,age属性,回家方法goHome(交通工具),需要使用交通工具,使用抽象类优化程序.
TrafficTool
Bicycle
Car
Subway
Master
*/

public abstract class TracficTool { //品牌
    private String brand;
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
    
    public TracficTool() {
        //TODOAuto-generated constructor stub
    }
    
    public TracficTool(String brand) {
        super();
        this.brand = brand;
    }
    
    /**
    * 前进方法 
    */
    public abstract void run();   
}

package com.syc.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.syc.day12;

public class Car extends TracficTool{
   
    public Car() {
        //TODOAuto-generated constructor stub
    }
    
    public Car(String brand) {
        super(brand);
        //TODOAuto-generated constructor stub
    }

    @Override
    public void run() { 
        System.out.println(getBrand()+"轿车正在飞速的前进...");
    }
}
    
package com.syc.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.syc.day12;

/**
* 主人
*/
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.syc.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);
    } 
}

7. static,final,abstract总结



二. 接口

生活中的接口: USB,插座... 
USB接口: 必须满足USB接口的宽度和厚度;
内部: 需要遵守导线的个数;
插座: 首先需要满足插头的个数,满足电压和电流一些规则.

2.1 接口的概念

从语法上讲: 接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有方法的实现.

从功能上讲: 接口表示一种约定(规范)或能力.

2.2 使用接口的好处

• 扩展类的功能,保持对外接口一致;

• 接口实现了多重继承,完成类和任何实现接口子类的通信和交互;

• 降低代码之间的耦合性.

2.3 接口的特点:

1).接口不能创建对象,而且接口中没有构造方法;
2).接口中的方法一般都是共有抽象方法: public abstract;
3).接口中所有的属性都是共有静态常量属性: pulbic static final

在一个接口中声明方法时,若没有声明访问权限,默认也是public,若没其他修饰默认也是abstract;

声明属性时,若没有声明访问权限和静态常量,默认也是public static final.

//示例
public interface Usb { //常量
    String brand="xxx"; 
    //前面省略public static final //方法
    
    void charge(); //前面省略 public abstract
}

2.4 接口的声明语法

关键字interface: 表示一个接口,接口interface和类class是平级关系 接口名命名习惯:
如果接口表示一种能力，命名采用:名字+后缀able ，比如 Serializable Comparable

语法:
public interface 接口名{ 
     //接口中的成员:抽象方法和静态常量
}

2.5 接口的实现类

接口与类的关系: 
implements: 实现一个类可以实现多个接口.

语法:

public interface I{
    public abstract void fun();
}

public class Impl implements I {
    public void fun(){}
}

思考:

一个类实现某个接口之后,是否可以存在父类?
可以,实现接口和继承类不冲突.

注意:

若一个类有父类同时也实现接口,声明类时,必须先继承再实现接口.

语法

public class Dog extends Animal implements I{
    public void fun(){}
}

2.6 接口的分类:

1).普通接口: 在接口中可以声明抽象方法和静态常量属性;
2).常量群接口: 在接口中只声明一组静态常量属性;
3).标志性接口: 在接口中没有抽象方法,也没有静态常量,作用为了标记某个类具有某个功能.

2.7 接口和接口的关系:

继承关系:

使用关键字extends实现接口与接口的继承关系.

接口继承的特点:

• 1).接口中没有私有成员,所以父接口中的所有成员都会被子接口继承;

• 2).父子关系中都是接口,所以在子接口中不需要实现任何的抽象方法;

• 3).接口可以多继承.

思考:

现有类A和类B,两个类中都有fun()方法,假如类C继承类A和类B,当使用类C的对象调用fun方法时,如何执行?

此时不知道执行那个fun方法,所以类不可以多继承.

现有A,B两个接口,接口中都有fun方法,接口C继承A,B,由于接口中的没有方法体,所在只要在接口C中存在了fun方法即可,所以接口支持多继承.

2.7 接口中特殊的方法:

• 1).JDK 1.8之后接口中使用static关键字修饰的方法有方法体,静态方法需要有方法体,注意只能通过 "接口名.方法名" 调用,因为不能被继承;

• 2).JDK 1.8之后接口中使用default关键字修饰的方法有方法体,可以被继承,通过实现类调用.

2.8 接口的使用:

1.USB接口

public interface USB{
    public void server();
}

public class Fan implements USB {
    public void server() {
    //TODO Auto-generated method stub
System.out.println("风扇和电脑连接成功,开始工作"); 
    }
}

public class Mouse implements USB{
    public void server() {
    //TODO Auto-generated method stub
System.out.println("鼠标和电脑连接成功,开始工作"); 
    }
}

public class Computer { 
    //面向接口编程,而不面向具体的实现 
    public USB usb1;
    public USB usb2;
    public USB usb3;
    
    public void Run(){ 
        System.out.println("电脑启动成功"); 
    
        if(usb1!=null) {
            usb1.server();
        }
        
        if(usb2!=null) {
            usb2.server();
        }
        
        if(usb3!=null) {
            usb3.server();
        }
    }
}

2. 在一个平台或系统中,

如果多个类都需要使用到某些方法(功能),可以将这些方法定义到一个接口中,所有需要这些方法的类,可以实现这个接口,有效地实现解耦.

案例:
现有运输工具类Transport类 Transport有三个子类,飞机Plane,车Car,船Ship.

Plane: 客机/货机/战斗机;
Car: 货车/坦克;
Ship: 客船/货船/航母;

战斗机,坦克,航母都有开火攻击的功能,通过分析,此功能不能来自于父类,所以可以将开火攻击的功能设置在一个接口中.

//交通工具类
public class Transport {

    //成员方法
    public void transfer(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) {
        FightingPlane fp = new FightingPlane();
        fp.yun("炸药"); 
        fp.fire();
        //战斗机对象的开火攻击的功能来源于Fire接口 
        //可以使用接口的引用指向实现类的实例
        Fire f = new Tank();
    }
}

2.9 抽象类和接口区别

语法:

• 1>. 抽象类使用abstract,接口使用interface;
• 2>. 抽象类中可以包含抽象方法,也可以包含非抽象方法,接口中只能包含抽象方法和静态常量,jdk1.8之后接口可以包含静态方法和默认方法;
• 3>. 抽象类和接口都不能实例化;
• 4>. 抽象类可以包含构造方法,接口中没有构造方法.

功能:

• 1>.抽象类一般用来表示同类事物,接口可以表示不同类事物;

• 2>.抽象类可以实现代码的重用,也可以约束子类的功能.接口就是约束实现类的功能,降低代码之间的耦合性.

使用场景:

• 1>. 程序或模块内部使用抽象类;

• 2>. 程序架构或模块之间使用接口.

三. 总结

1. 抽象类: 为什么使用抽象类?
    类实例化对象没有意思,所以把类定义为抽象类;
    抽象类不能实例化对象.

2. abstract关键字
   abstract 修饰类,表示抽象类;
   abstract 修饰方法,表示抽象方法 

3. 抽象方法
    抽象方法没有方法体;
    抽象方法被子类重写;
   包含抽象方法的类一定是抽象类.

4. 抽象类 
   抽象类不能实例化对象;
    抽象类可以包含抽象方法,也可以包含非抽象方法;
   抽象类的抽象方法必须被子类重写,除非子类也是抽象类.
   
5. static final abstract
   final 和 abstract 不能一起使用;
   static和 abstract不能一起使用;

6. 接口: 
   功能: 表示一个规范或能力;
   
   接口好处:
    扩展类的功能,保持对外接口一致,接口实现了多重继承,完成类和任何实现接口子类的通信和交互,降低代码之间的耦合性.