当前位置：首页 > 网络编程 > JavaScript > 详细页面

Java接口操作(继承父类并实现多个接口)

时间：2020-10-07来源：www.pcxitongcheng.com作者：电脑系统城

使用接口的时候，需要注意：

1. 接口是没有静态代码块或者构造方法的。 2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式：

1
2
3 public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
// 覆盖重写所有抽象方法
}

3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

A接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package cn.itcast.day10.demo02;
public interface MyInterfaceA {

// 错误写法！接口不能有静态代码块
// static {
//
// }

// 错误写法！接口不能有构造方法
// public MyInterfaceA() {
//
// }

public abstract void methodA();

public abstract void methodAbs();

public default void methodDefault() {
System.out.println("默认方法AAA");
}
}

B接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package cn.itcast.day10.demo02;
public interface MyInterfaceB {

// 错误写法！接口不能有静态代码块
// static {
//
// }

// 错误写法！接口不能有构造方法
// public MyInterfaceA() {
//
// }

public abstract void methodB();

public abstract void methodAbs();

public default void methodDefault() {
System.out.println("默认方法BBB");
}
}

实现类有多个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 package cn.itcast.day10.demo02;
public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {

@Override
public void methodA() {
System.out.println("覆盖重写了A方法");
}

@Override
public void methodB() {
System.out.println("覆盖重写了B方法");
}

@Override
public void methodAbs() {
System.out.println("覆盖重写了AB接口都有的抽象方法");
} // A B 都有覆盖一次

@Override
public void methodDefault() {
System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
}
}

只覆盖重写了一次。

4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package cn.itcast.day10.demo02;
public abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB {
@Override
public void methodA() {

}
// 没有写methodB那么实现类是抽象类
@Override
public void methodAbs() {

}

@Override
public void methodDefault() {

}
}

抽象方法methodB没有重写覆盖，那么实现类成为了抽象类。

5. 如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写（A，B两个接口中都写了默认方法，冲突了）。见3.中实现类中覆盖重写了A，B中的两个默认方法

6. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

Fu类

1
2
3
4
5
6
7 package cn.itcast.day10.demo02;
public class Fu {

public void method() {
System.out.println("父类方法");
}
}

MyInterface接口

1
2
3
4
5
6
7 package cn.itcast.day10.demo02;
public interface MyInterface {

public default void method() {
System.out.println("接口的默认方法");
}
}

直接父类当中的方法，和接口当中的默认方法产生了冲突。

Zi子类

1
2
3 package cn.itcast.day10.demo02;
public class Zi extends Fu implements MyInterface {
}

调用method方法，看哪个优先

1
2
3
4
5
6
7
8 package cn.itcast.day10.demo02;
public class Demo01Interface {

public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}

调用子类对象的method方法，发现使用的是父类中的而不是接口中的方法，父类的优先级比接口优先级更高。

运行结果：

父类方法

Process finished with exit code 0

补充知识：java从对象开始（类，父类与继承，抽象，接口）

1、对象（类class）

在程序设计时，我们往往会接触到各种形形色色的现实已存在的对象，这些对象都是需要我们在程序中实例化出来进行业务操作的。不过从数量和复杂上讲可以说比我们现实中接触的事物是有过之而无不及的。

2、父类与继承

当对象类型繁杂数量繁多时我们就会像生物学上对各种生物进行分门别类，对我们收集到的对象以属性或者功能又或者其他标准进行分类目。而这些我们最终分出来的各种类目往往在程序中被定义为父类，它是对我们收集到的对象中某些具有相同属性或者功能又或者其他相似特征的对象集合的总称。好似一个包含各种文件的文件夹，它本身在程序中并无任何业务操作的意义。

不过注意的是在不同情形不同问题域下，由于分类标准不同，父类也会成为某个父类的子类，所以会形成一种树状关系结构,父类在关系结构中与其他对象类并无差别。

分类完成后，现在我们就可以以父类为标准来操作一类对象了。但这时我们对分类好的对象进行实例化会发现那些相同的属性功能或者其他相似特征都需要在其对象中重复编写，像这种程度的分类并不是我们想要的。

于是，我们又给父类赋予新的功能，它不再是单纯的对对象进行分类了。我们提取出相同的属性和功能特征放在父类中，让我们需要操作的对象仅仅关注自己特有的属性和功能特征，其余的属性和功能特征都可通过继承父类来拥有。这样我们就解决了相同属性功能重复编写的问题，并且还能对共有属性功能进行规范化操作。

3、抽象类

因为父类并无任何业务操作意义，我们就对各种父类进行管理为它们添加abstract关键词，让它们无法实例化，这样就避免了实例化对象是不正确的或者某些人分不清具体要操作哪些对象而实例化父类的问题。因为这些父类无法实例化，所以我们把它们称为——抽象类。通过这样的设定我们就会在程序中以抽象类为节点形成各种层级关系。

于是我们树状关系机构又变成了具有清晰层级关系的树状关系结构。

4、小结

父类的提出是进行归类操作，那么继承则是去重和规范化的操作，而抽象在此基础上又进行了关系的分层级和类对象实例化操作的规范。

5、接口

前面说我们对每个对象根据某种特征进行分类了，但有时我们会因为某些特有目的标准不一样，有时以属性分类有时以功能分类，但有些对象可能拥有相同属性不拥有相同功能，有些对象拥有相同功能不拥有相同属性。这时我们就会把这些在父类中没有的属性或者功能但其他对象又有相识功能或属性单独抽取出来作为接口来为这些对象服务。

从抽取相同属性或者功能这点来看，接口实则是对我们已分类好具有清晰层级的树状关系结构再次进行一次去重复操作，从而我们的对象从具有清晰层级的树状关系结构变成了更加灵活的网状形结构。

但是在提取父类分类时我们一般会以相同属性来进行分类，那么那些不同的功能会单独提取到接口中，接口和抽象类相似的是都不会进行具体方法功能的实现，只是将相同的功能申明好进行规范化操作。具体实现会具体到对象再进行实现。

对象进行去重再提取后那些因为在不同父类中具有相同功能的对象又以另外一种标准分类到某种接口中了。比如某某对象的某某功能和某某对象的某某功能都是来至于某某接口的。从而我们对对象进行操作又多了一种标准，可以通过判断是否具有某种功能进行筛选对象进其操作。

6、总结

从功能点上看接口与（抽象和父类和继承）的提出都是对我们程序中的对象进行归类操作，去除那些重复的代码。并且在接口和抽象类中都是可以对某些属性和方法功能进行规范化约束，从而我们在对对象进行业务操作中就更加便捷清晰。对象与对象的关系更加明朗。

以上这篇Java接口操作(继承父类并实现多个接口)就是小编分享给大家的全部内容了，