【1】接口声明 格式
【访问修饰符】interface 接口名【extends 父接口1,父接口2......】
{
常量定义;
方法定义
}
1.package com.msb.test04;
2.
3./**
4. * 1.类是类,接口是接口,它们是同一层次的概念。
5. * 2.接口中没有构造器
6. * 3.接口如何声明:interface
7. * 4.在JDK1.8之前,接口中只有两部分内容:
8. * (1)常量:固定修饰符:public static final
9. * (2)抽象方法:固定修饰符:public abstract
10. * 注意:修饰符可以省略不写,IDE会帮你自动补全,但是初学者建议写上,防止遗忘。
11. */
12.public interface TestInterface01 {
13. //常量:
14. /*public static final*/ int NUM = 10;
15. //抽象方法:
16. /*public abstract*/ void a();
17. /*public abstract*/ void b(int num);
18. /*public abstract*/ int c(String name);
19.}
20.
21.interface TestInterface02{
22. void e();
23. void f();
24.}
25./*
26.5.类和接口的关系是什么? 实现关系 类实现接口:
27.6.一旦实现一个接口,那么实现类要重写接口中的全部的抽象方法:
28.7.如果没有全部重写抽象方法,那么这个类可以变成一个抽象类。
29.8.java只有单继承,java还有多实现
30.一个类继承其他类,只能直接继承一个父类
31.但是实现类实现接口的话,可以实现多个接口
32.9.写法:先继承 再实现:extends Person implements TestInterface01,TestInterface02
33. */
34.class Student extends Person implements TestInterface01,TestInterface02 {
35. @Override
36. public void a() {
37. System.out.println("---1");
38. }
39.
40. @Override
41. public void b(int num) {
42. System.out.println("---2");
43. }
44.
45. @Override
46. public int c(String name) {
47. return 100;
48. }
49.
50. @Override
51. public void e() {
52. System.out.println("---3");
53. }
54.
55. @Override
56. public void f() {
57. System.out.println("---4");
58. }
59.}
60.
61.
62.class Test{
63. //这是一个main方法,是程序的入口:
64. public static void main(String[] args) {
65. //10.接口不能创建对象:
66. //TestInterface02 t = new TestInterface02();
67. TestInterface02 t = new Student();//接口指向实现类 ---》多态
68.
69. //11.接口中常量如何访问:
70. System.out.println(TestInterface01.NUM);
71. System.out.println(Student.NUM);
72. Student s = new Student();
73. System.out.println(s.NUM);
74. TestInterface01 t2 = new Student();
75. System.out.println(t2.NUM);
76. }
}
【3】接口的作用是什么?
定义规则,只是跟抽象类不同地方在哪?它是接口不是类。
接口定义好规则之后,实现类负责实现即可。
【4】
继承:子类对父类的继承
实现:实现类对接口的实现
手机 是不是 照相机
继承:手机 extends 照相机 “is-a”的关系,手机是一个照相机
上面的写法 不好:
实现: 手机 implements 拍照功能 “has-a”的关系,手机具备照相的能力
案例:飞机,小鸟,风筝
定义一个接口: Flyable
【5】多态的应用场合
(1)父类当做方法的形参,传入具体的子类的对象
(2)父类当做方法的返回值,返回的是具体的子类的对象
(3)接口当做方法的形参,传入具体的实现类的对象
(4)接口当做方法的返回值,返回的是具体的实现类的对象
【6】接口和抽象类的区别:
JDK1.8以后的接口新增内容
在JDK1.8之前,接口中只有两部分内容:
(1)常量:固定修饰符:public static final
(2)抽象方法:固定修饰符:public abstract
在JDK1.8之后,新增非抽象方法:
(1)被public default修饰的非抽象方法:
注意1:default修饰符必须要加上,否则出错
注意2:实现类中要是想重写接口中的非抽象方法,那么default修饰符必须不能加,否则出错。
1.public interface TestInterface {
2. //常量:
3. public static final int NUM= 10;
4. //抽象方法:
5. public abstract void a();
6. //public default修饰的非抽象方法:
7. public default void b(){
8. System.out.println("-------TestInterface---b()-----");
9. }
10.}
11.class Test implements TestInterface{
12. public void c(){
13. //用一下接口中的b方法:
14. b();//可以
15. //super.b();不可以
16. TestInterface.super.b();//可以
17. }
18. @Override
19. public void a() {
20. System.out.println("重写了a方法");
21. }
22.
23. @Override
24. public void b() {
25.
26. }
27.}
(2)静态方法:
注意1:static不可以省略不写
注意2:静态方法不能重写
1.public interface TestInterface2 {
2. //常量:
3. public static final int NUM = 10;
4. //抽象方法:
5. public abstract void a();
6. //public default非抽象方法;
7. public default void b(){
8. System.out.println("-----TestInterface2---b");
9. }
10. //静态方法:
11. public static void c(){
12. System.out.println("TestInterface2中的静态方法");
13. }
14.}
15.
16.class Demo implements TestInterface2{
17. @Override
18. public void a() {
19. System.out.println("重写了a方法");
20. }
21. public static void c(){
22. System.out.println("Demo中的静态方法");
23. }
24.}
25.
26.class A {
27. //这是一个main方法,是程序的入口:
28. public static void main(String[] args) {
29. Demo d = new Demo();
30. d.c();
31. Demo.c();
32. TestInterface2.c();
33. }
34.}
疑问:为什么要在接口中加入非抽象方法???
如果接口中只能定义抽象方法的话,那么我要是修改接口中的内容,那么对实现类的影响太大了,所有实现类都会受到影响。
现在在接口中加入非抽象方法,对实现类没有影响,想调用就去调用即可。