概述

猫狗案例,我们想想狗一般就是看门,猫一般就是作为宠物了,对不。但是,现在有很多的驯养员或者是驯的,这应该属于经过特殊的培训训练出来的,对不。所以,这些额外的动作定义到动物类中就不合适,也不适合直接定义到猫或者狗中,因为只有部分猫狗具备这些功能。所以,为了体现事物功能的扩展性,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(); //没有该方法 //测试教练自己做
}
}

版权声明:本文为小平果原创文章,转载请注明:http://blog.csdn.net/i10630226

java基础之接口(抽象类与接口的区别)的更多相关文章

  1. 【java基础 16】抽象类和接口的区别

    导读:前两天闲着没事儿,看了本书,然后写了点代码,在接口里面写了默认方法实现,因为书上说这个特性是从java8开始的,我还特地给测了一下java7. 没过几天,就有一个技术分享会,刚好也是讲java8 ...

  2. 十、Java基础---------面向对象之抽象类与接口

    抽象类(abstract)     当编写一个类时,时常会为该类定义一些方法,这些方法的使用用以描述该类的行为方式,那么这些方法都有具体的方法体.但是在某些情况下,某个父类只是知道子类应该包含怎样的方 ...

  3. Java基础系列--06_抽象类与接口概述

    抽象类 (1)如果多个类中存在相同的方法声明,而方法体不一样,我们就可以只提取方法声明. 如果一个方法只有方法声明,没有方法体,那么这个方法必须用抽象修饰. 而一个类中如果有抽象方法,这个类必须定义为 ...

  4. Java基础知识(抽象类和接口)

    一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一种特殊的方法:它只有声明,而没有具体的实现.抽象方法的声明格式为: 1 abstract void fun(); 抽象方法必须用abst ...

  5. Java基础5:抽象类和接口

    本文主要介绍了抽象类和接口的特性和使用方法. 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人博客: https://h2pl.g ...

  6. JAVA核心技术I---JAVA基础知识(抽象类和接口)

    一:抽象类 (一)定义 类:属性(0或多个)+方法(0或多个)一个完整(健康)的类:所有的方法都有实现(方法体)类可以没有方法,但是有方法就肯定要有实现,这才是一个完整的类一个完整的类才可以被实例化, ...

  7. Java 的抽象特性:抽象类与接口深度解析

    要点: 抽象类 接口 抽象类与接口的差别 一. 抽象 对于面向对象编程来说,抽象是它的四大特征之中的一个. 在Java中,能够通过两种形式来体现OOP的抽象:接口和抽象类. 接口和抽象类为我们提供了一 ...

  8. Java:【面向对象:抽象类,接口】

    本文内容: 抽象类 接口 抽象类与接口的异同 首发日期:2018-03-24 抽象类: 虽然已经有了父类,但有时候父类也是无法直接描述某些共有属性的,比如哺乳类和人类都会叫,而一般来说哺乳类这个父类并 ...

  9. JAVA基础之——三大特征、接口和抽象类区别、重载和重写区别、==和equals区别、JAVA自动装箱和拆箱

    1 java三大特征 1)封装:即class,把一类实体定义成类,该类有变量和方法. 2)继承:从已有的父类中派生出子类,子类实现父类的抽象方法. 3)多态:通过父类对象可以引用不同的子类,从而实现不 ...

  10. java面向对象基础(四):抽象类和接口

    */ .hljs { display: block; overflow-x: auto; padding: 0.5em; color: #333; background: #f8f8f8; } .hl ...

随机推荐

  1. Linux - RAID和LVM

    什么是 RAID 磁盘阵列全名是『 Redundant Arrays of Inexpensive Disks, RAID 』,英翻中的意思是:容错式廉价磁盘阵列. RAID 可以透过一个技术(软件或 ...

  2. OpenCV——PS滤镜,毛玻璃特效

    程序完成 "毛玻璃" 特效, 不过边缘没有处理,使得最终的图像有黑边. 不过,有了黑边,感觉效果也不错,所以这个bug 没有管. #ifndef PS_ALGORITHM_H_IN ...

  3. 苹果新的编程语言 Swift 语言进阶(十)--类的继承

    一.类的继承 类能够从其它类继承方法.属性以及其它特性,当一个类从另外的类继承时,继承的类称为子类,它继承的类称为超类.在Swift中,继承是类区别与其它类型(结构.枚举)的基础行为. 1.1 .类的 ...

  4. c/c++ 表达式求值

    表达式求值 [问题描述] 一个算术表达式是由操作数(operand).运算符(operator)和界限符(delimiter)组成的.假设操作数是正整数,运算符只含加减乘除等四种运算符,界限符有左右括 ...

  5. OpenCV混合高斯模型函数注释说明

    OpenCV混合高斯模型函数注释说明 一.cvaux.h #define CV_BGFG_MOG_MAX_NGAUSSIANS 500 //高斯背景检测算法的默认参数设置 #define CV_BGF ...

  6. linux中syscall调用号查看

    可以用locate查找: locate unistd_32 //或者 locate unistd_64 以下是本猫在ubuntu下返回的结果: /usr/src/linux-headers-3.16. ...

  7. 阅读源码(IV)

    往期系列: <由阅读源码想到> <由阅读源码想到 | 下篇> <阅读源码(III)> Eric S.Raymond的写于2014年的<How to learn ...

  8. SPRING事务的属性有哪些?其中,事务隔离级别有哪几种?什么情况需要使用这几种事务隔离级别?

    Spring 声明式事务,propagation属性列表  PROPAGATION_REQUIRED:支持当前事务,如果当前没有事务,就新建一个事务.这是最常见的选择.  PROPAGATION_SU ...

  9. python函数与装饰器

    一.名字空间与作用域 1.名字空间 名字空间:赋值语句创建了约束,用来存储约束的dict被称为名字空间      赋值语句的行为:1.分别在堆和栈中创建obj与name                 ...

  10. No module named zope.interface error的解决

    明明安装了 zope.interface,还是出现标题错误,错误语句是 from zope.interface import ooxx 根据 http://stackoverflow.com/ques ...