接口的基础语法
一、
- 接口也是一种“引用数据类型”。编译之后也是一个class字节码文件
- 接口是完全抽象的。（抽象类是半抽象）或者也可以说接口是特殊的抽象类
- 接口怎么定义？语法是什么？
[修饰符列表] interface 接口名{ } - 接口支持多继承，一个接口可以继承多个接口
- 接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。接口中没有其他内容了。
- 接口中所有的元素都是public修饰的（都是公开的）
- 接口中的抽象方法定义时：public abstract修饰符可以省略
- 接口中的常量的public static final可以省略
- 接口中的方法都是抽象方法，所以接口中的方法不能有方法体
public class Test01{
public static void main(String[] args){
// 访问接口的常量。
System.out.println(MyMath.PI);
// 常量能重新赋值吗？
//错误: 无法为最终变量PI分配值
//MyMath.PI = 3.1415928;
//错误: 无法为最终变量k分配值
//MyMath.k = 111;
}
}
//定义接口
interface A{
}
//接口支持继承
interface B extends A{
}
//一个接口可以继承多个接口（支持多继承）
interface C extends A,B{
}
//我的数学接口
interface MyMath{
// 常量
//public static final double PI = 3.1415926;
// public static final可以省略吗？可以
double PI = 3.1415926;
// k是不是常量？？？？是。
// 接口中随便写一个变量就是常量。
// 常量：值不能发生改变的变量。
int k = 100;
// 抽象方法
//public abstract int sum(int a, int b);
// 接口当中既然都是抽象方法，那么在编写代码的时候，public abstract可以省略吗？可以
int sum(int a, int b);
// 接口中的方法可以有方法体吗？
// 错误: 接口抽象方法不能带有主体
/*
void doSome(){
}
*/
// 相减的抽象方法
int sub(int a, int b);
}二、
- 类和类之间叫做继承，类和接口之间叫做实现
别多想：你仍然可以将“实现”看做“继承”。
继承使用extends关键字完成
实现使用implements关键字完成。 - 【重点】：当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）
public class Test02{
public static void main(String[] args){
//错误: MyMath是抽象的; 无法实例化
//new MyMath();
// 能使用多态吗？可以。
//Animal a = new Cat();
// 父类型的引用指向子类型的对象
MyMath mm = new MyMathImpl();
// 调用接口里面的方法（面向接口编程。）
int result1 = mm.sum(10, 20);
System.out.println(result1);
int result2 = mm.sub(20, 10);
System.out.println(result2);
}
}
// 特殊的抽象类，完全抽象的，叫做接口。
interface MyMath{
double PI = 3.1415926;
int sum(int a, int b);
int sub(int a, int b);
}
// 这样没问题
/*
abstract class MyMathImpl implements MyMath {
}
*/
// 编写一个类（这个类是一个“非抽象”的类）
// 这个类的名字是随意的。
//错误: MyMathImpl不是抽象的, 并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class MyMathImpl implements MyMath {
}
*/
//修正
class MyMathImpl implements MyMath {
//错误：正在尝试分配更低的访问权限; 以前为public
/*
int sum(int a, int b){
return a + b;
}
*/
// 重写/覆盖/实现 接口中的方法（通常叫做实现。）
public int sum(int a, int b){
return a + b;
}
public int sub(int a, int b){
return a - b;
}
}三、
- 接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？
对于计算机来说，一个机箱上有多个接口，一个接口是连接键盘的，一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的… - 【重点】：一个类可以同时实现多个接口。
这种机制弥补了java中的哪个缺陷？
java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中存在多继承，java中的接口弥补了单继承带来的缺陷。
接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。
编译器没意见。但是运行时可能出现：ClassCastException
之前有一个结论：
无论向上转型还是向下转型，两种类型之间必须要有继承关系，
没有继承关系编译器会报错。（这句话不适用在接口方面。）
最终实际上和之前还是一样，需要加：instanceof运算符进行判断。
向下转型养成好习惯。转型之前先 if + instanceof 进行判断。
public class Test03{
public static void main(String[] args){
// 多态该怎么用呢？
// 都是父类型引用指向子类型对象
A a = new D();
//a.m2(); // 编译报错。A接口中没有m2()方法。
B b = new D();
C c = new D();
// 这个编译没问题，运行也没问题。
// 调用其他接口中的方法，你需要转型（接口转型。）
B b2 = (B)a;
b2.m2();
// 直接向下转型为D可以吗？可以
D d = (D)a;
d.m2();
M m = new E();
// 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
// 但是一定要注意，运行时可能会出现ClassCastException异常。
// 编译没问题，运行有问题。
//K k = (K)m;
if(m instanceof K){
K k = (K)m;
}
}
}
interface K{
}
interface M{
}
class E implements M{
}
// --------------------------------------------------------------------
interface X{
}
interface Y{
}
interface Z extends X,Y{ //接口和接口支持多继承。
}
//------------------------------------------------------------------
interface A{
void m1();
}
interface B{
void m2();
}
interface C{
void m3();
}
// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
// 实现A接口的m1()
public void m1(){
}
// 实现B接口中的m2()
public void m2(){
System.out.println("m2 ....");
}
// 实现接口C中的m3()
public void m3(){
}
}继承和实现都存在的话，代码应该怎么写？
extends 关键字在前
implements 关键字在后
public class Test04{
public static void main(String[] args){
// 创建对象（表面看Animal类没起作用！）
Flyable f = new Cat(); //多态。
f.fly();
// 同一个接口
Flyable f2 = new Pig();
// 调用同一个fly()方法，最后的执行效果不同。
f2.fly();
Flyable f3 = new Fish();
f3.fly();
}
}
// 动物类：父类
class Animal{
}
// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
void fly();
}
// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
public void fly(){
System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
}
}
// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class Snake extends Animal{
}
// 想飞就插翅膀这个接口。
class Pig extends Animal implements Flyable{
public void fly(){
System.out.println("我是一只会飞的猪！！！");
}
}
// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{ //没写extends，也是有的，默认继承Object。
public void fly(){
System.out.println("我是六眼飞鱼（流言蜚语）！！！");
}
}接口的基础语法 总结：
- 接口是一种“引用数据类型”
- 接口是完全抽象的
- 接口怎么定义：[修饰符列表] interface 接口名{ }
- 接口支持多继承
- 接口中只有常量+抽象方法
- 接口中所有的元素都是public修饰的
- 接口中抽象方法的public abstract可以省略
- 接口中常量的public static final可以省略
- 接口中方法不能有方法体
- 一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现
- 一个类可以是想多个接口
- extends和implements可以共存，extends在前，implements在后
- 使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）
接口在开发中的作用
注意：接口在开发中的作用，类似于多态在开发中的作用
多态：面向抽象编程，不要面向具体编程。降低程序的耦合度，提高程序的扩展力
/*
public class Master{
public void feed(Dog d){}
public void feed(Cat c){}
//假设又要养其它的宠物，那么这个时候需要再 加1个方法。（需要修改代码了）
//这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
}
*/
public class Master{
public void feed(Animal a){
// 面向Animal父类编程，父类是比子类更抽象的。
//所以我们叫做面向抽象编程，不要面向具体编程。
//这样程序的扩展力就强。
}
}接口在开发中的作用？
接口是不是完全抽象的？是
而我们以后正好要求，面向抽象编程
面向抽象编程这句话以后可以修改为：面向接口编程
有了接口就有了可插拔。可插拔表示扩展力很强，不是焊接死的。
主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来。这叫做高扩展性（低耦合度）
接口在现实世界中是不是到处都是呢？
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范）
接口是一个抽象的概念
分析：中午去饭馆吃饭，这个过程有接口吗？
接口是抽象的
菜单是一个接口（菜单上有一个抽象的照片：西红柿炒鸡蛋）。
谁面向接口调用（顾客面向菜单点菜，调用接口）。
谁负责实现这个接口（后台的厨师负责把西红柿炒鸡蛋做好！是接口的实现者）。
这个接口有什么用呢？？
这个饭馆的“菜单” ，让“顾客”和“后厨”解耦合了。
顾客不用找后厨，后厨不用找顾客，他们之间完全依靠这个抽象的菜单沟通。
/*
接口：菜单，抽象的
*/
public interface FoodMenu{
// 西红柿炒蛋
void shiZiChaoJiDan();
// 鱼香肉丝
void yuXiangRouSi();
}//西餐厨师
// 实现菜单上的菜
// 厨师是接口的实现者。
public class AmericCooker implements FoodMenu{
// 西红柿炒蛋
public void shiZiChaoJiDan(){
System.out.println("西餐师傅做的西红柿炒鸡蛋！");
}
// 鱼香肉丝
public void yuXiangRouSi(){
System.out.println("西餐师傅做的鱼香肉丝！");
}
}//中餐厨师
// 实现菜单上的菜
// 厨师是接口的实现者。
public class ChinaCooker implements FoodMenu{
// 西红柿炒蛋
public void shiZiChaoJiDan(){
System.out.println("中餐师傅做的西红柿炒鸡蛋，东北口味！");
}
// 鱼香肉丝
public void yuXiangRouSi(){
System.out.println("中餐师傅做的鱼香肉丝，东北口味！");
}
}// 顾客
//接口的调用者
public class Customer{
// 顾客手里有一个菜单
// Customer has a FoodMenu!（这句话什么意思：顾客有一个菜单）
// 记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在。
// 实例变量，属性
// 面向抽象编程，面向接口编程。降低程序的耦合度，提高程序的扩展力。
private FoodMenu foodMenu;
// 如果以下这样写，就表示写死了（焊接了。没有可插拔了。）
// 中餐厨师
//ChinaCooker cc;
// 西餐厨师
//AmericCooker ac
// 构造方法
public Customer(){
}
public Customer(FoodMenu foodMenu){
this.foodMenu = foodMenu;
}
// setter and getter
public void setFoodMenu(FoodMenu foodMenu){
this.foodMenu = foodMenu;
}
public FoodMenu getFoodMenu(){
return foodMenu;
}
// 提供一个点菜的方法
public void order(){
// 先拿到菜单才能点菜
// 调用get方法拿菜单。
//FoodMenu fm = this.getFoodMenu();
// 也可以不调用get方法，因为在本类中私有的属性是可以访问
foodMenu.shiZiChaoJiDan();
foodMenu.yuXiangRouSi();
}
}
/*
Cat is a Animal，但凡满足is a的表示都可以设置为继承。【我是你】
Customer has a FoodMenu，但凡是满足has a的表示都以属性的形式存在。【我中有你】
*/
/*
class Address{
String city;
String street;
String zipcode;
}
class User{
int id;
// 和这个一样。
// String是一个类。
// name是变量名。
// name是一个引用。
String name;
// Address是一个类名。
// 这就是一个变量。
// 实例变量。
Address addr; // addr是一个引用。是一个变量。
public static void main(String[] args){
// 局部变量
//Address addr;
//addr = new Address();
// 合并。
Address addr = new Address();
User u = new User();
u.id = 100;
u.name = "zhangsan";
u.addr = new Address();
System.out.println(u.addr.city); // null
System.out.println(u.addr.street); // null
System.out.println(u.addr.zipcode); // null
}
}
//“自己”类
// MySelf has a Friend;
//你是把你的朋友对象随身携带放在兜里
//还是说你保留一个朋友的电话号码
class MySelf{
// 你这个对象，应该有一个朋友对象的电话号码。
// 电话号码就是一个对象的内存地址。联系你朋友的时候，打电话。
// f是一个引用。f默认值是null，是null表示，你没有朋友。
Friend f;
public MySelf(){
}
//通过构造方法能不能给你一个朋友对象。
public MySelf(Friend f){
this.f = f;
}
public static void main(String[] args){
// 创建朋友对象
Friend f = new Friend(); //朋友对象有了
// 创建对象的同时交朋友。
MySelf m2 = new MySelf(f);
// 创建自己对象
// 目前还没有交朋友。
MySelf m = new MySelf(); //自己对象
// 交朋友
m.f = f; // 把朋友的地址给了你。
}
}
// “朋友”类
class Friend{
}
*/public class Test{
public static void main(String[] args){
// 创建厨师对象
//FoodMenu cooker1 = new ChinaCooker();
FoodMenu cooker1 = new AmericCooker();
// 创建顾客对象
Customer customer = new Customer(cooker1);
// 顾客点菜
customer.order();
}
}总结一句话：三个字”解耦合“
面向接口编程，可以降低程序的耦合度。提高程序的扩展力。符合OCP开发原则。
接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度）。
接口可以解耦合，解开的是谁和谁的耦合！！！
任何一个接口都有调用者和实现者。
接口可以将调用者和实现者解耦合。
调用者面向接口调用。
实现者面向接口编写实现。
上述的例子中，无论是AmericCooker、ChinaCooker还是Customer，这两方关心的都只是FoodMenu，所以说这里的FoodMenu接口就实现了分离的目的，假如说在实际开发中，由项目开发经理先把这个FoodMenu制定好，然后把Customer交给项目组A去做，把AmericCooker、ChinaCooker交给项目组B去做，两者不需要相互关心，这样就实现了多人进行协同开发，开发效率显著提高！！
以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接，降低耦合度。
类型和类型之间的关系：
is a（继承）、has a（关联）、like a（实现）
is a：
Cat is a Animal（猫是一个动物）
凡是能够满足is a的表示“继承关系”
A extends B
has a：
I has a Pen（我有一支笔）
凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b;
}
like a:
Cooker like a FoodMenu（厨师像一个菜单一样【不是长得像，比如你很有钱，你请一个私人厨师，你想吃什么都告诉厨师，厨师就像一个菜单一样，再比如司机像导航。自己理解理解】）
凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B抽象类和接口有什么区别？？？
在这里我们只说一下抽象类和接口在语法上的区别
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习
抽象类是半抽象的
接口是完全抽象的
抽象类中有构造方法
接口中没有构造方法
接口和接口之间支持多继承
类和类之间只能单继承
一个类可以同时实现多个接口
一个抽象类只能继承一个类（单继承）
接口中只允许出现常量和抽象方法
这里先透露一个信息：
以后接口使用的比抽象类多。一般抽象类使用的还是少。
接口一般都是对”行为“的抽象
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
