接口
接口的引出:USB
插槽是现实中的接口,可以把手机,相机,U盘都插入USB
插槽中,而不用担心那个插槽是专门插哪个的,原因是做了USB
插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸,排线等等。
接口的快速入门:
package JAVA面向对象高级部分.interface_;
public interface USBInterface {
//开始工作的方法
public abstract void start();
//结束工作方法
public abstract void stop();
}
package JAVA面向对象高级部分.interface_;
public class Phone implements USBInterface{//手机类
@Override
public void start() {
System.out.println("呵呵可以玩手机了。。。");
}
@Override
public void stop() {
System.out.println("想想就生气手机关机了。。。");
}
}
package JAVA面向对象高级部分.interface_;
public class Camera implements USBInterface{//相机类
@Override
public void start() {
System.out.println("相机开始工作了。。。");
}
@Override
public void stop() {
System.out.println("相机关机了。。。");
}
}
package JAVA面向对象高级部分.interface_;
public class Computer {//电脑类
public void work(USBInterface usbInterface){
usbInterface.start();
usbInterface.stop();
}
}
接口的基本介绍
接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。
接口定义语法:
interface 接口名{ //属性 //方法【1.抽象方法 2.默认实现方法 3.静态方法】 }
接口实现语法:
class 类名 implements 接口{
自己属性
自己方法
必须实现的接口的抽象方法
}
小结:(必须记住)
- 在
jdk7.0
前接口里的所有方法都没有方法体,即都是抽象方法 - 在
jdk8.0
后接口可以有静态方法,默认方法default
修饰,也就是说接口中可以有方法具体实现
package JAVA面向对象高级部分.interface_.intterface01;
public class TestInterface01 {
public static void main(String[] args) {
}
}
interface A {
//在接口中可以有自己的属性和抽象方法
//属性
public int num = 10;
//抽象方法,在接口中抽象方法的abstract可以省略
public void show();
//在jdk8.0后接口可以有静态方法,默认方法,也就是说接口中可以有方法具体实现
//在jdk8.0后接口可以有静态方法或默认方法(默认方法要用default修饰)
//静态方法
public static void print(){
System.out.println("我是中国人!!!");
}
//默认方法
default public void hi(){
System.out.println("您好吗?");
}
}
注意事项和细节说明:(九点细节必须记住)
1.接口不能被实例化
2.接口中所有方法是public
修饰的可以省略,接口中的抽象方法,可以不用abstract
修饰
3.一个普通类实现接口,就必须将该接口的所有方法都实现
4.抽象类实现接口,可以不用实现接口的方法
5.一个类同时可以实现多个接口
6.接口中的属性,只能是final
的,而且是public static final 修饰符的
。比如:int a = 1;
实际上是public static final int a = 1;
[必须初始化]
7.接口中属性的访问形式:接口名.属性名
8.接口不能继承其它的类,但是可以继承多个别的接口,接口可以是多继承关系
interface X extends Animal,Usb, USBInterface{}
- 类与类是继承关系,类与类是单继承关系
- 类与接口是实现关系,类可以实现多个接口
- 接口与接口是继承关系,接口与接口可以是多继承关系
9.接口的修饰符,只能是public
和默认的,这和类的修饰符是一样的
package JAVA面向对象高级部分.interface_;
//细节说明
//1.接口是不能实例化的【不能创建对象和抽象类一样】
//2.接口中所有的方法都是public修饰的,接口中的抽象方法,可以不用abstract修饰
//3.普通类实现接口,就要必须实现接口中所有方法
//4.抽象类实现接口,可以不用实现接口的方法
public interface Animal {
//接口中所有方法都是用public修饰的,接口中的抽象方法可以不用abstract修饰【意思是public和abstract可以省略】
void soy();//注意可以省略public 和 abstract
//接口中的属性,只能是final的,而且是public static final的
//下面的语句其实是:public static final int a = 1;
int a = 1;
}
abstract class Cat implements Animal {}//4.说明抽象实现接口可以不用实现接口中的方法
练习题目:
interface A {
int a = 23;
}
class B implements A {}
在main方法中
B b = new B();
System.out.println("b.a");
System.out.println("A.a");
System.out.println("B.a");
语法是否正确,如果正确,输出什么?
全部正确,都是输出:23
实现接口VS继承类
可以将接口理解为一种规范的制定和继承的补充机制
接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性
接口的价值主要在于:设计,设计好各种规范(方法),让其它类去实现这些方法。即更加的灵活
接口比继承更加灵活
接口比继承更加灵活,继承是满足is - a
的关系,而接口只需要满足like - a
的关系
接口在一定程度上实现代码解耦【即:接口规范性+动态绑定机制】
package JAVA面向对象高级部分.interface_.interface02;
public class ExtendsVSInterface {
public static void main(String[] args) {
LittleMonkey li = new LittleMonkey("孙悟空");
li.flying();
li.swimming();
li.climbing();
}
}
/**
* 小结 :当子类继承了父类,就自动的拥有了父类的功能
* 如果子类需要扩展功能,可以通过实现接口的方式扩展
* 可以理解实现接口 是对java单继承机制的一种补充
*/
class Monkey {//猴子
private String name;
public Monkey() {
}
public Monkey(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void climbing(){
System.out.println(getName()+"会上树");
}
}
//鱼
interface Fish {
void swimming();//游泳
}
//鸟
interface Bird {
void flying();//飞翔
}
//小猴子
class LittleMonkey extends Monkey implements Bird,Fish{
public LittleMonkey() {
}
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println("猴子会游泳了。。。");
}
@Override
public void flying() {
System.out.println("猴子会飞翔了。。。");
}
}
接口的多态特性
-
多态参数【前面案例体现】,在前面的
USB
接口案例,USBInterface usb
,即可以接收手机对象,又可以接收相机对象,就体现了接口多态【接口引用可以指向实现了接口的类对象】package JAVA面向对象高级部分.interface_; public class InterfacePolyParameter { public static void main(String[] args) { //接口的多态体现,接口类型的变量myInterface可以指向 实现了myClass接口类的对象实例 //就是父类引用指向子类对象【多态的参数的体现和前面Usb接口案例一样】 myInterface myInterface = new myClass(); } } //接口的多态体现 interface myInterface{} //具体类实现接口 class myClass implements myInterface{}
-
多态数组
InterfacePolyArr.java
演示一个案例,给
Usb
数组中,存入Phone
和相机对象,Phone
类还有一个特有的方法call()
,请遍历Usb
数组,如果是Phone
对象,除了调用Usb
接口定义方法外,还需要调用Phone
特有方法call()
package JAVA面向对象高级部分.interface_.interface03; public class InterfacePolyArr { public static void main(String[] args) { //多态数组 Usb[] usb = new Usb[2]; usb[0] = new Phone(); usb[1] = new Camera(); for (int i = 0; i < usb.length; i++) { //调用Usb接口中的work方法 usb[i].work(); //调用手机特有方法 if (usb[i] instanceof Phone){ Phone phone = (Phone) usb[i]; phone.call(); } } } } //Usb接口 interface Usb{ //省略了public和static关键字 void work(); } //Phone类 class Phone implements Usb { @Override public void work() { System.out.println("手机工作"); } //手机类特有的方法 public void call(){ System.out.println("手机可以打电话。。。"); } } //Camera相机类 class Camera implements Usb { @Override public void work() { System.out.println("相机可以拍照了。。。呵呵!!!"); } }
-
接口存在多态传递现象
InterfacePolyPass.java
package JAVA面向对象高级部分.interface_.interface04;
/**
* 接口的多态传递现象
*/
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向,实现了该接口的类对象的引用实例【相当于父类指向子类引用】
Father father = new Son();
//如果Father继了GrandPa接口,而Son实现了Father接口
//那么,实际上就相当于Son类也实现了GrandPa接口
//下面就是所谓的接口多态传递现象
Grandpa grandpa = new Son();
}
}
interface Grandpa { }
interface Father extends Grandpa{ }
class Son implements Father{ }
练习题目 (必须重点理解下面练习题目)
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
//访问接口的 X 就使用A.X
//访问父类的 X 就使用super.X
System.out.println(A.x+" "+super.x)
}
public static void main(String[] args){
new C().pX();
}
}
代码有没有错误,有错误就改正,看看输出结果?
有错误,接口也父类都有一个同名的X,造成了不知道使用是接口的还是父类的X
改正如上面: