1. 接口部分接上
2. 接口细节01 405
1)接口不能被实例化
2)接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰图示:
3) 一个普通类实现接口,就必须将该接口的所有方法都实现。
4)抽象类实现接口，可以不用实现接口的方法。
代码在com.stulzl.interface_detalil.包中
InterfaceDetail01
package com.stulzl.interface_detalil;
//接口细节01 405
public class InterfaceDetail01 {
public static void main(String[] args) {
//IA ia = new IA();//错误，接口不能被实例化
}
}
interface IA{
//接口不能被实例化
//接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰
void say();//public 和 abstract可以不写，因为是默认的
void hi();
}
//一个普通类实现接口,就必须将该接口的所有方法都实现。
class Cat implements IA{//可以使用快捷键Alt+enter
@Override
public void say() {
}
@Override
public void hi() {
}
}
//抽象类实现接口，可以不用实现接口的方法。
abstract class Tiger implements IA{
}3. 接口细节02 406
5)一个类同时可以实现多个接口[举例]
6)接口中的属性，只能是final的，而且是public static final修饰符。比如:int a=1;实际上是public static final int a=1; (必须初始化)
7)接口中属性的访问形式:接口名.属性名
8)接口不能继承其它的类，但是可以继承多个别的接口[举例]
9)接口的修饰符只能是public和默认，这点和类的修饰符是一样的。
代码在com.stulzl.interface_detalil02.包中
InterfaceDetail02
package com.stulzl.interface_detalil02;
//接口细节01 406
public class InterfaceDetail02 {
public static void main(String[] args) {
//证明 接口中的属性,是 public static final修饰的
System.out.println(IB.n1);//可以直接通过名字调用，说明 n1 就是 static
//IB.n1 = 30; //n1不能被修改，说明 n1 是 final
}
}
interface IB{
//接口中的属性，只能是final的，而且是public static final修饰符。
int n1 = 10;//等价 public static final int n1 = 10;
void hi();
}
interface IC{
void say();
}
//接口不能继承其它的类，但是可以继承多个别的接口
interface ID extends IB,IC{
}
//接口的修饰符只能是public和默认，这点和类的修饰符是一样的
interface IE{
}
//一个类同时可以实现多个接口
class Pig implements IB,IC{
@Override
public void hi() {
}
@Override
public void say() {
}
}4. 练习
4.1 判断输出 407
代码在com.stulzl.interface_exercise01.包中
InterfaceExercise01
package com.stulzl.interface_exercise01;
public class InterfaceExercise01 {
public static void main(String[] args) {
B b=new B();//ok
System.out.println(b.a); //23
System.out.println(A.a); //23
System.out.println(B.a); //23
}
}
interface A {
int a = 23; //等价public static final int a = 23;
}
class B implements A {//正确
}5. 接口和继承的比较 408
小结: 当子类继承了父类，就自动的拥有父类的功能
如果子类需要扩展功能，可以通过实现接口的方式扩展.
可以理解 实现接口 是 对 java 单继承机制的一种补充
接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性。
接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。即
更加的灵活..
接口比继承更加灵活
接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足like - a的关系。
接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制]
让猴子学会爬树，游泳，飞翔
代码在com.stulzl.extends_vs_interface.包中
ExtendsVsInterface
package com.stulzl.extends_vs_interface;
//接口VS继承 408
//让猴子学会爬树，游泳，飞翔
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey wukong = new LittleMonkey("悟空");
wukong.climbing(); //爬树通过继承父类方法
wukong.swimming(); //游泳通过实现鱼儿接口
wukong.flying(); //飞翔通过实现鸟儿接口
}
}
//小结: 当子类继承了父类，就自动的拥有父类的功能
// 如果子类需要扩展功能，可以通过实现接口的方式扩展.
// 可以理解 实现接口 是 对 java 单继承机制的一种补充
class Monkey{//父类
private String name;
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(name+" 会爬树……");
}
}
//提供一个鱼儿接口
interface Fishable{
void swimming();
}
//提供一个鸟儿接口
interface Birdable{
void flying();
}
//继承
class LittleMonkey extends Monkey implements Fishable,Birdable{
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println(getName()+"通过学习，可以像鱼儿一样游泳了……");
}
@Override
public void flying() {
System.out.println(getName()+"通过学习，可以像鸟儿一样飞翔了……");
}
}6. 接口的多态特性
6.1 多态参数(前面案例体现) 409
在前面的Usb接口案例，UsbInterface usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)
代码在com.stulzl.interface_poly.包中
InterfacePolyParameter
package com.stulzl.interface_poly;
//接口多态参数 409
public class InterfacePolyParameter {
public static void main(String[] args) {
//接口的多态体现
//接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
IF if01 = new Monster();
if01 = new Car();
//继承体现的多态
//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
AAA a = new BBB();
a = new CCC();
}
}
interface IF{
}
class Monster implements IF{
}
class Car implements IF{
}
class AAA{
}
class BBB extends AAA{
}
class CCC extends AAA{
}6.2 接口多态数组 409
演示一个案例:给Usb数组中，存放Phone和相机对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call.
代码在com.stulzl.interface_polyarr.包中
InterfacePolyArr
package com.stulzl.interface_polyarr;
//接口多态数组
//演示一个案例:给Usb数组中，存放Phone和相机对象，Phone类还有一个特有的方法call()， 409
//请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call.
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){//进行运行类型判断，编译类型是Usb 运行类型是Phone
Phone phone = (Phone)usbs[i];//向下转型
phone.call();
}
}
}
}
interface Usb{//接口
void work();
}
class Phone implements Usb{
@Override
public void work() {
System.out.println("手机工作中……");
}
//手机方法
public void call(){
System.out.println("手机可以打电话……");
}
}
class Camera implements Usb{
@Override
public void work() {
System.out.println("相机工作中……");
}
}6.3 接口存在多态传递现象 410
代码在vcom.stulzl.interface_polypass.包中
InterfacePolyPass
package com.stulzl.interface_polypass;
//接口多态传递 410
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向，实现了该接口的类的对象实例
IG ig = new Teacher();
//如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口
//那么，实际上就相当于 Teacher 类也实现了 IH 接口.
//这就是所谓的 接口多态传递现象
IH ih = new Teacher();
}
}
interface IH{
}
interface IG extends IH{
}
class Teacher implements IG{
}7. 判断输出 411
代码在com.stulzl.interface_exercise.包中
InterfaceExercise
package com.stulzl.interface_exercise;
//接口练习
public class InterfaceExercise {
public static void main(String[] args) {
new C().pX();// 0 1
}
}
interface A { // 1min 看看
int x = 0;//想到 等价 public static final 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);
}
}
