* 接口的语法
* 1. 在Java语言中interface也可以表示一种类型
* a. 我们的自己定义的一个类,就表示java语言中的一种数据类型
b. 我们自己定义的一个接口,也表示java语言中的数据类型
从数据类型的角度,类和接口,地位是平等,都表示数据类型,但是它们的侧重点不同:
a. 类这种数据类型,描述的是一组数据集合(成员变量)和基于这个数据集合的 一组操作
,这一组操作,它们有联系(间接),都操作同一个数据集合
b. 接口这种数据类型,首先接口这种数据类型,并不关心数据集合,
它关心的仅仅只是一组特殊的操作(方法),这些特殊操作,没有直接关系,接口中
定义的行为,非常的松散
*
* 接口语法:
2.接口用关键字interface表示
格式:interface 接口名 {}
同时,接口的抽象程度比我们的抽象类高,接口中只能定义一种方法, 就是抽象方法(使用JDK8以前)
接口和类的关系:
3.类和接口的关系,类实现接口有实现关系, 用 implements 表示
类和接口的实现关系, 其实是一种实质上的继承关系
格式: class 类名 implements 接口名 {}
接口的特征:
1. 接口不能直接实例化, 但是接口可以间接实例化
接口类型 引用变量 = new 接口子类类型();
2. 接口的子类
可以是抽象类
也可以是具体类(必须是实现接口中所有的抽象方法)
*/
代码示例:
public class Demo1 {
public static void main(String[] args) {
MyInterface myInterface = new MyClass();
}
}
interface MyInterface {
public abstract void testInterface();
}
class MyClass implements MyInterface {
@Override
public void testInterface() {
System.out.println("hello interface");
}
}
* 抽象类和接口的比较
成员区别
抽象类 成员变量可以是变量可以是常量;
成员方法 有抽象方法;,非抽象方法
接口 成员变量 常量 public final static
成员方法:抽象方法(JDK8以前的代码)
关系区别
类与类 继承,单继承
类与接口 实现,单实现,多实现(一个类,可以实现一个接口,也可以同时实现多个接口)
接口与接口 继承,单继承,多继承
设计理念区别
抽象类
a.体现的子类和父类:”is a”的关系。
因为在java语言中,一个类只能继承另一个类,把一个子类类型看做父类类型
b.描述的是子类和父类共性
接口
a. 被实现, 体现的是:”like a”的关系。
因为java语言中,一个类可以实现 多个 接口,每个接口,
都相当于给这个类,打开了一扇小小的窗户
通常,一个接口很难反映出一个类的全貌,换句话说我们认为接口
只会放映一个类的冰山一角,所以我们通常我们只能说 一个类 like a 接口
b. 描述的是一个额外的功能的结合,接口通常用来,给类扩展功能
代码示例:
public class Demo1 {
public static void main(String[] args) {
Inter1 inter1 = new Son();
inter1.show1();
Inter2 inter2 = new Son();
inter2.show2();
}
}
class Father {
public void fatherDo() {
System.out.println("father DO");
}
public void work() {
System.out.println("work");
}
}
interface Inter1 {
void show1();
}
interface Inter2 {
void show2();
}
class Son extends Father implements Inter1, Inter2 {
@Override
public void show1() {
System.out.println("show1 in son");
}
@Override
public void show2() {
System.out.println("show2 in son");
}
}
* jdk8 中提供了两种特殊的方法:
* 1. 默认方法
* 2. 静态方法
*
* 他们在接口中,都可以有方法体,方法实现
*
* 默认方法,其实是java语言的一种折中,接口添加默认方法,不会影响所有实现了该接口的子类
* 静态方法, 使用场景,通常作为工具方法
* a. 定义该静态方法的类中使用
* b. 通过定义该静态方法的接口名. 访问静态方法
*
代码范例:
public class Demo1 {
public static void main(String[] args) {
MyInterface.testStatic();
}
}
interface JDK8Interface {
}
interface MyInterface {
void test();
default void show() {
System.out.println();
testStatic();
}
static void testStatic() {
System.out.println("static");
}
}
class A implements MyInterface {
@Override
public void test() {
System.out.println("A test()");
}
@Override
public void show() {
}
}
abstract class B implements MyInterface {
@Override
public void test() {
System.out.println("B test()");
}
@Override
public abstract void show();
}
* 接口的特点
1. 无构造方法:没有构造方法
2. 成员变量:只能是常量,修饰符public static final
对于接口而言,定义的成员变量,默认的修饰符就是public static final
3. 成员方法:只能是抽象方法,修饰符public abstract
接口中的方法声明,默认修饰符public abstract
代码说明:
public class Demo1 {
public static void main(String[] args) {
}
}
interface MemberInterface {
int a = 100;
void method();
}
* 在java语言中:
* 1. 类与类之间,只能是单重继承,extends关键字后面只能跟一个类名
*
* java语言声称自己实现了多重继承?
* 1. 仅从接口的角度来理解 接口与接口之间,可以实现多重继承
* 2. 一个完整的类定义,除了可以声明一个类继承其他的某各类,除此之外
* 我们还可以让该类,实现多个接口
*
* 就好像实现了多重继承
*
代码说明:
public class Demo1 {
}
interface FirstInterface {
void first();
}
interface SecondInterface {
void second();
}
interface ThirdInterface extends FirstInterface, SecondInterface {}
class A implements ThirdInterface {
@Override
public void first() {
}
@Override
public void second() {
}
}
class B {
public void doSomething() {
System.out.println("doSomething");
}
}
class CompleteClass extends B implements FirstInterface, SecondInterface {
@Override
public void first() {
}
@Override
public void second() {
}
}
练习示例:
* 教练和运动员案例
乒乓球运动员和足球运动员。
乒乓球教练和足球教练。
为了出国交流,跟乒乓球相关的人员都需要学习英语。
请用所学知识:
分析,这个案例中有哪些抽象类,哪些接口,哪些具体类。
乒乓球运动员
属性:name, age, salary
行为:eat(), sleep(), train(), match(), learnEnglish();
乒乓球教练
属性:name, age, salary,bonus
行为:eat(), sleep(), teach(), learnEnglish()
足球运动员
属性:name, age, salary
行为:eat(), sleep(), train(), match()
足球教练
属性:name, age, salary, bonus
行为:eat(), sleep(), teach()
如何描述:
所有人的共性: 定义一个父类(具体父类) 其实是人的共性 Human
1. 发现乒乓球运动员,乒乓球教练,足球运动员 足球教练有相同的属性 name, age, salary
2. 发现乒乓球运动员,乒乓球教练,足球运动员 足球教练有相同的行为eat(), sleep()
运动员有相同的行为: Athlete 描述运动员描述相同的行为(Athlete 抽象类)
train(), match(),但实现,不同类型的远动员,训练和比赛的内容不同
教练员有形同的属性性和行为:Coach 教练员的bonus属性,以及teach()方法声明(抽象类)
a. bonus 属性
b. teach() 但是,不同类型的教练,教的内容的不容
有一种特殊的行为,学习英语的行为,这属于运动员额外的特殊技能
而且,跟乒乓球相关的人员相关的人才需要有这样的特殊技能
*/
代码:
public class Exercise {
}
class Human {
}
abstract class Athlete extends Human {
public abstract void train();
public abstract void match();
}
abstract class Coach extends Human {
private int bonus;
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
public abstract void teach();
}
class TableTennisAthlete extends Athlete implements SpecialSkill {
@Override
public void train() {
}
@Override
public void match() {
}
@Override
public void learningEnglish() {
}
}
class TableTennisCoach extends Coach implements SpecialSkill {
@Override
public void teach() {
}
@Override
public void learningEnglish() {
}
}
class FootballAthlete extends Athlete{
@Override
public void train() {
}
@Override
public void match() {
}
}
class FootballCoach extends Coach {
@Override
public void teach() {
}
}
interface SpecialSkill {
void learningEnglish();
}