0
点赞
收藏
分享

微信扫一扫

Java学习 - 黑马（第二部分） - 随堂笔记 - 05_接口

洛茄 2022-04-15 阅读 63
java学习idea

Java学习 - 黑马（第二部分） - 随堂笔记 - 05_接口

1. 接口

在这里插入图片描述

在这里插入图片描述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

Java中的接口更多的体现在对行为的抽象

1.2 接口的特点

  • 接口用关键字interface修饰
    • public interface 接口名{}
  • 类实现接口用implements表示
    • public class 类名 implements 接口名{}
  • 接口不能实例化？
    • 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
    • 多态的形式：具体类多态，抽象类多态，接口多态
    • 多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
  • 接口的实现类
    • 要么重写接口中的所有抽象方法
    • 要么是抽象类
package com.itheima_01;

public interface Jumpping {
    public abstract void jump();
}

package com.itheima_01;

public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}

package com.itheima_01;

public abstract class Dog implements Jumpping{

}

package com.itheima_01;
//测试类
public class JumppingDemo {
    public static void main(String[] args) {
        //Jumpping j = new Jumpping();//报错，接口不能直接实例化
        Jumpping j = new Cat();
        j.jump();
    }
}

1.3 接口的成员特点

  • 成员变量
    • 只能是常量
    • 默认修饰符：public static final
  • 构造方法
    • 接口没有构造方法，因为接口只要是对行为进行抽象的，是没有具体存在
    • 一个类如果没有父类，默认继承Object类
  • 成员方法
    • 只能是抽象方法
    • 默认修饰符：public abstract
    • 关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解
package com.itheima_02;

//public class InterImpl implements Inter等价于
public class InterImpl extends Object implements Inter{
    public InterImpl(){
        super();
    }

    @Override
    public void method() {
        System.out.println("method");
    }

    @Override
    public void show() {
        System.out.println("show");
    }
}

package com.itheima_02;

public interface Inter {
    public int num = 10;
    public final int num2 = 20;
    //public static final int num3 = 30;//相当于
    int num3 = 30;

    //public Inter(){}//接口不能构造方法

    //public void show(){}//报错，接口不能有非抽象方法

    public abstract void method();
    void show();//默认带public abstract
}

package com.itheima_02;
//测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        System.out.println(i.num);
        //i.num = 20;//报错，接口里面默认被final修饰
        System.out.println(i.num2);
        //i.num2 = 40;//报错，被final修饰
        System.out.println(Inter.num);//默认被静态修饰
    }
}

案例：猫和狗（接口版）

需求：对猫和狗进行训练，他们就可以跳高了，这里加入了跳高功能。请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试

思路：

  1. 定义接口（Jumpping）

    成员方法：跳高();

  2. 定义抽象动物类（Animal）

    成员变量：姓名，年龄；

    构造方法：无参，带参；

    成员方法：get/set方法，吃饭();

  3. 定义具体猫类（Cat），继承动物类，实现跳高接口

    构造方法：无参，带参；

    成员方法：重写吃饭(){…},重写跳高方法(){…}

  4. 定义狗类（Dog），继承动物类，实现跳高接口

    构造方法：无参，带参；

    成员方法：重写吃饭(){…},重写跳高方法(){…}

  5. 定义测试类（AnimalDemo），写代码测试

package com.itheima_03;

public interface Jumpping {
    void jump();
}

package com.itheima_03;

public 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();
}

package com.itheima_03;

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("狗跳高");
    }
}

package com.itheima_03;

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 com.itheima_03;

import javax.print.attribute.standard.JobKOctets;

public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("---------");

        Animal a = new Cat();
        a.setName("噬元兽");
        a.setAge(100);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        //a.jump();//报错
        System.out.println("-------------");

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("=============");

        Cat c = new Cat();
        c.setName("汤姆");
        c.setAge(6);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
        System.out.println("++++++++++++");

        //创建Dog对象，调用方法
        Jumpping jk = new Dog();
        jk.jump();
        System.out.println("---------");

        Animal b = new Dog();
        b.setName("高飞");
        b.setAge(99);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
        //b.jump();//报错
        System.out.println("-------------");

        b = new Dog("眼镜狗",10);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
        System.out.println("=============");

        Dog d = new Dog();
        d.setName("杰克");
        d.setAge(8);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.jump();
    }
}

1.4 类和接口的关系

  • 类和类的关系
    • 继承关系，只能单继承，但是可以多层继承
  • 类和接口的关系
    • 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
  • 接口和接口的关系
    • 继承关系，可以单继承，也可以多继承
package com.itheima_04;

public interface Inter1 {
}

package com.itheima_04;

public interface Inter2 {
}

package com.itheima_04;

public interface Inter3 extends Inter1,Inter2{
}

package com.itheima_04;

public class InterImpl extends Object implements Inter1,Inter2,Inter3{
}

1.5 抽象类和接口的区别

  • 成员区别
    • 抽象类：变量，常量；有构造方法，有抽象方法，也有非抽象方法
    • 接口：常量；抽象方法
  • 关系区别
    • 类与类：继承，单继承
    • 类与接口：实现，可以单实现，也可以多实现
    • 接口与接口：继承，单继承，多继承
  • 设计理念区别
    • 抽象类：对类抽象，包括属性、行为
    • 接口：对行为抽象，主要是行为

门和警报的例子

门：都有open()和close()两个动作，这个时候我们可以使用抽象类和接口来定义这个抽象概念

//抽象类
public abstract class Door{
	public abstract void open();
	public abstract void close();
}

//接口
public interface Door{
	void open();
	void close();
}

第一种方案，都放在抽象类中

//抽象类
public abstract class Door{
	public abstract void open();
	public abstract void close();
	public abstract void alarm();
}

第二种方案，都放在接口中

//接口
public interface Door{
	void open();
	void close();
	void alarm();
}

上面两种方案都不太好

public interface Alarm{
	void alarm();
}
public abstract class Door{
	public abstract void open();
	public abstract void close();
}
public class AlarmDoor extends Door implements Alarm{
	public void open(){
	//...
	}
	public void close(){
	//...
	}
	public void alarm(){
	//...
	}
}

在这里，我们再次强调抽象类是对事物的抽象，而接口是对行为的抽象

案例：运动员和教练

需求：我们现在有乒乓球运动员和篮球运动员、乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现

分析：从具体到抽象

​ 乒乓球运动员

​ 篮球运动员

​ 乒乓球教练

​ 篮球教练

在这里插入图片描述

实现：从抽象到具体

使用：使用的是具体的类的对象

思路：

  1. 定义说英语接口
    1. 成员方法：说英语();
  2. 定义抽象人类
    1. 成员变量：姓名、年龄；
    2. 构造方法：无参、带参；
    3. 成员方法：get/set方法，吃饭()；
  3. 定义抽象教练类，继承人类
    1. 构造方法：无参、带参；
    2. 成员方法：教();
  4. 定义抽象运动员类，继承人类
    1. 构造方法：无参、带参；
    2. 成员方法：学习();
  5. 定义具体篮球教练类，继承教练类
    1. 构造方法：无参、带参；
    2. 成员方法：重写吃饭(){…},重写教(){…}
  6. 定义具体乒乓球教练类，继承教练类，实现说英语接口
    1. 构造方法：无参、带参；
    2. 成员方法：重写吃饭(){…},重写教(){…}，重写说英语(){…}
  7. 定义具体篮球运动员类，继承运动员类
    1. 构造方法：无参、带参；
    2. 成员方法：重写吃饭(){…},重写学习(){…}
  8. 定义具体乒乓球运动员类，继承运动员类，实现说英语接口
    1. 构造方法：无参、带参；
    2. 成员方法：重写吃饭(){…},重写学习(){…}，重写说英语(){…}
  9. 定义测试类，写代码测试
package com.itheima_05;
//说英语的接口
public interface SpeakEnglish {
    public abstract void speak();
}

package com.itheima_05;

public 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();
}

package com.itheima_05;

public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

package com.itheima_05;

public abstract class Player extends Person{
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

package com.itheima_05;

public class PingpangCoach extends Coach implements SpeakEnglish {
    public PingpangCoach() {
    }

    public PingpangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何接发球");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练会说英语");
    }
}

package com.itheima_05;

public class PingpangPlayer extends Player implements SpeakEnglish{

    public PingpangPlayer() {
    }

    public PingpangPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何接发球");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员会说英语" );
    }
}

package com.itheima_05;

public class BasketballCoach extends Coach{
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
}

package com.itheima_05;

public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
}


package com.itheima_05;

import java.util.SortedMap;

public class PersonDemo {
    public static void main(String[] args) {
        //创建对象
        PingpangPlayer ppp = new PingpangPlayer();
        ppp.setName("马龙");
        ppp.setAge(35);
        System.out.println(ppp.getName() + "," + ppp.getAge());
        ppp.eat();
        ppp.speak();
        ppp.study();
        System.out.println("-----------");

        ppp = new PingpangPlayer("王皓",45);
        System.out.println(ppp.getName() + "," + ppp.getAge());
        ppp.eat();
        ppp.speak();
        ppp.study();
        System.out.println("++++++++++++");

        PingpangCoach pingpangCoach = new PingpangCoach();
        pingpangCoach.setName("刘国梁");
        pingpangCoach.setAge(50);
        System.out.println(pingpangCoach.getName()+","+pingpangCoach.getAge());
        pingpangCoach.eat();
        pingpangCoach.speak();
        pingpangCoach.teach();
        System.out.println("---------------");

        pingpangCoach = new PingpangCoach("王楠",50);
        System.out.println(pingpangCoach.getName()+","+pingpangCoach.getAge());
        pingpangCoach.eat();
        pingpangCoach.speak();
        pingpangCoach.teach();
        System.out.println("==================");

        BasketballPlayer basketballPlayer = new BasketballPlayer();
        basketballPlayer.setName("姚明");
        basketballPlayer.setAge(40);
        System.out.println(basketballPlayer.getName()+","+basketballPlayer.getAge());
        basketballPlayer.eat();
        basketballPlayer.study();
        System.out.println("---------------");

        basketballPlayer = new BasketballPlayer("科比",35);
        System.out.println(basketballPlayer.getName()+","+basketballPlayer.getAge());
        basketballPlayer.eat();
        basketballPlayer.study();
        System.out.println("++++++++++++++");

        BasketballCoach basketballCoach = new BasketballCoach();
        basketballCoach.setName("刘维伟");
        basketballCoach.setAge(40);
        System.out.println(basketballCoach.getName()+","+basketballCoach.getAge());
        basketballCoach.eat();
        basketballCoach.teach();
        System.out.println("----------------");

        basketballCoach = new BasketballCoach("老K",56);
        System.out.println(basketballCoach.getName()+","+basketballCoach.getAge());
        basketballCoach.eat();
        basketballCoach.teach();


    }
}
举报

相关推荐

Java学习 - 黑马（第二部分） - 随堂笔记 - 06_形参和返回值

java学习idea

JavaEE学习的第二部分

http网络web安全网络安全

【hibernate框架】EJBQL第二部分

hibernate框架sessionEJBQLHQLHtml/CSS前端开发

R语言——taxize（第二部分）

python软件测试自动化测试request库https测试工具职场和发展

第二部分Flink快速应用

flink大数据java

MySQL学习第二部分：事务的理解

mysql学习数据库

TypeScript 学习笔记 第二部分 webpack 创建typescript项目

前端webhtmlcss

MVC购物车第二部分

mvcbootstrapjava

华为数据之道第二部分导读

c#c++c语言pythonjava

OpenCV For Python系列教程（第二部分）

opencvpython计算机视觉
0 条评论