接口
简单介绍
1.1 概念
接口是java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
如果一个类中完全是由全局常量（static final）和抽象方法组成，就可以将其定义成一个接口
接口来的目的就是为了突破Java单继承的局限性。
接口的好处：灵活，可以同时使用多个接口的功能。
接口主要体现的是 一套开发规范。
1.2 特点
- 接口中都是抽象方法
- 通过interface关键字创建接口
- 通过implements让子类来实现
- 可以理解成，接口就是一个特殊的抽象类
- 接口突破了java的单继承的局限性
- 接口和类之间可以多实现，接口和接口之间可以多继承
- 接口是对外暴露的规则，是一套开发规范
- 接口提高了程序的功能扩展，降低了耦合性
1.3入门案例
package cn.tedu.oop;
//测试 接口
public class Test1_Interface {
public static void main(String[] args) {
//TODO 创建多态对象测试
//9,接口可以被实例化吗?--不可以,接口和抽象类一样都不能被实例化
// new Demo()
//8,用了接口里的抽象方法的声明,实现类的方法体
Demo demo = new DemoImpl();
demo.eat();
demo.game();
demo.hi();
}
}
//1,抽象类里可以有抽象方法(必须被abstract修饰),也可以有普通方法(提供方法体)
//3,通过interface关键字定义接口,语法:interface 接口名
interface Demo{
//2,接口里的方法都是抽象方法
abstract public void eat() ;
abstract public void game() ;
//4,在jdk1.8里允许接口中出现普通方法,要求被static或者default修饰
// static public void hi() {}
// default public void hi() {}
//5,接口为方法的编写提供了简写方式,会自动拼接 public abstract
// public abstract void hi() ;
void hi() ;//简写形式
}
//6,如果想用接口里的功能,怎么用呢?--和接口发生实现关系
//class Dog extends Animal{//继承时,是子类继承抽象类,来使用抽象类的功能
class DemoImpl implements Demo{//现在是,实现类 实现 接口,来使用接口的功能
//7,实现接口后,由于接口里都是抽象方法,所以需要全都重写,否则就是一个抽象类
@Override
public void hi() {
System.out.println("hi()...");
}
@Override
public void eat() {
System.out.println("eat()...");
}
@Override
public void game() {
System.out.println("game()...");
}
}
//abstract class DemoImpl implements Demo{//现在是,实现类 实现 接口,来使用接口的功能2.接口的用法
1.接口必须有子类，子类依靠implements关键字可以同时实现多个接口。
2.接口的子类（如果不是抽象类）必须实现接口之中的全部抽象方法。
3.接口可以利用对象多态性，利用子类实现对象的实例化。
4.接口和普通的类一样，本身也有数据成员和方法，但数据成员一定要初始赋值，并且此值不能再有修改，定义的方法可以有抽象方法和默认方法，抽象方法abstact关键字可以省略，默认方法需要带上default关键字，默认方法可以带有方法体。
5.默认方法的调用和普通方法的调用一样
2.1 用法测试
package cn.tedu.oop;
//测试 接口
//总结
//接口里没有构造方法/没有变量都是常量
//接口里都是抽象方法(jdk1.8可以有特殊的普通方法)
//接口里的常量可以简写,会自动拼接public static final
//接口里的方法可以简写,会自动拼接public abstract
public class Test2_Interface2 {
public static void main(String[] args) {
//3,接口不能被实例化
Inter in = new InterImpl();
//in.age = 20; //修改值,失败---age是final的
System.out.println( in.age );//获取值
System.out.println( Inter.age );//获取值,age是static的
//TODO 7,测试接口里的方法
String desc = in.save();
System.out.println(desc);
in.delete(10);
}
}
//0,通过interface定义接口
interface Inter{
//1,接口里不让出现构造方法.Interfaces cannot have constructors
// public Inter() { }
//2,接口里没有变量!!! -- 会自动拼接public static final把变量变成常量!!
//public static final int age = 10;
int age = 10 ; //简写形式
//4,接口里的方法--会自动拼接public abstract
// public abstract void save() ;
// public abstract void delete() ;
String save() ;//简写形式
void delete(int id) ;
}
//5,接口的实现类,要么重写所有抽象方法,要么是一个抽象类
//abstract class InterImpl implements Inter{
class InterImpl implements Inter{
//6,在进行方法重写时,要有足够的权限.接口里的所有资源默认的权限都是public
@Override
public String save() {
return "保存成功!" ;
}
@Override
public void delete(int id) {
System.out.println("delete()..."+id);
}
} 3 接口的复杂用法
接口和类之间可以多实现，接口和接口之间可以多继承
测试
import java.io.Reader;
//测试 接口的复杂用法
//接口和类之间可以多实现，接口和接口之间可以多继承
public class Test3_Interface3 {
public static void main(String[] args) {
//4,--2号接口的功能,接口那么多,想用谁的功能,左边就写谁
Inter2 in = new Inter2Impl() ;
in.update();
in.save();
in.delete(5);
in.get();
}
}
interface Inter1{
void save();
}
interface Inter3{
void update();
void get();
}
//5,实现类可以在继承的同时,多实现
abstract class Impl2 extends Object implements Inter1 , Inter3{
}
//3,接口和实现类之间 -- 是实现关系 ,可以多实现(逗号隔开)
//--Impl实现类,同时实现了Inter1和Inter3接口的功能,
//--需要同时重写多个抽象方法,否则就是一个抽象类
class Impl implements Inter1 , Inter3{
@Override
public void update() {
}
@Override
public void get() {
}
@Override
public void save() {
}
}
//1,接口和接口之间 -- 是继承关系,可以多继承(逗号隔开)
//--2号接口同时使用了1号和3号接口的功能!
interface Inter2 extends Inter1 , Inter3{
void delete(int id) ;
}
//2,想要使用2号接口的功能,找一个实现类来实现接口
class Inter2Impl implements Inter2{
@Override
public void save() {
System.out.println(1);
}
@Override
public void update() {
System.out.println(2);
}
@Override
public void get() {
System.out.println(3);
}
@Override
public void delete(int id) {
System.out.println(4);
}
}4 总结
1.类和类之间的关系是:继承关系
java里只支持单继承
class A extends B
其中A是子类,B是父类.子类可以使用父类的所有功能。
方法的重写override:如果想要修改父类的原有功能,可以进行方法重写。
2.接口和接口之间的关系：是继承关系
接口的出现就是为了突破java单继承的局限性。
接口间可以多继承。
interface A extends B , C
其中A是子接口,B和C是父接口。
A就拥有了B和C的所有功能,A的功能是最全的。
class Impl implements A
Impl实现类就需要同时重写A B C 接口里的所有抽象方法,否则就是一个抽象类。
3.类和接口之间的关系：是实现关系
实现类可以实现接口,而且可以多实现
class A implements B,C
A是实现类,B和C是接口.
A需要同时重写B和C接口里的所有抽象方法,否则就是一个抽象类
类可以在继承的同时多实现
class A extends B implements C , D
A可以叫子类,也可以叫是实现类
A同时拥有父类B的功能,也同时拥有接口C和D的功能
A需要同时重写C和D接口里的所有抽象方法,否则就是一个抽象类
对于父类B里的方法吗?看需求,B类是父类,里面如果都是普通方法,只有需要修改才会发生重写。
4.接口和抽象类的区别
相同点
抽象类和接口都是抽象层，一般用来提取共性
两者都不能被实例化
不同点
构造方法：抽象类里有，接口里没有！
成员变量:抽象类里有,接口里没有,接口里都是常量。
成员方法:抽象类可以有普通方法和抽象方法,但是接口里都是抽象方法(jdk1.8以后可以有)
接口存在简写形式,抽象类里没有
接口里的常量,int age= 10;会自动拼接public static final
接口里的方法,void save(),会自动拼接public abstract
怎么去设计你的抽象层，到底是体现为一个抽象类还是接口？
关键就看你需不需要提供方法体，如果类里的方法都不需要提供方法体，可以设计为接口，如果类里的方法需要提供方法，设计为抽象类。
抽象层到底设计为抽象类好还是接口好
如果实现类想要同时拥有多个功能，最好选择接口，因为接口可以多继承多实现。
如果就是设计为抽象类，子类就只能继承一个父类，只有一次的继承权。
5 程序设计
需求：
具体事务：培优班老师，高手班老师
共性：备课，讲课
测试：常见多态对象测试
分析：
利用面向接口编程的设计思想
1.把子类见的共性功能，向上提取，形成父类
2.要不要把父类修饰成抽象层，看程序设计的结果--抽象层可以是抽象类也可以是接口
3.如果抽象层都是抽象方法，直接设计为接口
4.如果抽象成还需要普通方法，那就设计成抽象类
package cn.tedu.oop;
interface Teacher {
void ready() ;
void teach() ;
}
--ActTeacher类
package cn.tedu.oop;
//描述培优班老师的事物
//共性:备课 / 讲课
public class ActTeacher implements Teacher{
public void ready() {
System.out.println("高手班老师正在 备课");
}
public void teach() {
System.out.println("高手班老师正在 讲课");
}
}
--CgbTeacher类
package cn.tedu.oop;
//描述培优班老师的事物
//共性:备课 / 讲课
//6,实现类实现了接口以后,需要重写所有抽象方法,否则就是抽象类
abstract public class CgbTeacher implements Teacher{
}
--测试类
package cn.tedu.oop;
//测试 程序设计
public class Test4_Design {
public static void main(String[] args) {
//接口和抽象类一样,不可以被实例化
// Teacher t = new Teacher();
//创建多态对象测试--多态体现的是调用标准
Teacher t = new ActTeacher() ;
//标准就是父类,只能用父类提供的功能
t.ready();
t.teach();
}
}