Java：接口

最新推荐文章于 2022-06-15 10:36:28 发布

一颗车厘子854

最新推荐文章于 2022-06-15 10:36:28 发布

阅读量249

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_63531507/article/details/122523402

版权

1、接口概述：

就是一种公共的规范标准，只要符合规范标准，大家都可以通用，Java接口更多体现在对行为的抽象；

2、接口的特点：

1、接口用关键字interface来修饰：public interface 接口名{}

2、类实现接口用implements表示：public class implements 类名{}

3、接口不能实例化：想要实例化就参照多态的方式，实现类实例化，叫接口多态；

多态的形式：具体类多态，抽象类多态，接口多态；

多态的前提：有继承或者实现的关系，有方法的重写，有父类引用指向子类对象；

4、接口的实现类：要么重写接口的方法，要么是抽象类；

interface Catch{
    public abstract void show();
}
class Cat3 implements Catch {
    @Override
    public void show() {
        System.out.println("猫抓老鼠");
    }
}
abstract class Dog3 implements Catch{}

public class Joogle {
    public static void main(String[] args) {
        Catch catch1=new Cat3();
        catch1.show();
//        猫抓老鼠
    }
}

3、接口成员的特点：

1、成员变量：只能是常量,默认被public static final修饰；

2、构造方法：接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在，一个类如果没有父类默认继承Object类，

3、成员方法：只能是抽象方法，默认修饰符：public abstract；

class ChenyuanImpl extends Object implements Chenyuan {
    //   和 class ChenyuanImpl implements Chenyuan{}效果一样
    public ChenyuanImpl() {
        super();
    }

    @Override
    public void show1() {

    }

    @Override
    public void show2() {

    }
}

public class Joogle1 {
    public static void main(String[] args) {
        Chenyuan chenyuan = new ChenyuanImpl();
        System.out.println(chenyuan.num1);
//        10
        System.out.println(chenyuan.num2);
//        20
        System.out.println(Chenyuan.num1);
//        10
        System.out.println(Chenyuan.num2);
//        20
    }
}

猫狗案例：

需求：对猫和狗进行训练，他们就可以游泳了，加入了游泳功能，请采用抽象类和接口来实现猫狗案例。

思路分析：

1、定义接口:(Swimming) 成员方法：游泳()；

2、定义抽象动物类(Animal3):

成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set,吃饭；

3、定义具体的猫类(Cat4):

构造方法：无参，带参；重写成员方法；

4、定义具体的狗类(Dog4):

构造方法：无参，带参；重写成员方法；

5、定义测试类：写代码测试

package com.one;
abstract class Animal3{
    private String name;
    private int age;

    public Animal3() {
    }

    public Animal3(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();
}
interface Swimming{
    void swim();
}
class Cat4 extends Animal3 implements Swimming{
    public Cat4() {
    }

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

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void swim() {
        System.out.println("猫会游泳");
    }
}
class Dog4 extends Animal3 implements Swimming{
    public Dog4() {
    }

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

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗会游泳");
    }
}
public class Joogle2 {
    public static void main(String[] args) {
        Animal3 animal3=new Cat4();
        animal3.setAge(2);
        animal3.setName("英短");
        System.out.println(animal3.getAge()+"岁"+","+animal3.getName());
        animal3.eat();
        Swimming swimming=new Cat4();
        swimming.swim();
//        2岁,英短
//        猫吃鱼
//        猫会游泳
        System.out.println("==================");
        Cat4 c=new Cat4();
        c.setName("加菲");
        c.setAge(3);
        System.out.println(c.getAge()+"岁"+","+c.getName());
        c.eat();
        c.swim();
//        3岁,加菲
//        猫吃鱼
//        猫会游泳
        System.out.println("==================================");
        Animal3 animal31=new Dog4();
        animal31.setName("萨摩");
        animal31.setAge(3);
        System.out.println(animal31.getAge()+"岁"+","+animal31.getName());
        animal31.eat();
        Swimming swimming1=new Dog4();
        swimming1.swim();
//        3岁,萨摩
//        狗吃骨头
//        狗会游泳
        System.out.println("==================");
        Dog4 d=new Dog4();
        d.setName("二哈");
        d.setAge(4);
        System.out.println(d.getAge()+"岁"+","+d.getName());
        d.eat();
        d.swim();
//        4岁,二哈
//        狗吃骨头
//        狗会游泳

    }
}

 老师和学生案例,加入打游戏的额外功能

 分析：
     老师：
         属性：姓名，年龄
         行为：吃饭，睡觉
     学生：
         属性：姓名，年龄
         行为：吃饭，睡觉

     由于老师和学生有着共性内容，提取出来一个抽象类

     人：（抽象类）
         属性：姓名，年龄
         行为：吃饭(),睡觉()
由于不是所有的老师和学生都打游戏，只有部分的老师和学生会
所以，我们将抽烟定义为一个接口
     部分的老师：实现打游戏接口
     部分的学生：实现打游戏的接口

package com.one;
abstract class Person1{
    private String name;
     private int age;
     public Person1(){}

    public Person1(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 abstract void sleep();
}
class Teacher1 extends Person1{
    public Teacher1(){}

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

    @Override
    public void eat() {
        System.out.println("老师吃牛肉");
    }

    @Override
    public void sleep() {
        System.out.println("老师睡的早");
    }
}
class Student2 extends Person1{
    public Student2(){}

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

    @Override
    public void eat() {
        System.out.println("学生喝粥");
    }

    @Override
    public void sleep() {
        System.out.println("学生睡不好");
    }
}
interface PlayLOl{
    public void play();
}
class StudentImpl extends Student2 implements PlayLOl{
    public StudentImpl(){}

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

    @Override
    public void play() {
        System.out.println("学生玩英雄联盟");
    }
}
class Teacher1Impl extends Teacher1 implements PlayLOl{
    public Teacher1Impl(){}

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

    @Override
    public void play() {
        System.out.println("老师玩英雄联盟");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person1 p1=new Student2("小黑",15);
        p1.eat();
        p1.sleep();
        Person1 p2=new StudentImpl("大黑",18);
        ((StudentImpl)p2).play();
//        学生喝粥
//        学生睡不好
//        学生玩英雄联盟
        new Teacher1Impl().eat();
        new Teacher1Impl().sleep();
        ((Teacher1Impl)new Teacher1Impl("小白",18)).play();
//        老师吃牛肉
//        老师睡的早
//        老师玩英雄联盟
    }
}

4、接口和类的关系：

1、类和类的关系：继承关系，只能单继承，但是可以多层继承

2、类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3、接口和接口的关系：继承关系，可以单继承，也可以多继承

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

1、成员区别：

抽象类：变量，常量，构造方法，抽象方法和非抽象方法；

接口：常量，抽象方法；

2、关系区别

类与类：继承，单继承

类和接口：实现，可以多实现，也可以单实现

接口和接口：可以单继承，也可以多继承

3、设计理念区别：

抽象类：对类抽象，包括属性和行为；

接口：主要是行为

将来我们更多的面向接口开发
将代码进行分类开发，会提高我们开发效率和排错效率
通常情况下，常见会4层：
bean: 一般存放的是将来要new的实体类
controller: 一般是数据的入口类
dao: 具体对数据做操作的地方，放在dao层，这一层一般情况下，都是对数据库做操作的
service: 一般在这里面放的是接口，和实现类。

package com.one;
//bean: 一般存放的是将来要new的实体类
abstract class People{
    private String name;
    private int age;
    public People(){}

    public People(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 abstract void sleep();
}

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

    @Override
    public void eat() {
        System.out.println("篮球运动员吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("篮球运动员睡觉");
    }
}
class PingpangPlayer extends People{
    public PingpangPlayer() {
    }
    public PingpangPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃饭");
    }
    @Override
    public void sleep() {
        System.out.println("乒乓球运动员睡觉");
    }
}
class BasketballCacoh extends People{
    public BasketballCacoh() {
    }

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

    @Override
    public void eat() {
        System.out.println("篮球教练吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("篮球教练睡觉");
    }
}
class PingPangCaoch extends People{
    public PingPangCaoch(){}

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

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("乒乓球教练睡觉");
    }
}
//service: 一般在这里面放的是接口，和实现类。
interface StudyEnglish{
    public  abstract void study();
}
class PingpangPlayerImpl extends PingpangPlayer implements StudyEnglish{
    public PingpangPlayerImpl() {
    }

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

    @Override
    public void study() {
        System.out.println("乒乓球运动员学英语");
    }
}
class PingpangCoachIpml extends PingPangCaoch implements StudyEnglish{
    public PingpangCoachIpml() {}

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

    @Override
    public void study() {
        System.out.println("乒乓球教练学英语");
    }
}
//controller: 一般是数据的入口类
public class Sport {
    public static void main(String[] args) {
        People a=new BasketballPlayer("小黑",18);
        a.eat();
        a.sleep();
        People b=new BasketballCacoh("大黑",30);
        b.sleep();
        b.eat();

        new PingpangCoachIpml().eat();
        new PingpangCoachIpml().sleep();
        ((PingpangCoachIpml)new PingpangCoachIpml("大白",35)).study();

        new PingpangPlayerImpl().eat();
        new PingpangPlayerImpl().sleep();
        ((PingpangPlayerImpl)new PingpangPlayerImpl("小白",17)).study();
    }
}