java接口和stu.i_java基础之接口（抽象类与接口的区别）

概述

猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，对不。但是，现在有很多的驯养员或者是驯的，这应该属于经过特殊的培训训练出来的，对不。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

1、接口的特点：

A:接口用关键字interface表示

interface 接口名 {} //默认省略了关键字 public,但在具体的实现类中，重写方法必须声明为public

B:类实现接口用implements表示

class 类名 implements 接口名 {}

C:接口不能实例化

那么，接口如何实例化呢?

按照多态的方式来实例化。

D:接口的子类

a:可以是抽象类。但是意义不大。

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

由此可见多态的使用场合：

A:具体类多态(几乎没有)

B:抽象类多态(常用)

C:接口多态(最常用)

//定义动物培训接口

interface AnimalTrain {

public abstract void jump();

}

//抽象类实现接口

abstract class Dog implements AnimalTrain {

}

//具体类实现接口

class Cat implements AnimalTrain {

public void jump() {

System.out.println("猫可以跳高了");

}

}

class InterfaceDemo {

public static void main(String[] args) {

//AnimalTrain是抽象的; 无法实例化

//AnimalTrain at = new AnimalTrain();

//at.jump();

AnimalTrain at = new Cat();

at.jump();

}

}

2、接口成员特点

成员变量；只能是常量，并且是静态的。

默认修饰符：public static final

建议：自己手动给出。

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

成员方法：只能是抽象方法。

默认修饰符：public abstract

建议：自己手动给出。

所有的类都默认继承自一个类：Object。

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

interface Inter {

public int num = 10;

public final int num2 = 20;

public static final int num3 = 30;

//错误: 需要

//public Inter() {}

//接口方法不能带有主体

//public void show() {}

//abstract void show(); //默认public

public void show(); //默认abstract

}

//接口名+Impl这种格式是接口的实现类格式

/*

class InterImpl implements Inter {

public InterImpl() {

super();

}

}

*/

class InterImpl extends Object implements Inter {

public InterImpl() {

super();

}

public void show() {}

}

//测试类

class InterfaceDemo2 {

public static void main(String[] args) {

//创建对象

Inter i = new InterImpl();

System.out.println(i.num);

System.out.println(i.num2);

//i.num = 100;

//i.num2 = 200;

//System.out.println(i.num); //无法为最终变量num分配值

//System.out.println(i.num2);//无法为最终变量num2分配值

System.out.println(Inter.num);

System.out.println(Inter.num2);

System.out.println("--------------");

}

}

3、类与类,类与接口以及接口与接口的关系

类与类：

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

类与接口：

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

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

接口与接口：

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

interface Father {

public abstract void show();

}

interface Mother {

public abstract void show2();

}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现

class Son extends Object implements Father,Mother {

public void show() {

System.out.println("show son");

}

public void show2() {

System.out.println("show2 son");

}

}

class InterfaceDemo3 {

public static void main(String[] args) {

//创建对象

Father f = new Son();

f.show();

//f.show2(); //报错

Mother m = new Son();

//m.show(); //报错

m.show2();

}

}

4、猫狗案例

/*

加入跳高的额外功能

分析：从具体到抽象

猫：

姓名,年龄

吃饭，睡觉

狗：

姓名,年龄

吃饭，睡觉

由于有共性功能，所以，我们抽取出一个父类：

动物：

姓名,年龄

吃饭();

睡觉(){}

猫：继承自动物

狗：继承自动物

跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口

接口：

跳高

部分猫：实现跳高

部分狗：实现跳高

实现；

从抽象到具体

使用：

使用具体类

*/

//定义跳高接口

interface Jumpping {

//跳高功能

public abstract void jump();

}

//定义抽象类

abstract class Animal {

//姓名

private String name;

//年龄

private int age;

public Animal() {}

public Animal(String name,int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

//吃饭();

public abstract void eat();

//睡觉(){}

public void sleep() {

System.out.println("睡觉觉了");

}

}

//具体猫类

class Cat extends Animal {

public Cat(){}

public Cat(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("猫吃鱼");

}

}

//具体狗类

class Dog extends Animal {

public Dog(){}

public Dog(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("狗吃肉");

}

}

//有跳高功能的猫

class JumpCat extends Cat implements Jumpping {

public JumpCat() {}

public JumpCat(String name,int age) {

super(name,age);

}

public void jump() {

System.out.println("跳高猫");

}

}

//有跳高功能的狗

class JumpDog extends Dog implements Jumpping {

public JumpDog() {}

public JumpDog(String name,int age) {

super(name,age);

}

public void jump() {

System.out.println("跳高狗");

}

}

class InterfaceTest {

public static void main(String[] args) {

//定义跳高猫并测试

JumpCat jc = new JumpCat();

jc.setName("哆啦A梦");

jc.setAge(3);

System.out.println(jc.getName()+"---"+jc.getAge());

jc.eat();

jc.sleep();

jc.jump();

System.out.println("-----------------");

JumpCat jc2 = new JumpCat("加菲猫",2);

System.out.println(jc2.getName()+"---"+jc2.getAge());

jc2.eat();

jc2.sleep();

jc2.jump();

//定义跳高狗并进行测试的事情自己完成。

}

}

5、老师和学生案例

/*

加入抽烟的额外功能

分析：从具体到抽象

老师：姓名，年龄，吃饭，睡觉

学生：姓名，年龄，吃饭，睡觉

由于有共性功能，我们提取出一个父类，人类。

人类：

姓名，年龄

吃饭();

睡觉(){}

抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

抽烟接口。

部分老师抽烟：实现抽烟接口

部分学生抽烟：实现抽烟接口

实现：从抽象到具体

使用：具体

*/

//定义抽烟接口

interface Smoking {

//抽烟的抽象方法

public abstract void smoke();

}

//定义抽象人类

abstract class Person {

//姓名

private String name;

//年龄

private int age;

public Person() {}

public Person(String name,int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

//吃饭();

public abstract void eat();

//睡觉(){}

public void sleep() {

System.out.println("睡觉觉了");

}

}

//具体老师类

class Teacher extends Person {

public Teacher() {}

public Teacher(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("吃大白菜");

}

}

//具体学生类

class Student extends Person {

public Student() {}

public Student(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("吃红烧肉");

}

}

//抽烟的老师

class SmokingTeacher extends Teacher implements Smoking {

public SmokingTeacher() {}

public SmokingTeacher(String name,int age) {

super(name,age);

}

public void smoke() {

System.out.println("抽烟的老师");

}

}

//抽烟的学生

class SmokingStudent extends Student implements Smoking {

public SmokingStudent() {}

public SmokingStudent(String name,int age) {

super(name,age);

}

public void smoke() {

System.out.println("抽烟的学生");

}

}

class InterfaceTest2 {

public static void main(String[] args) {

//测试学生

SmokingStudent ss = new SmokingStudent();

ss.setName("林青霞");

ss.setAge(27);

System.out.println(ss.getName()+"---"+ss.getAge());

ss.eat();

ss.sleep();

ss.smoke();

System.out.println("-------------------");

SmokingStudent ss2 = new SmokingStudent("刘意",30);

System.out.println(ss2.getName()+"---"+ss2.getAge());

ss2.eat();

ss2.sleep();

ss2.smoke();

//测试老师留给自己练习

}

}

6、抽象类和接口的区别：

A:成员区别

抽象类：

成员变量：可以变量，也可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量

成员方法：只可以抽象

B:关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

C:设计理念区别

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

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

7、综合小练习

教练和运动员案例

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识：

分析，这个案例中有哪些抽象类，哪些接口，哪些具体类

/*

教练和运动员案例(学生分析然后讲解)

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识：

分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

整个分析过程，我是通过画图讲解的。

*/

//定义一个说英语的接口

interface SpeakEnglish {

//说英语

public abstract void speak();

}

//定义人的抽象类

abstract class Person {

private String name;

private int age;

public Person() {}

public Person(String name,int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

//睡觉

public void sleep() {

System.out.println("人都是要睡觉的");

}

//吃饭

public abstract void eat();

}

//定义运动员抽象类

abstract class Player extends Person {

public Player() {}

public Player(String name,int age) {

super(name,age);

}

//学习

public abstract void study();

}

//定义教练抽象类

abstract class Coach extends Person {

public Coach() {}

public Coach(String name,int age) {

super(name,age);

}

//教

public abstract void teach();

}

//定义乒乓球运动员具体类

class PingPangPlayer extends Player implements SpeakEnglish {

public PingPangPlayer(){}

public PingPangPlayer(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println("乒乓球运动员吃大白菜，喝小米粥");

}

//学习

public void study() {

System.out.println("乒乓球运动员学习如何发球和接球");

}

//说英语

public void speak() {

System.out.println("乒乓球运动员说英语");

}

}

//定义篮球运动员具体类

class BasketballPlayer extends Player {

public BasketballPlayer(){}

public BasketballPlayer(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println("篮球运动员吃牛肉，喝牛奶");

}

//学习

public void study() {

System.out.println("篮球运动员学习如何运球和投篮");

}

}

//定义乒乓球教练具体类

class PingPangCoach extends Coach implements SpeakEnglish {

public PingPangCoach(){}

public PingPangCoach(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println("乒乓球教练吃小白菜，喝大米粥");

}

//教

public void teach() {

System.out.println("乒乓球教练教如何发球和接球");

}

//说英语

public void speak() {

System.out.println("乒乓球教练说英语");

}

}

//定义篮球教练具体类

class BasketballCoach extends Coach {

public BasketballCoach(){}

public BasketballCoach(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println("篮球教练吃羊肉，喝羊奶");

}

//教

public void teach() {

System.out.println("篮球教练教如何运球和投篮");

}

}

class InterfaceDemo {

public static void main(String[] args) {

//测试运动员(乒乓球运动员和篮球运动员)

//乒乓球运动员

PingPangPlayer ppp = new PingPangPlayer();

ppp.setName("王浩");

ppp.setAge(33);

System.out.println(ppp.getName()+"---"+ppp.getAge());

ppp.eat();

ppp.sleep();

ppp.study();

ppp.speak();

System.out.println("----------------");

//通过带参构造给数据(留给你们)

//篮球运动员

BasketballPlayer bp = new BasketballPlayer();

bp.setName("姚明");

bp.setAge(34);

System.out.println(bp.getName()+"---"+bp.getAge());

bp.eat();

bp.sleep();

bp.study();

//bp.speak(); //没有该方法

//测试教练自己做

}

}