抽象类和接口

1.1 为什么使用抽象类
有些类创建对象没有意义。需要把这个定义为抽象类
1 Animal animal=new Animal();
2 Pet pet=new Pet()
抽象类（abstract）不能实例化，只能被继承。
1.2 abstract 关键字
关键字：abstract：抽象
可以修饰方法：叫做抽象方法，没有方法体，需要使用分号表示声明结束
可以修饰类：叫做抽象类，抽象方法所在的类必须是抽象类
1.3 抽象方法
使用abstract关键字修饰，只表示声明了一个方法，但是没有任何的实现
特点：
1没有方法体，需要使用分号表示方法声明结束
2如果一个类中有一个方法是抽象的，那么这个类必须是抽象的
​ 3抽象类中可以包含抽象方法，也可以不包含
4 抽象方法必须被子类重写，除非子类也是抽象类
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
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）接口中所有的属性都是共有静态常量属性：pulbic 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是平级关系
语法：
public interface 接口名{
//接口中的成员：抽象方法和静态常量
}
2.5接口的实现类
接口与类的关系：implements
语法：
pulbic 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）在接口中使用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(){
	usb1.server();
	usb2.server();
	usb3.server();
}

}

2.在一个平台或系统中，如果多个类都需要使用到某些方法，可以将这些方法定义到一个接口中，所有需要这些方法的类，可以实现这个接口，有效地实现解耦。
案例：现有交通工具类Transport类
​ Transport有三个子类，飞机Plane，车Car，船Ship
Plane有，客机，货机，战斗机
​ Car有客车，货车，坦克
​ 船有客船，货船，航母
战斗机，坦克，航母都有开火攻击的功能，通过分析，此功能不能来自于父类，所以可以讲开火攻击的功能设置在一个接口中
//交通工具类
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) {
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>抽象类可以实现代码的重用，也可以约束子类的功能。接口就是约束实现类的功能，降低代码之间的耦合性。