java接口的基本概念
java接口的概念
java接⼝的概念
⼀:概念
接⼝是功能的集合。同样可以看做⼀种数据类型,是⽐抽象类更为抽象的“类”。
接⼝描述应该具备的⽅法,并没有具体的实现。具体实现由接⼝的实现类(相当于接⼝的⼦类来完成)。好处:
使功能和实现分离,优化了程序设计。
⼆:语法
使⽤关键字interface关键字来定义。
定义的接⼝⽂件仍然是.java⽂件。虽然声明的时候使⽤interface关键字,编译之后仍然是.class
⽂件。接⼝我们可以把他看做是⼀种只包含了功能声明的特殊类。
定义格式:
public interface 接⼝名字{
抽象⽅法1(public abstract 返回值类型⽅法名字(参数列表);)
抽象⽅法1(public abstract 返回值类型⽅法名字(参数列表);)
抽象⽅法1(public abstract 返回值类型⽅法名字(参数列表);)
.......
}
1package pany;
2
3public interface Myinterface {
4/**
5 *接⼝定义:
6 * 修饰符 interface 接⼝名字
7 * ⽅法的定义:
8 * public abstract 返回值类型⽅法名字 (参数列表)
9 * 其中 public 修饰符必须是 public 或者不写,不写该⽅法的访问权限也是public。⽅法为抽象⽅法,所以⽤abstract来修饰.
10 * 成员的变量的定义:必须是常量且修饰符为public .
11*/
12public static final int c=22;
13public abstract int myinter();
java 接口的理解
java 接口的理解
Java 接口是一种抽象类型,它定义了一组规范或方法,但并不实现这些方法。接口可以被看作是一种完全抽象的类,它只包含方法的声明,而没有方法的实现。实现接口的类必须提供这些方法的具体实现。
理解Java 接口需要从以下几个方面入手:
1. **抽象性**:接口是一种抽象类型,它只定义方法的声明,而不提供具体的实现。这意味着接口中的方法都是抽象方法,需要由实现接口的类来提供具体实现。
2. **规范性**:接口是一种规范,它定义了一组方法的规范和行为。实现接口的类必须遵循这些规范,提供相应的方法实现。
3. **多重继承**:通过实现多个接口,一个类可以实现多重继承,即继承多个接口中定义的方法。这使得一个类能够具有多个规范或行为。
4. **设计模式**:接口在Java 中常常被用于实现设计模式,如工厂模式、适配器模式、观察者模式等。通过使用接口,可以更加灵活地设计软件架构和代码结构。
5. **依赖注入**:在面向对象编程中,依赖注入是一种常见的设计模式,它使得代码更加模块化和可测试。通过接口,可以实现依赖注入,使得代码之间的耦合度降低,更加易于维护和测试。
6. **回调函数**:接口可以被用作回调函数,即当某个事件发生时,调用实现该接口的类中的方法。这种回调机制使得代码更加灵活
和可扩展。
总之,Java 接口是一种强大的抽象类型,它可以用来定义规范、实现多态、降低耦合度、提高代码可维护性和可扩展性等。理解Java 接口需要深入理解抽象、规范和多态等概念,并掌握如何在实践中使用接口来设计代码结构和软件架构。
Java接口是什么
Java接口是什么
Java接口是什么
接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法,以下是店铺为大家搜索整理的Java接口是什么,希望能给大家带来帮助,
接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类,否则该类要定义接口中的.所有方法。
接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在Java中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。
接口与类相似点:
一个接口可以有多个方法。
接口文件保存在.java结尾的文件中,文件名使用接口名。
接口的字节码文件保存在.class结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别:
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量,除了static和final变量。
接口不是被类继承了,而是要被类实现。
接口支持多重继承。
【Java接口是什么】
详解Java中的面向接口编程
详解Java中的面向接口编程
在Java编程中,面向接口编程是一种重要的编程思想和实践方式。通过面向接口编程,我们可以实现代码的灵活性、可扩展性和可维护性。本文将详细介绍
Java中的面向接口编程,并探讨其优势和应用。
一、什么是接口?
在Java中,接口是一种定义了一组方法的抽象类型。接口可以看作是一种契约,规定了类应该具有的行为。通过实现接口,类可以拥有接口定义的方法,并提供自己的实现。
在接口中,我们只定义方法的签名,而不包含具体的实现。这使得接口成为一
种非常灵活的编程工具,可以在不改变接口定义的情况下,实现不同的具体逻辑。
二、为什么要使用面向接口编程?
1. 提高代码的灵活性
通过面向接口编程,我们可以将程序的依赖关系从具体的实现类解耦,而是依
赖于接口。这样,当需要替换具体的实现类时,只需要修改依赖的接口即可,而不需要修改大量的代码。这样可以提高代码的灵活性和可维护性。
2. 实现多态
面向接口编程可以实现多态。多态是指在父类或接口类型的引用变量中,可以
指向不同子类或实现类的实例。通过多态,我们可以编写通用的代码,而不需要考虑具体的实现类。这样可以提高代码的复用性和扩展性。
3. 规范化编程
接口定义了类应该具有的行为,通过面向接口编程,我们可以规范化编程。当多个类实现同一个接口时,它们必须提供相同的方法,这样可以提高代码的一致性和可读性。
三、如何使用面向接口编程?
1. 定义接口
在使用面向接口编程之前,首先需要定义接口。接口的定义使用`interface`关键字,例如:
```java
public interface Animal {
java接口规范
java接口规范
Java接口规范是指在Java中编写接口时应遵循的一些约定和
规范。接口是一种抽象的概念,用于定义一组相关的操作或功能,并且可以被多个类实现。接口规范的目的是提供一种清晰、一致的方式来定义接口,以便于其他开发人员理解和使用。
以下是一些Java接口规范的内容:
1. 接口命名:接口的名称应该清晰明了,能够准确表达接口的功能或角色。接口的名称应该使用驼峰命名法,并且以大写字母开头。
2. 接口声明:接口应该使用关键字“interface”来声明,并且应
该放置在单独的源文件中。接口的声明应该包含一个或多个抽象方法的定义。
3. 方法命名:接口中的方法应该使用清晰明了的动词命名,以准确表达方法的功能。方法的命名应该使用驼峰命名法,并且以小写字母开头。
4. 方法声明:接口中的方法声明应该包含方法的返回类型、方法名和参数列表。接口中的方法默认是抽象方法,不需要使用关键字“abstract”来声明。接口中的方法不能包含方法体。
5. 常量声明:接口中可以声明常量,这些常量需要使用关键字“final”和“static”来声明,并且常量的名称需要使用大写字母和
下划线。接口中的常量默认是public的,并且不需要使用关键
字“public”来声明。
6. 接口实现:类可以实现一个或多个接口,通过实现接口可以强制类实现接口中定义的方法。类实现接口时需要使用关键字“implements”来声明,并且需要实现接口中定义的所有抽象方法。
7. 接口继承:接口可以继承一个或多个接口,通过继承接口可以扩展接口的功能。接口继承接口时需要使用关键字“extends”来声明,并且需要继承所有父接口的定义。
java 接口
java 接口
在Java语言中,接口是一个特殊的语法结构,其中可以包含一组方法声明(没有实现的方法)和一些常量。接口和类构成Java的两个基本类型,但接口和类有着不同的目的,它可用于在树形层次结构上毫不相干的类之间进行交互。一个Java类可以实现多个Java接口,这也解决了Java类不支持多重继承带来的弱点。
1 接口的声明
Java接口的定义方式与类基本相同,不过接口定义使用的关键字是interface,
各个参数的说明如下。
●Inter_name 表示接口名称。
●Extends 表示接口的继承关系。接口继承没有唯一性限制,一个接口可以继承多个接口,
接口interface_name称为被继承接口(如interface1_name、interface2_name)的子接口
(subinterface),被继承的接口(如interface1_name、interface2_name)称为接口
interface_name的父接口(superinterface)。
●RetureType 表示方法的返回值类型。
●Method_name 表示方法名称。
●Parameter_list 表示方法参数列表。
2 接口的特征
接口对于其声明、变量和方法都做了许多限制,这些限制作为接口的特征归纳如下:
●具有public访问控制符的接口,允许任何类使用;没有指定public的接口,其访问将局
限于所属的包。
●方法的声明不需要其他修饰符,在接口中声明的方法,将隐式地声明为公有的(public)
和抽象的(abstract)。
什么是接口
什么是接口
Java中的接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。
接口的两种含义:一,Java接口,Java语言中存在的结构,有特定的语法和结构;二,一个类所具有的方法的特征集合,是一种逻辑上的抽象。前者叫做“Java接口”,后者叫做“接口”。
在Java语言规范中,一个方法的特征仅包括方法的名字,参数的数目和种类,而不包括方法的返回类型,参数的名字以及所抛出来的异常。在Java编译器检查方法的重载时,会根据这些条件判断两个方法是否是重载方法。但在Java编译器检查方法的置换时,则会进一步检查两个方法(分处超类型和子类型)的返还类型和抛出的异常是否相同。
接口继承和实现继承的规则不同,一个类只有一个直接父类,但可以实现多个接口。
Java接口本身没有任何实现,因为Java接口不涉及表象,而只描述public行为,所以Java接口比Java抽象类更抽象化。
Java接口的方法只能是抽象的和公开的,Java接口不能有构造器,Java接口可以有public,静态的和final属性。
接口把方法的特征和方法的实现分割开来。这种分割体现在接口常常代表一个角色,它包装与该角色相关的操作和属性,而实现这个接口的类便是扮演这个角色的演员。一个角色由不同的演员来演,而不同的演员之间除了扮演一个共同的角色之外,并不要求其它的共同之处。
[编辑本段]为什么使用接口
两个类中的两个类似的功能,调用他们的类动态的决定一种实现,那他们提供一个抽象父类,子类分别实现父类所定义的方法。
java的接口与实例
一、定义
Java接口(Interface),是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。
接口定义的一般形式为:
[访问控制符]interface {
类型标识符final 符号常量名n = 常数;
返回值类型方法名([参数列表]);
…
}
二、接口的特点
1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
三、接口的用法
1、精简程序结构,免除重复定义
比如,有两个及上的的类拥有相同的方法,但是实现功能不一样,就可以定义一个接口,将这个方法提炼出来,在需要使用该方法的类中去实现,就免除了多个类定义系统方法的麻烦。
什么是接口
什么是接口?
接口(Interface)是面向对象编程中的一个重要概念,用于定义对象之间的通信协议。接口定义了一组方法的签名(方法名、参数列表和返回类型),而不包含具体的实现代码。通过实现接口,类可以表达自己具备某种能力或提供某种服务。
接口的主要特点如下:
1. 方法签名:接口定义了一组方法的签名,包括方法名、参数列表和返回类型。方法签名描述了方法的输入和输出,但不包含具体的实现代码。接口中的方法通常是抽象方法,不包含方法体。
2. 多实现:一个类可以实现一个或多个接口。通过实现接口,类可以表达自己具备接口定义的能力或提供接口定义的服务。一个类可以实现多个接口,从而具备多个不同的能力或服务。
3. 接口继承:接口可以继承其他接口,形成接口之间的继承关系。子接口继承了父接口的方法签名,并可以添加新的方法签名。接口继承可以形成接口的层次结构,提供更加抽象和通用的接口定义。
4. 实现接口:类通过实现接口来表达自己具备接口定义的能力或提供接口定义的服务。实现接口需要实现接口定义的所有方法签名,以提供方法的具体实现。一个类可以实现多个接口,通过逗号分隔。
5. 接口与类的关系:接口与类是两个不同的概念。接口定义了一组方法的签名,没有具体的实现代码;而类是具体的实现单位,提供方法的具体实现。类通过实现接口来表达自己具备接口定义的能力或提供接口定义的服务。
接口的优点包括:
1. 规范和约束:接口定义了一组方法的签名,规范了类提供的能力或服务。通过接口,可以明确约定类需要实现哪些方法,从而提供一致的行为和接口。
接口的基本定义
接⼝的基本定义
⼀、接⼝定义
Java接⼝是⼀系列⽅法的声明,是⼀些抽象的集合
⼀个接⼝只有抽象⽅法没有⽅法的实现,因此这些⽅法可以在不同的地⽅被不同的类实现,⽽这些实现可以具有不同的⾏为(功能)。简单地说,接⼝就是特殊的抽象类,即所有⽅法都是抽象⽅法的抽象类就是Java中的接⼝(interface)。
⼆、接⼝的特点
接⼝是⼀种特殊的抽象类。
接⼝中没有变量,只能有public static final修饰的静态常量。三个修饰符可以省略。
接⼝中所有⽅法都是抽象⽅法,且默认就是public权限。
java接口介绍
10
接口的特征五
接口必须通过类来实现它的抽象方法。
public class Glass implements Transparency{ … }
12
比较抽象类与接口
抽象类和接口都位于继承树的上层,相同点:
代表系统的抽象层。
不能实例化。 能包含抽象方法。
13
抽象类与接口区别(一)
在抽象类中可以为部分方法提供默认实现,从 而避免在子类中重复实现它们,提高代码的可 重用性,这是抽象类的优势所在;而接口中只 能包含抽象方法。
5
中国联通 public class CMCC_SMS implements MobileProductor{ //如果是中国移动,则由中国移动根据短 信发送接口实现自己发送短信的功能 public void sendSMS() { System.out.println("这是由中国移动代理 发送的短信信息!"); } }
当类实现了某个接口时,它必须实现接口中所有的抽象方 法,否则这个类必须被定义为抽象类。
11
接口的特征六
不允许创建接口的实例,但允许定义接口类型的引用变量 。 Transparency t=new Glass(); 一个类只能继承一个直接的父类,但能实现多个接口。
java接口实验报告 -回复
java接口实验报告-回复
Java接口实验报告
[Java接口]的使用及实验结果
写一篇1500-2000字文章,一步一步回答
一、引言
Java是一种面向对象的编程语言,它提供了丰富的特性来支持面向对象的编程。其中一个最重要的特性之一就是接口。接口在Java中扮演着连接不同类之间的桥梁,它定义了一组方法的签名,规定了其他类必须遵循的接口。在本次实验中,我们将探索Java接口的使用,并通过编写简单的实验来进一步理解其工作原理。
二、理论基础
2.1 接口的定义
在Java中,接口是一种抽象的定义,它定义了一组可以被其他类实现的方法。接口可以看作是一种约定,它规定了实现它的类必须提供的方法。接口中的方法只有签名,没有实现,是完全抽象的。接口使用`interface`
关键字来定义。
2.2 接口的实现
一个类可以同时实现多个接口,通过`implements`关键字来实现接口。一个类实现了一个接口,就必须提供该接口中定义的所有方法。接口的实现通过关键字`implements`来实现。
2.3 接口的优势
接口在Java中扮演着重要的角色,它具有以下几个优势:
1. 定义了一组可以被其他类实现的方法,提供了一种规范。
2. 实现多态性,不同的类可以实现同一个接口,实现类的实例可以通过接口的引用来访问。
3. 提高了代码的灵活性和可维护性,实现类可以随时更改。
4. 提供了一种解耦合的方式,降低了类之间的依赖性。
三、实验过程
3.1 实验目标
本次实验的目标是通过创建一个简单的接口和实现类,理解接口的概念和
使用方法。
3.2 实验准备
java接口介绍
接口
一、Java中引入接口的原因
实现多重继承。
二、Java中的接口与类的关系
接口是一种特殊的类。
其特殊性在于:接口中的属性只能是公有访问的常量,接口中的方法只能是公有访问的抽象方法。
三、接口的定义
略
四、接口的使用
不能被实例化,只能被继承或作为数据类型使用,这一点与抽象类一样。
五、接口的实现(即继承接口)
1.实现接口的类在定义时,在类头中由implements指明要实现的接口(列表);
2.实现接口的类在定义时,对方法的定义必须注意遵守抽象方法的使用原则,即“非抽象类中不允许存在抽象方法”,否则出现编译错误;
3.实现接口的类在定义时,若要实现接口中的抽象方法(即覆盖接口中的抽象方法)必须注意遵守覆盖规范,即“三同一不降”,否则出现编译错误。
java接口继承和实现
java接口继承和实现
Java中的接口继承和实现是面向对象编程中常用的概念和技术。接口是一种只包含方法声明而没有方法实现的抽象类。在Java中,一个类可以继承自另一个类,也可以实现一个或多个接口。
1. 什么是接口?
接口是一种抽象类。它定义了一组方法的声明,但没有方法的实现。它可以包含常量和默认方法。接口可以被类实现,实现接口的类必须实现接口中声明的所有方法。
2. 为什么要使用接口?
使用接口有以下几个原因:
- 接口提供了一种规范,定义了一组方法的声明,来确保一组相关类具有相同的行为。
- 接口解耦了类之间的关系,提供了更大的灵活性。一个类可以实现多个接口,而不仅仅限于单继承。
- 接口提供了一种契约,确保类实现了接口中定义的所有方法,从而增加代码的可维护性,降低了耦合度。
3. 接口的继承?
接口可以通过继承来扩展其他接口。接口的继承使用关键字"extends"。继承后的接口会继承父接口中的所有方法声明。
java
public interface ParentInterface {
void method1();
}
public interface ChildInterface extends ParentInterface { void method2();
}
上述代码中,ChildInterface继承自ParentInterface。ChildInterface除了拥有自己定义的method2外,还继承了ParentInterface的method1。
4. 类的实现接口?
类可以通过实现接口来符合接口的规范。使用关键字"implements",类必须实现接口中声明的所有方法。
java 接口的申明
java 接口的申明
Java中的接口是一种抽象类型,它是一种约定,定义了类需要遵循的行为。在Java中,接口是通过interface关键字来声明的,接口可以包含抽象方法、默认方法、静态方法和常量。
接口的声明使用关键字interface,其基本语法为:
```java
interface 接口名 {
// 抽象方法声明
// 默认方法声明
// 静态方法声明
// 常量声明
}
```
接口中的方法默认为public abstract类型,可以省略这两个修饰符。接口中的
方法没有方法体,所有的方法都是抽象方法,由实现接口的类来实现这些方法。
除了抽象方法外,Java 8引入了默认方法和静态方法。默认方法使用default关
键字声明,它允许在接口中定义方法的具体实现。静态方法使用static关键字声明,它可以在接口中直接调用,不需要实现类的实例。
常量是接口中的特殊成员,定义时使用final修饰,表示常量的值不能被修改,接口中的常量默认为public static final类型,可以省略这三个修饰符。
接口的声明示例:
```java
interface Animal {
int legs = 4; // 常量声明
void eat(); // 抽象方法声明
default void sleep() { // 默认方法声明
System.out.println("Animal is sleeping");
}
static void run() { // 静态方法声明
System.out.println("Animal is running");
java接口的基本概念
class A{ public void fun1(){
// 定义类A // 定义fun1()方法
System.out.println("A --> public void fun1(){}") ;
} public void fun2(){
// 定义fun2()方法
this.fun1() ;
}
}; class B extends A{
}
abstract class B implements A{ // 定义抽象类,实现接口
public abstract void say() ;
// 此时抽象类中存在三个抽象方法
}
class X extends B{
// 子类继承抽象类
public void say() { // 覆写抽象类B中的抽象方法
}
}
接口的继承
一个接口不能继承一个抽象类,但是却可以 通过extends关键字同时继承多个接口,实 现接口的多继承。
格式:
interface 子接口 extends 父接口A,父接口 B,...{}
接口的多继承
interface A{
// 定义接口A
public String AUTHOR = "李兴华" ;
System.out.println("A --> public void fun1(){}") ;
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
java接口的基本概念
接口的定义
interface A{ public static final String AUTHOR = “张三" ;
完整//格定式义:全局常量
public abstract void print() ; // 定义抽象方法
// 定义抽象方法 // 定义抽象方法
}
abstract class B{
// 定义抽象类 B
public abstract void say() ;
} class X extends B implements A{
public void say() {
// 子类同时实现接口 // 覆写抽象类B中的抽象方法
// 定义抽象方法 // 定义抽象方法
}
abstract class B implements A{ // 定义抽象类,实现接口
public abstract void say() ;
// 此时抽象类中存在三个抽象方法
}
class X extends B{
// 子类继承抽象类
public void say() { // 覆写抽象类B中的抽象方法
System.out.println("Hello World!!!");
}
public String getInfo() {
// 覆写接口A中的抽象方法
return "HELLO";
}
public void print() {
// 覆写接口A中的抽象方法
System.out.println("作者:" + AUTHOR);
B + say () : void
X
+ <<Implement>> say () : void + <<Imjapvlae接m口e的nt基>>本概g念etInfo () : String + <<Implement>> print () : void
继承抽象类实现接口
一个子类可以同时继承抽象类和实现接口。 格式如下:
System.out.println("Hello World!!!");
}
public String getInfo() {// 覆写抽象类B中的抽象方法
return "HELLO";
}
public void print() {
// 覆写抽象类B中的抽象方法
System.out.println("作者:" + AUTHOR);
第6章:面向对象(高级) —— 接口的基本概念
java接口的基本概念
本章目标
掌握接口的定义格式及使用 掌握接口与抽象类的关系
java接口的基本概念
接口
接口是java中最重要的概念,接口可以理解 为一种特殊的类,里面全部是由全局常量和 公共的抽象方法所组成。
java接口的基本概念
接口的定义格式
class 子类 extends 抽象类 implements 接 口A,接口B,...{}
java接口的基本概念
子类同时继承抽象类和实现接口
interface A{
// 定义接口A
public String AUTHOR = "李兴华" ; // 定义全局常量
public void print() ; public String getInfo() ;
System.out.println("作者:" + AUTHOR);
java接口的基本概念
}
接口的实现
以上的程序中,一个子类同时实现了两个接 口,这样在子类中就必须同时覆写完两个接 口中的全部抽象方法
A
+ AUTHOR : String = "李兴华" + print () : void + getInfo () : String
Hale Waihona Puke Baidu
// 定义全局常量
public void print() ;
// 定义抽象方法
public String getInfo() ;
// 定义抽象方法
} interface B{
public void say() ;
// 定义接口B // 定义抽象方法
} class X implements A,B{
public void say() {
}
}
java接口的基本概念
接口和抽象类的使用限制
在java中允许一个抽象类实现多个接口的
interface A{ public String AUTHOR = "李兴华" ; public void print() ; public String getInfo() ;
// 定义接口A // 定义全局常量
public abstract String getInfo() ; // 定义抽象方法
}
interface A{
String AUTHOR = “张三" ; // 等价于:public
简st化at格ic式f:inal String AUTHOR = "李兴华" ;
void print() ;
// 等价于:public
abstract void print() ;
String getInfo() ;
// 等价于:public
abstract String getInfo() ;
java接口的基本概念
}
接口图形表示
接口的图形可以按照类图的形式表示,也可 以使用一个“○”表示
A + AUTHOR : String = "李兴华" + print () : void + getInfo () : String
}
}
java接口的基本概念
接口的继承
一个接口不能继承一个抽象类,但是却可以 通过extends关键字同时继承多个接口,实 现接口的多继承。
// 子类同时实现两个接口 // 覆写B接口中的抽象方法
System.out.println("Hello World!!!");
} public String getInfo() {
// 覆写A接口中的抽象方法
return "HELLO";
}
public void print() {
// 覆写A接口中的抽象方法
A
java接口的基本概念
实现接口
与抽象类一样,接口要使用也必须通过子类, 子类通过implements关键字实现接口。
实现格式:
class 子类 implements 接口A,接口B,...{ }
java接口的基本概念
实现接口
interface A{
// 定义接口A
public String AUTHOR = "李华" ;