接口

接口

1.接口的概述及其特点

如果一个抽象类的所有方法都是抽象的,则可以将这个类用另外一种方式来定义,即接口----来自 java基础入门.

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

一切事物均有功能，即一切事物均有接口。

谁想使用具备这个功能就去实现这个接口.

举个例子:

狗

所有狗都有共性,性别,年龄,睡觉,吃饭-----建议创建成抽象类

部分狗:会数数------这种扩展的----建议创建成接口

1) 接口特点

a:接口用关键字interface表示

* interface 接口名 {}（接口里面可以定义方法，都是抽象的）

b:类实现接口用implements(实现)表示

* class 类名 implements 接口名 {}　　　

接口中都是抽象方法，需要子类去重写

c:接口不能实例化,因为调用抽象方法没有意义（利用多态实例化）

d:接口的子类

(1)可以是抽象类（可以不重写方法）。但是意义不大。

(2)可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

注意1:接口不是被继承的，而是被实现的，但是也属于父类，父类引用指向子类对象.

注意2: 子类:有构造方法

            Public Demo() {

Super();(默认有)

}

接口是干爹,有亲爹Class Demo extends object impolements Inter() {}

子类默认继承object的,super访问的是object里面的构造方法,一个类不写继承任何类,默认继承object.

2.接口的成员特点

接口是对外暴露的原则

1) 接口成员特点

 

　　因为接口仅仅是定义需要具备哪些功能，无需且不能写出具体内容。为了限制接口不被具体实现，其中的成员都是有固定修饰符的，声明的修饰符不能与固定修饰符冲突。接口中的成员是有固定修饰符的，如果没有写，也会自动加入.

 

a.成员变量只能是常量，并且是静态的并公共的。(静态的可以类名.或者接口.调用的)

默认修饰符：public static final(没顺序)三个关键字可以互相交换位置

Int num = 10;

 

b.构造方法：接口没有构造方法。

 

c.成员方法：只能是抽象方法。(接口中不能定义非抽象方法)

 

如void print();

 

默认修饰符：public abstract

 

建议：自己手动给出。方法修饰符为：public abstract(所以依据方法重写的访问权限注意事项，重写接口方法时，必须使用public)

 

注意:当一个类实现了接口时，必须实现其所有的方法，否则这个类会保留一些抽象方法，此时，该类包含了抽象方法，便必须定义为一个抽象类。

 

　　接口与父类的功能可以重复，均代表要具备某种功能，并不冲突。一实现,父类和接口的方法都实现了.

 

定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。

 

 

3.抽象类和接口的区别

1) 成员区别

　　

2) 关系区别

    

 

3) 设计理念区别

a.抽象类 被继承体现的是："is a"的关系。抽象类中定义的是该继承体系的共性功能。

b.接口 被实现体现的是："like a"的关系。接口中定义的是该继承体系的扩展功能。

对事物本质的抽象用抽象类，对事物功能的扩展用接口

 

4.类与类,类与接口,接口与接口的关系

1) 类与类：

继承关系,只能单继承,可以多层继承。

2) 类与接口

实现关系,可以单实现,也可以多实现。

class Demo extends object implements interA,interB

多实现,没有具体的方法体,所以可以多实现,重写可以都重写

并且还可以在继承一个类的同时实现多个接口。

1. Interface InterA {
2. Public abstract void printA();
3. }
4. Interface InterB{
5. Public abstract void printA();
6. }
7. class Demo implements InterA,InterB {
8. Public abstract void printA() {
9. System.out.println("PrintA") //重写一个相当于都给重写了
10. }
11. }

     

3) 接口与接口：

* 继承关系,可以单继承,也可以多继承。

Interface InterC extends InterB,InterA

1. //class Demo implements InterA,implements InterB {        //这么做不允许是非法的

5.猫狗案例加入跳高功能分析及其代码实现

1. class bj09_20 {
2.    public static void main(String[] args) {
3.       Cat c = new Cat("加菲",8); //创建对象
4.       c.eat();
5.       c.sleep();
6.  
7.       JumpCat jc = new JumpCat("跳高猫",3);
8.       System.out.println("Hello World!");
9.       jc.eat();
10.       jc.sleep();
11.       jc.jump();
12.    }
13. }
14. /*
15. * 动物类：姓名，年龄，吃饭，睡觉。//动物的共性功能,如何做不明确,定义成抽象类
16. * 猫和狗
17. * 动物培训接口：跳高 //某些动物具备的,扩展功能,做成接口
18. */
19. abstract class Animal {
20.    //成员变量
21.    private String name; //姓名
22.    private int age; //年龄
23.    //构造方法
24.    public Animal() {} //空参构造
25.    public Animal(String name,int age) { //有参构造
26.       this.name = name;
27.       this.age = age;
28.    }
29.    //成员方法
30.    public void setName(String name) { //设置姓名
31.       this.name = name;
32.    }
33.    public String getName() { //获取姓名
34.       return name;
35.    }
36.  
37.    public void setAge(int age) { //设置年龄
38.       this.age = age;
39.    }
40.    public int getAge() { //获取姓名
41.       return age;
42.    }
43.  
44.    //吃饭睡觉抽象的,抽象方法,必须在接口或抽象类中
45.    public abstract void eat(); //吃饭
46.    public abstract void sleep(); //睡觉
47. }
48. //跳高接口
49. interface Jumping {
50.    public void jump();
51. }
52. class Cat extends Animal { //不是所有的猫都跳高,所以不要接接口
53.    public Cat() {}; //空参构造
54.    public Cat(String name,int age) { //有参构造
55.       super(name,age);
56.    }
57.  
58.    public void eat() {
59.       System.out.println("猫吃鱼");
60.    }
61.    public void sleep() {
62.       System.out.println("侧着睡");
63.    }
64. }
65. class JumpCat extends Cat implements Jumping{ //JumpCat继承Cat,实现接口Jumping
66.    public JumpCat() {} //空参构造
67.    public JumpCat(String name,int age) { //有参构造
68.       super(name,age);
69.    }
70.  
71.    public void jump() {
72.       System.out.println("猫跳高");
73.    }
74.    //想要用有参构造创建对象JumpCat,需在JumpCat里面写有参构造