1.接口概述
- 概述
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
java中的接口更多的体现在对行为的抽象。
2.接口的特点
- 接口用关键字
interface修饰
public interface 接口名{}
- 类实现接口用implement表示
public class 类名 implement 接口名{}
- 接口不能实例化
接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
- 接口的形式
具体类多态，抽象类多态，接口多态
- 多态的前提：
有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
- 接口的实现类
要么重写接口中的所有抽象方法
要么是抽象类
//接口Jumpping
package Interface.study01;
/*定义了一个接口*/
public interface Jumpping {
public abstract void Jump();
}
//子类Cat
package Interface.study01;
public class Cat implements Jumpping{
@Override
public void Jump() {
System.out.println("猫可以跳高了");
}
}
//测试类
package Interface.study01;
public class JumppingDemo {
public static void main(String[] args) {
// Jumpping j = new Jumpping();
Jumpping cat = new Cat();
cat.Jump();
}
}
3.接口的成员特点
- 成员变量
只能是常量
默认修饰符：public static final
- 构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
一个类如果没有父类，默认继承自Object类
- 成员方法
只能是抽象方法
默认修饰符：public abstract
1.案例：猫和狗（接口版）
需求：对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。
思路：
① 定义接口（Jumpping)
成员方法：跳高();
② 定义抽象动物类（Animal）
成员变量：姓名，年龄；构造方法：带参，无参；get/set方法，吃饭（）；
③ 定义具体猫类（Cat），基础动物类，实现跳高接口
构造方法：带参，无参；成员方法：重写吃饭(){……}，重写跳高(){……}
④ 定义具体狗类（Dog），基础动物类，实现跳高接口
构造方法：带参，无参；成员方法：重写吃饭(){……}，重写跳高(){……}
⑤ 定义测试类(AnimalDemo),写代码测试。
//接口
package Interface.study02;
/*接口*/
public interface Jumpping {
public abstract void jump();
}
//父类
package Interface.study02;
/*父类*/
public abstract class Animal {
private String name;
private int age;
public Animal(){
}
public Animal(String name,int age){
this.age = age;
this.name = name;
}
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public abstract void eat();
}
//子类Dog
package Interface.study02;
public class Dog extends Animal implements Jumpping{
public Dog(){
}
public Dog(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println("狗吃");
}
@Override
public void jump() {
System.out.println("狗跳");
}
}
//子类Cat
package Interface.study02;
public class Cat extends Animal implements Jumpping{
public Cat(){
}
public Cat(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println("猫吃");
}
@Override
public void jump() {
System.out.println("猫跳");
}
}
//测试类
package Interface.study02;
import java.util.concurrent.Callable;
public class AnimalDemo {
public static void main(String[] args) {
//猫：
//创建对象，调用方法-------接口
Jumpping cat = new Cat();
cat.jump();
System.out.println("----------------");
//创建对象，调用方法------继承
Animal z = new Cat();
z.setName("小猫");
z.setAge(5);
System.out.println(z.getName()+","+z.getAge());
z.eat();
// a.jump();------报错
System.out.println("----------------");
//创建对象，调用方法
Cat q = new Cat("小猫咪",5);
q.eat();
q.jump();
System.out.println(q.getName()+","+q.getAge());
System.out.println("----------------");
//狗：
//创建对象，调用方法-------接口
Jumpping u = new Dog();
u.jump();
System.out.println("----------------");
//创建对象，调用方法------继承
Animal a = new Dog();
a.setName("小dog1");
a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
// a.jump();------报错
System.out.println("----------------");
//创建对象，调用方法
Dog k = new Dog("小dog2",5);
k.eat();
k.jump();
System.out.println(k.getName()+","+k.getAge());
System.out.println("------------------");
}
}
4.类和接口的关系
- 类和类的关系
继承关系，只能单继承，但是可以多层继承。
- 类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
- 接口和接口的关系
继承关系，可以单继承，也可以多继承
//inter1
package Interface.study03;
public interface inter1 {
}
//inter2
package Interface.study03;
public interface inter2 {
}
//inter3
package Interface.study03;
/*
1.接口和接口的关系
继承关系，可以单继承，也可以多继承
*/
public interface inter3 extends inter1,inter2{
}
//interImp
package Interface.study03;
/* 1. 类和类的关系
继承关系，只能单继承，但是可以多层继承。
2.类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。*/
public class interImp extends Object implements inter1,inter2,inter3{
}
5. 抽象类和接口的区别
- 语法层面的区别
- 成员区别
抽象类：变量，常量，构造方法，抽象方法，非抽象方法
接口：常量，抽象方法
- 关系区别
类与类：继承，单继承
类与接口：实现，可以单实现，也可以多实现
接口与接口：继承，单继承，多继承
- 设计理念区别
抽象类：对类抽象，包括属性，行为。
接口：对行为抽象，主要是行为。
抽象类是对事物的抽象，而接口是对行为的抽象。
1.案例：运动员和教练
-
需求：我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口。并用代码实现。
-
分析：从具体到抽象
- 实现：从抽象到具体
- 使用：使用的是具体的类和对象
//English接口
package Interface.study04;
/*接口*/
public interface English {
//english成员方法
public abstract void english();
}
//人类抽象类human
package Interface.study04;
/*人类抽象类*/
public abstract class human {
//成员变量
private String name;
private int age;
//无参构造方法
public human(){
}
//带参构造方法
public human(String name,int age){
this.name = name;
this.age = age;
}
//set、get方法
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
//eat成员方法
public abstract void eat();
}
//运动员抽象类jock
package Interface.study04;
/*运动员抽象类*/
public abstract class jock extends human{
//无参构造方法
public jock(){
}
//带参构造方法
public jock(String name,int age){
super(name, age);
}
//成员方法
public void study(){
System.out.println("学习");
}
}
//教练抽象类Teacher
package Interface.study04;
/*教练抽象类*/
public abstract class Teacher extends human{
//无参构造方法
public Teacher(){
}
//带参构造方法
public Teacher(String name,int age){
super(name,age);
}
//成员方法
public void teach(){
System.out.println("教");
}
}
//篮球教练具体类BasketballCoach
package Interface.study04;
/*篮球教练具体类*/
public class BasketballCoach extends Teacher{
//无参构造方法
public BasketballCoach(){
}
//带参构造方法
public BasketballCoach(String name,int age){
super(name,age);
}
//重写eat方法
@Override
public void eat() {
System.out.println("篮球教练吃饭");
}
//重写teach方法
@Override
public void teach() {
System.out.println("篮球教练教课");
}
}
//篮球运动员具体类BasketballJock
package Interface.study04;
/*篮球运动员具体类*/
public class BasketballJock extends jock{
//无参构造方法
public BasketballJock(){
}
//带参构造方法
public BasketballJock(String name,int age){
super(name,age);
}
//重写eat方法
@Override
public void eat() {
System.out.println("篮球运动员吃饭");
}
//重写study方法
@Override
public void study() {
System.out.println("篮球运动员学习");
}
}
//乒乓球教练具体类PingPangCoach
package Interface.study04;
/*乒乓球教练具体类*/
public class PingPangCoach extends Teacher implements English{
//重写english方法
@Override
public void english() {
System.out.println("学习英语");
}
//无参构造方法
public PingPangCoach(){
}
//带参构造方法
public PingPangCoach(String name,int age){
super(name, age);
}
//重写eat方法
@Override
public void eat() {
System.out.println("乒乓球教练吃饭");
}
//重写teach方法
@Override
public void teach() {
System.out.println("乒乓球教练教课");
}
}
//乒乓球运动员具体类PingPangJock
package Interface.study04;
/*乒乓球运动员具体类*/
public class PingPangJock extends jock implements English{
//重写english方法
@Override
public void english() {
System.out.println("乒乓球远动员学习英语");
}
//无参构造方法
public PingPangJock(){
}
//带参构造方法
public PingPangJock(String name,int age){
super(name, age);
}
//重写eat方法
@Override
public void eat() {
System.out.println("乒乓球运动员吃饭");
}
//重写study方法
@Override
public void study() {
System.out.println("乒乓球运动员学习");
}
}
//测试类testDemo
package Interface.study04;
/*测试类*/
public class testDemo {
public static void main(String[] args) {
// 篮球教练
BasketballCoach basketballCoach = new BasketballCoach();
basketballCoach.setName("李明");
basketballCoach.setAge(20);
System.out.println(basketballCoach.getName()+","+basketballCoach.getAge());
basketballCoach.eat();
basketballCoach.teach();
System.out.println("====================");
// 篮球运动员
BasketballJock basketballJock = new BasketballJock("帅帅",15);
System.out.println(basketballJock.getName()+","+basketballJock.getAge());
basketballJock.eat();
basketballJock.study();
System.out.println("====================");
// 乒乓球教练
PingPangCoach pingPangCoach = new PingPangCoach();
pingPangCoach.setName("黎明");
pingPangCoach.setAge(30);
pingPangCoach.eat();
pingPangCoach.teach();
pingPangCoach.english();
System.out.println("====================");
// 乒乓球运动员
PingPangJock pingPangJock = new PingPangJock("李铭",16);
System.out.println(pingPangJock.getName()+","+pingPangJock.getAge());
pingPangJock.eat();
pingPangJock.study();
pingPangJock.english();
System.out.println("====================");
}
}
PingPangCoach pingPangCoach = new PingPangCoach();
pingPangCoach.setName(“黎明”);
pingPangCoach.setAge(30);
pingPangCoach.eat();
pingPangCoach.teach();
pingPangCoach.english();
System.out.println("====================");
// 乒乓球运动员
PingPangJock pingPangJock = new PingPangJock(“李铭”,16);
System.out.println(pingPangJock.getName()+","+pingPangJock.getAge());
pingPangJock.eat();
pingPangJock.study();
pingPangJock.english();
System.out.println("====================");
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
