零基础学Java,肝了bilibili的6百多集JavaSE教程传送门的学习笔记!!!
下面博客分为两部分:
- ① 接口的要点(想快速了解接口的小伙伴选择)
- ② 案例代码,对①中的知识点进行解释(需要再花费5分钟学习的小伙伴选择)
一、接口的要点
接口的基础语法
1、接口是一种 "引用数据类型" 。
2、接口时完全抽象的。
3、接口这么定义:[修饰符列表] interface 接口名 {}
4、接口支持多继承。
5、接口中只有:常量+抽象方法。
6、接口中所有的元素都是public修饰的。
7、接口中的抽象方法定义时:public abstract可以省略。
8、接口中的变量定义时:public static final可以省略。
9、接口中的方法不能有方法体。
10、一个非抽象的类实现接口需要将接口中所以方法加以实现。
11、一个类可以实现多个接口。
12、extends和implements可以同时使用。extends在前,implements在后。
13、使用接口写代码的时候,可以使用多态。(父类型引用指向子类型对象)
接口在开发中的作用
类似于多态在开发中的作用 ---> 解耦合。
多态:面向抽象编程,不要面向具体编程。减低程序的耦合度。提高程序的扩展力。
符合OCP开发原则。
接口的进一步理解:类和类的关系
is a: 继承关系
Cat is a Animal.
has a: 关联关系
I has a pen.
like a: 实现关系
Cooker like a FoodMenu.(厨师像一个菜单,功能的"像")
抽象类和接口的区别:
这里只解释下语法上的区别。
抽象类是半抽象的。
接口是完全抽象的。
抽象类中有构造方法。
接口中没有构造方法。
类和类之间只能单继承。
接口和接口之间支持多继承。
一个类可以同时实现多个接口。
一个抽象类只能继承一个类(单继承)。
接口中只允许出现常量和抽象方法。
二、案例代码
1、接口的基础语法
① InterfaceTest.java
public class InterfaceTest {
public static void main(String[] args) {
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 {
}
② InterfaceTest01
接口的基础语法:
- 1、接口是一次 “引用数据类型” 。接口编译之后也是一个class字节码文件
- 2、接口是完全抽象的,(抽象类是半抽象)或者说接口是特殊的抽象类。
- 3、接口这么定义呢?
语法:
[修饰符列表] interface 接口名 {
}
- 4、接口支持多继承,一个接口可以继承多个接口。
- 5、接口中只包含两部分内容,一部分是:常量;一部分是:抽象方法。
接口中没有其它内容。只有以上两部分 - 6、接口中所有的元素都是public修饰的。
- 7、接口中的抽象方法定义时:public abstract可以省略。
- 8、接口中的变量定义时:public static final可以省略。
接口中随便写的变量就是常量。 - 9、接口中的方法都是抽象方法,所以接口中的方法不能有方法体。
public class InterfaceTest01 {
public static void main(String[] args) {
System.out.println("A.PI: " + A.PI);
System.out.println("A.ID:" + A.ID);
}
}
interface A {
public static final double PI = 3.1415926;
double ID = 2018217213.0901;
public abstract int doSome();
public int doOther();
int move();
}
interface B extends A {
}
interface C extends A, B {
}
③ InterfaceTest02.java
接口的基础语法2:
- 类和类之间叫做继承,类和接口之间叫做实现,也可以把实现看成一种继承
- 继承使用extend关键字完成
- 实现使用implements关键字完成
public class InterfaceTest02 {
public static void main(String[] args) {
// 能使用多态吗?可以。
// 父类型的引用指向子类型的对象。
MyMath mm = new MyMathImpl();
// 调用接口里面的方法(面向接口编程)
int result1 = mm.sum(2,2);
int result2 = mm.sub(1,2);
System.out.println("result1: " + result1 + " result2: " + result2);
// 编译时,编译器看接口里有没有该方法,有就编译通过。
// 运行时,调用子类里的方法。
}
}
interface MyMath {
double PI = 3.1415926;
int sum(int a, int b);
int sub(int a, int b);
}
// 非抽象类
class MyMathImpl implements MyMath {
// 方法前面的public不能省略。
// 编译报错:正在尝试分配更低的访问权限;以前是public(接口)。
// 继承的子类里,元素的访问权限只能更高、不能更低。
@Override
public int sum(int a, int b) {
return a + b;
}
@Override
public int sub(int a, int b) {
return a - b;
}
}
abstract class MyMath2 implements MyMath {
// 不需要实现接口中的抽象方法。
}
④ InterfaceTest03.java
接口和接口之间支持多继承,那么一个类可以同时实现多个接口吗?
可以,一个类可以同时实现多个接口。
这种机制弥补了Java中的那些缺陷?
Java中类和类只支持单继承。
实际上单继承是为了简单而出现的,现实世界中存在多继承,
Java中的接口弥补了单继承带来的缺陷。
之前的学习中有一个结论:
无论向上转型还是向下转型,两种类型之间必须要有继承关系,没有继承关系编译器会报错。(但这句话不适应在接口方面)
最终实际上和之前一样,需要加:instanceof运算符进行判断。
建议:
养成向下转型好习惯。转型之前先if+instanceof进行判断。
public class InterfaceTest03 {
public static void main(String[] args) {
// 多态该怎么用呢?
// 都是父类型引用指向子类型对象。
Test1 test1 = new Test4();
Test2 test2 = new Test4();
Test3 test3 = new Test4();
// test1.m2(); // 编译报错,Test1接口里没有m2()方法
Test2 t2 = (Test2) test1; // 要想调用其它接口中的方法,需要转型(接口转型。)
t2.m2();
}
}
interface Test1 {
void m1();
}
interface Test2 {
void m2();
}
interface Test3 {
void m3();
}
class Test4 implements Test1, Test2, Test3 {
@Override
public void m1() {
System.out.println("m1()");
}
@Override
public void m2() {
System.out.println("m2()");
}
@Override
public void m3() {
System.out.println("m3()");
}
}
⑤ InterfaceTest04.java
继承和实现都存在时:
extends 关键字在前,mplements 关键字在后(代码规范)
public class InterfaceTest04 {
public static void main(String[] args) {
// 创建对象 (表面看Animal类没起作用!)
Flyable cat = new Cat();
cat.fly();
Flyable pig = new Pig();
pig.fly();
}
}
class Animal {
}
// 接口通常提取的是行为动作。
interface Flyable {
void fly();
}
// 会飞的猫类
class Cat extends Animal implements Flyable {
@Override
public void fly() {
System.out.println("会飞的猫!");
}
}
// 飞猪
class Pig extends Animal implements Flyable {
@Override
public void fly() {
System.out.println("这是一只飞猪!");
}
}
2、接口在开发中的作用
写代码的建议
Cat is a Animal, 满足 "is a" 的表示都可以设置为继承。
Customer has a FoodMenu, 但凡是满足 "has a" 的表示都以属性的形式存在。
写这些代码就是要表示,使用接口抽象编程,降低程序耦合度,提高程序扩展力。
接口的使用离不开多态(接口+多态-->降低程序耦合度)
接口可以解耦合(调用者和实现者),所以在设计的时候要考虑要两者之间的关系。
调用者是面向接口调用。
实现者面向接口编写实现。
① FoodMenu
public interface FoodMenu {
void XiHongShichaoJiDan();
void YuXiangRouSi();
}
② ChinaCooker、AmericanCooker
public class ChinaCooker implements FoodMenu {
@Override
public void XiHongShichaoJiDan() {
System.out.println("中国厨师做的西红柿炒鸡蛋。");
}
@Override
public void YuXiangRouSi() {
System.out.println("中国厨师做的鱼香肉丝。");
}
}
public class AmericanCooker implements FoodMenu {
@Override
public void XiHongShichaoJiDan() {
System.out.println("西方厨师做的西红柿炒鸡蛋。");
}
@Override
public void YuXiangRouSi() {
System.out.println("西方厨师做的鱼香肉丝。");
}
}
③ Customer
public class Customer {
private FoodMenu foodMenu;
public Customer() {
}
public Customer(FoodMenu foodMenu) {
this.foodMenu = foodMenu;
}
public FoodMenu getFoodMenu() {
return foodMenu;
}
public void setFoodMenu(FoodMenu foodMenu) {
this.foodMenu = foodMenu;
}
public void order1() {
foodMenu.XiHongShichaoJiDan();
}
public void order2() {
foodMenu.YuXiangRouSi();
}
}