一、快速入门
1、
package interface_;
public class Interface01 {
public static void main(String[] args) {
Phone phone = new Phone();
Computer computer=new Computer();
computer.work(phone);//把手机接入到计算机
}
}
//输出:
// 手机开始工作……
//手机停止工作……
package interface_;
public interface UsbInterface {//接口
//规定了接口的相关方法
public void start();
public void stop();
}
package interface_;
//Phone类实现UsbInterface,要实现UsbInterface规定/声明的方法
public class Phone implements UsbInterface{
public void start(){
System.out.println("手机开始工作……");
}
public void stop(){
System.out.println("手机停止工作……");
}
}
package interface_;
public class Computer {
public void work(UsbInterface usbInterface){
//通过接口来调用方法
usbInterface.start();
usbInterface.stop();
}
}
2、难点在于不知道什么时候使用接口:(应用场景)
(1)说现在要制造战斗机,武装直升机,专家只需把飞机需要的功能/规格定下来即可,然后让别的人具体实现就可
(2)有一个项目经理,管理三个程序员,功能开发一个软件,为了控制和管理软件,项目经理可以定义一些接口,然后由程序员具体实现
package interface_;
public class Interface03 {
public static void main(String[] args) {
MysqlDB mysqlDB=new MysqlDB();
t(mysqlDB);
OracleDB oracleDB = new OracleDB();
t(oracleDB);
}
public static void t(DBInterface db){
db.connect();
db.close();
}
}
//输出:
// 连接mysql
//关闭mysql
//连接oracle
//关闭oracle
package interface_;
public class MysqlDB implements DBInterface{
public void connect(){
System.out.println("连接mysql");
}
public void close(){
System.out.println("关闭mysql");
}
}
package interface_;
public class OracleDB implements DBInterface{
public void connect(){
System.out.println("连接oracle");
}
public void close(){
System.out.println("关闭oracle");
}
}
二、基本介绍:
接口就是给出一些没有实现的方法,封装到一起,到某个类要使用时,再根据具体情况把这些方法写出来,语法:
interface 接口名{
//属性
//方法
}
class 类名 implements 接口{
自己属性;
自己方法;
必须实现的接口的抽象方法
}
小结:
1、在jdk7.0前接口里的所有方法都没有方法体
2、在jdk8.0后接口类可以有静态方法(需要用static关键字修饰),默认方法(需要用default关键字修饰),即接口中可以有方法的具体实现
package interface_;
public class Interface2 {
public static void main(String[] args) {
}
}
class A implements Interface02{
public void hi(){
System.out.println("hi()...");
}
}
package interface_;
public interface Interface02 {
public int n1=10;//属性
//在接口中,抽象方法可以省略abstract关键字
public void hi();//方法
default public void ok(){//默认方法
System.out.println("ok...");
}
public static void cry(){//静态方法
System.out.println("cry...");
}
}
三、细节:
1、接口不能被实例化(抽象,所以不能new,而且实例化后要调用方法,方法不能用)
2、接口中所有的方法是public方法,接口中抽象方法,可以不用abstract修饰(因为接口本身就是抽象的)
void a();//实际上是public abstract void a();
3、一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用快捷键alt+enter快速解决
4、抽象类实现接口,可以不用实现接口的方法
5、一个类同时可以实现多个接口
class Pig implements IB,IC{}
6、接口中的属性,只能是final的,而且是public static final修饰符
int a=1;//实际上是public static final int a=1;(必须初始化)
package interface_;
public class Interface03 {
public static void main(String[] args) {
System.out.println(IB.n1);//1、可通过类名访问属性,证明接口有static修饰
//IB.n1=30;//2、属性不可修改,证明接口有final修饰
}
}
interface IB{
int n1=10;
//protected int n1=10;报错
//private int n1=10;报错
//3、证明接口是public
}
7、接口中属性的访问形式:
接口名.属性名
8、一个接口不能继承其他的类,但是可以继承多个别的接口(注意是extends,不是implements)
interface A extends B,C{}
9、接口的修饰符,只能是public和默认,这点和类的修饰符是一样的
四、实现接口VS继承类(Extends VS Interface)
package interface_;
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey wukong = new LittleMonkey("悟空");
wukong.climbing();
wukong.swimming();
}
}
class Monkey{
private String name;
public Monkey(String name) {
this.name = name;
}
public void climbing(){
System.out.println(name+"会爬树");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//接口
interface Fishable{
void swimming();
}
//继承
class LittleMonkey extends Monkey{
public LittleMonkey(String name) {
super(name);
}
public void swimming(){
System.out.println(getName()+"通过学习,可以游泳");
}
}
//输出:
//悟空会爬树
//悟空通过学习,可以游泳
1、继承是天生就有的,实现是后天学习的技能
2、当子类继承了父类,就自动拥有父类的功能;如果子类需要扩展功能,可以通过实现接口的方式扩展
3、实现接口是对java单继承机制的一种补充
4、比较:
(1)接口和继承解决的问题不同:
继承:解决代码的复用性和可维护性
接口:设计,设计好各种规范(方法),让其它类去实现这些方法
(2)接口比继承更加灵活:
继承:是满足is-a的关系
接口:只需满足like-a的关系
(3)接口在一定程度上实现代码解耦(接口规范性+动态绑定机制)
五、接口的多态特性:
1、多态参数
package interface_;
public class Interface01 {
public static void main(String[] args) {
Phone phone = new Phone();
Camera camera = new Camera();
Computer computer = new Computer();
computer.work(phone);//把手机接入到计算机
System.out.println("===============");
computer.work(camera);//把相机接入到计算机
//UsbInterface既可以接收手机对象,又可以接收相机对象
//就体现了接口多态(接口引用可以指向实现了接口的类的对象)
}
}
//输出:
// 手机开始工作……
//手机停止工作……
//===============
//相机开始工作……
//相机停止工作……
package interface_;
public class Computer {
//1、UsbInterface usbInterface形参是接口类型UsbInterface
//2、看到接收实现了UsbInterface接口的类的对象实例
public void work(UsbInterface usbInterface){
usbInterface.start();
usbInterface.stop();
}
}
package interface_;
//Phone类实现UsbInterface,要实现UsbInterface规定/声明的方法
public class Phone implements UsbInterface{
public void start(){
System.out.println("手机开始工作……");
}
public void stop(){
System.out.println("手机停止工作……");
}
}
package interface_;
public class Camera implements UsbInterface{
public void start(){
System.out.println("相机开始工作……");
}
public void stop(){
System.out.println("相机停止工作……");
}
}
向上转型等于很多设备用同一种接口,向下转型等于同一种设备用很多种接口
2、多态数组
//给Usb数组中,存放Phone和相机对象,Phone类还有一个特有的方法call()
//请遍历Usb数组,如果是Phone对象,除了调用Usb接口定义的方法外,
//特有方法call
package interface_;
public class InterfacePolyArr {
public static void main(String[] args) {
//多态数组———》接口类型数组
Usb[] usbs=new Usb[2];
usbs[0]=new Phone_();
usbs[1]=new Camera_();
for(int i=0;i<usbs.length;i++){
usbs[i].work();//动态绑定
if(usbs[i] instanceof Phone_){//判断运行类型
((Phone_) usbs[i]).call();//向下转型
}
}
}
}
interface Usb{
void work();
}
class Phone_ implements Usb{
public void call(){
System.out.println("手机可以打电话……");
}
public void work(){
System.out.println("手机工作中……");
}
}
class Camera_ implements Usb{
public void work(){
System.out.println("相机工作中……");
}
}
//输出:
//手机工作中……
//手机可以打电话……
//相机工作中……
3、接口存在多态传递现象
package interface_;
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向,实现了该接口的类的对象实例
IG ig=new Teacher();
IH ih=new Teacher();
}
}
interface IH{
void hi();
}
interface IG extends IH{}
class Teacher implements IG{
@Override
public void hi() {
}
}
六、练习题
package interface_;
public class InterfaceExercise02 {
}
interface A{
int x=0;
}
class B{
int x=1;//普通属性
}
class C extends B implements A{
public void pX(){
//System.out.println(x);//错误,x指定不明确,要明确指定x
System.out.println(A.x+" "+super.x);//输出:0 1
}
public static void main(String[] args) {
new C().pX();
}
}