Java基础知识（十六）（面向对象--7）接口

最新推荐文章于 2023-01-11 15:46:54 发布
最新推荐文章于 2023-01-11 15:46:54 发布
阅读量192 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986314/article/details/122550652
版权

1、接口：
      (1)句定义格式：接口使用关键：interface表示
           interface 接口名{}
      (2)接口是如何实现的呢？
          接口不能直接实例化
          那么接口如何去表示呢？
          这里需要另外一个关键字供其他类实现该接口：implements
          使用多态的形式进行实现，由具体的子类进行实例化,其实这是多态的一种，叫做接口多态。
      (3)也可以用一个抽象类去实现

      现在我们将猫狗案例加入钻火圈的功能改写。

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

class Cat extends Animal{

    public Cat() {
    }

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

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

//定义一个钻火圈的接口
interface ZuanHuoQuan{
    void zuanHuo();
}

class TrainCat extends Cat implements ZuanHuoQuan{

    @Override
    public void zuanHuo() {
        System.out.println("猫钻火圈");
    }
}

public class InterfaceDemo1 {
    public static void main(String[] args) {
        //定义出了一个会钻火圈的猫
        Cat c = new TrainCat();
        TrainCat tc = (TrainCat) c;
        tc.zuanHuo();

    }
}


2、 接口中成员的特点：
      (1)成员变量：
                只能是常量，并且是静态的
                JVM在真正运行之前会自动补齐修饰符：public static final
                建议：在学习阶段手动补齐，在开发阶段，省略不写。
     (2)构造方法：
                接口中没有构造方法。
     (3)成员方法：
                接口中的方法只能是抽象方法，没有方法体，连大括号都没有
                JVM在真正运行之前会自动补齐修饰符：public abstract
                建议：在学习阶段手动补齐，在开发阶段，省略不写。

       (4)注意：
        a、当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法
        b、当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可以选择性的实现
        c、接口与接口之间什么关系呢？

interface Inter{
    public static final int a = 10;
//    Inter(){}

    //java: 接口抽象方法不能带有主体
//    public void fun(){
//        System.out.println("玩游戏");
//    }

    public abstract void fun();
    public abstract void fun2();
}

//虽然接口中没有构造方法，但是多态初始化的时候会先初始化父类再初始化子类
//这里其实继承了一个父类
//java中所有的类都有一个父类叫做Object
//每一个class都有Object作为父类
//那么所有继承Object类的子类都拥有了父类Object类中的方法
class Demo extends Object implements Inter{

    @Override
    public void fun() {
        System.out.println("Demo类中实现玩游戏方法");
    }

    @Override
    public void fun2() {
        System.out.println("Demo类中实现玩游戏方法2");
    }
}

abstract class Demo2 implements Inter{
    @Override
    public void fun() {
        System.out.println("抽象类中实现接口抽象方法");
    }
}

public class InterfaceDemo2 {
    public static void main(String[] args) {
        Inter i = new Demo();
        System.out.println(i.a);
//        java: 无法为最终变量a分配值
//        i.a = 100;
        System.out.println(Inter.a);
        i.fun();
    }
}

3、类与类，类与接口，接口与接口的关系
        类与类：
            存在继承关系，只能进行单继承，不可以进行多继承，但是可以是多层继承
        类与接口：
            实现关系，可以是单实现，也可以是一次性实现多个接口，也可以在继承一个类的同时，实现多个接口
        接口与接口：
            存在的是继承关系，可以进行单继承，也可以进行多继承
 


interface Inter2{}
interface Inter3{}
interface Inter4 extends Inter2,Inter3{}

class Demo3 extends Object implements Inter2,Inter3{}


public class InterfaceDemo3 {
}

4、猫狗案例：加入跳高的功能
     分析：
                猫：
                    属性：姓名，年龄
                    行为：吃饭，睡觉
                狗：
                    属性：姓名，年龄
                    行为：吃饭，睡觉
               由于猫和狗存在共性，所以我们提取出来到一个新的类中
               动物：（抽象类）
                    属性：姓名，年龄
                    行为：吃饭(),睡觉()
               猫：继承自动物
               狗：继承自动物

               由于跳高是一个额外的功能，不是动物特有的，所以我们利用接口的方式去定义
               接口：
                        跳高
               部分的猫：实现接口
               部分的狗：实现接口

abstract class Animal4{
    private String name;
    private int age;

    public Animal4() {
    }

    public Animal4(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 Cat4 extends Animal4{
    public Cat4() {
    }

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

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

    @Override
    public void sleep() {
        System.out.println("猫蜷着睡");
    }
}

class Dog4 extends Animal4{

    public Dog4() {
    }

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

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

    @Override
    public void sleep() {
        System.out.println("狗侧着睡");
    }
}

interface Jump{
    public abstract void jump();
}

//定义部分的会跳高的猫
class JumpCat extends Cat4 implements Jump{

    public JumpCat() {
    }

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

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

//定义会跳高的狗
class JumpDog extends Dog4 implements Jump{

    public JumpDog() {
    }

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

    @Override
    public void jump() {
        System.out.println("狗跳高");
    }
}



public class InterfaceDemo4 {
    public static void main(String[] args) {
        //创建一个不会跳高的狗
        Animal4 a1 = new Dog4("小白",2);
        a1.eat();
        a1.sleep();
        //创建一个会跳高的狗
        //抽象多态
        Dog4 d1 = new JumpDog("大白",3);
        d1.eat();
        d1.sleep();
        ((JumpDog) d1).jump();

        //接口多态
        Jump j1 = new JumpDog("小黑",4);
        j1.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);
    }

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

class Student extends Person{
    public Student() {
    }

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

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

class SmokeTeacher extends Teacher implements Smoking{
    public SmokeTeacher() {
    }

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

    @Override
    public void smoke() {
        System.out.println("老师抽烟");
    }
}

class SmokeStudent extends Student implements Smoking{

    public SmokeStudent() {
    }

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

    @Override
    public void smoke() {
        System.out.println("学生抽烟");
    }
}



public class InterfaceDemo5 {
    public static void main(String[] args) {
        //创建一个不抽烟的学生对象
        Person p1 = new Student("阿杰",18);
        p1.eat();
        p1.sleep();
        //ClassCastException
//        ((SmokeStudent)p1).smoke();

        //创建一个抽烟的学生对象
        Person p2 = new SmokeStudent("阿豪",17);
        p2.eat();
        p2.sleep();
        ((SmokeStudent) p2).smoke();
    }
}

6、教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

分析：

由于这个题较为复杂，我们在使用IDEA写代码的时候可以归一归类。


通常情况下，常见会4层：
bean: 一般存放的是将来要new的实体类
controller: 一般是数据的入口类
dao: 具体对数据做操作的地方，放在dao层，这一层一般情况下，都是对数据库做操作的
service: 一般在这里面放的是接口，和实现类。

具体代码如下：

(1)bean中代码：

Person：

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 void show() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

 CoachMan:

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

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

 SportMan:

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

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

BasketballCoachMan：

public class BasketballCoachMan extends CoachMan{
    public BasketballCoachMan() {
    }

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

 BasketballMan:

public class BasketballMan extends SportMan{
    public BasketballMan() {
    }

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

 

(2)service中的代码：

PingPang接口：

public interface PingPang {
    public abstract void studyEnglish();
}

 PingPangSportManImpl： 

import com.shujia.wjj.day12.ketang.interfacedemo.sportdemo.bean.SportMan;

public class PingPangSportManImpl extends SportMan implements PingPang {

    public PingPangSportManImpl() {
    }

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

    @Override
    public void studyEnglish() {
        System.out.println("乒乓球运动员学习英语");
    }
}

PingPangCoachManImpl： 

import com.shujia.wjj.day12.ketang.interfacedemo.sportdemo.bean.CoachMan;

public class PingPangCoachManImpl extends CoachMan implements PingPang {
    public PingPangCoachManImpl() {
    }

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

    @Override
    public void studyEnglish() {
        System.out.println("乒乓球教练学习英语");
    }
}

(3)controller中的代码：

SportManDemo测试类：

import com.shujia.wjj.day12.ketang.interfacedemo.sportdemo.bean.BasketballMan;
import com.shujia.wjj.day12.ketang.interfacedemo.sportdemo.bean.SportMan;
import com.shujia.wjj.day12.ketang.interfacedemo.sportdemo.service.PingPangSportManImpl;

//测试类，测试写的案例
public class SportManDemo {
    public static void main(String[] args) {
        //创建一个乒乓球运动员对象
        SportMan sm = new PingPangSportManImpl("阿豪",18);
        sm.show();
        ((PingPangSportManImpl)sm).studyEnglish();

        //创建一个篮球运动员
        SportMan sm2 = new BasketballMan("阿杰",19);
        sm2.show();
//        ((BasketballMan)sm2).studyEnglish();

    }
}

L缶神
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象知识点总结
buaa_shang的专栏
11-29 1万+
一、类和对象 （1）类：类是模子，确定对象将会拥有的特征(属性)和行为(方法)。 类的特点：类是具有相同属性和方法的一组对象的集合。 （2）对象 创建对象：类名 对象名 = new 类名() 使用对象：对象.属性   /   对象.方法名() （3）成员变量与局部变量 成员变量：在类中定义，用来描述对象将要有什么。（作用域在整个类内部都是可见的） 局部变量：在类的方法中定义，在方法
java面向对象（继承，抽象类，接口知识点概括）
weixin_58623233的博客
11-28 371
继承（单继承方式：即每个子类只能有一个直接父类） ·继承是面向对象程序设计的又一重要特性，是面对对象编程技术的一块基石，因为它允许创建分等级层次的类，继承是可以实现代码复用的重要手段 ·语法规则：【访问权限】class 子类名 extends 父类名； 注：（其中extends是继承关键字，后面跟着父类的类名，如果没有extends子句则这个类直接继承Object。需要注意的是：父类名所指定的类必须是在当前编译单元中可以访问的类，否则会报错） ·覆盖：子类除了可以继承父类中的成员方法和成员变量，还可以
java面向对象知识点
aXiner的博客
04-07 391
一、面向对象三大特征 1.封装性：简而言之，内部操作对外部操作不可见。 2.继承性：子类对父类的继承，（is-a） （1）当派生类继承基类时只会继承其他的函数，不会继承构造函数，但是派生类需要帮助基类构造构造函数 （2）super关键字可以调用父类的构造函数，必须放在派生类的第一行 （3）super.data 可以用来访问基类属性；super.func()可以用来调用基类成员方法 （4）invok...
oop（1）
lijiabin417的博客
11-09 648
面对对象OOP(1) 一、类和对象 1.1、类 1、Java语言最基本单位就是类，类似于类型 2、类是一类事物的抽象 3、可以理解为模板或者设计图纸 1.2、对象 每个对象具有三个特点：对象的状态，对象的行为和对象的标识。 1、对象的状态用来描述对象的基本特征。 2、对象的行为用来描述对象的功能。 3、对象的标识是指对象在内存中都有一个唯一地址，用来和其他对象区分开来。 4、类是一类事物的抽象，对象是具体的实现 1.3、类和对象的关系 1、计算机语言是用来描述现实的。（属性+行为） 2、通过类来描述事物，把
第十一天接口
weixin_48508747的博客
01-17 200
接口：interface 1、语句定义格式：接口使用关键：interface表示 interface 接口名{} 2、接口是如何实现的呢？ 接口不能直接实例化 那么接口如何去表示呢？ 这里需要另外一个关键字供其他类实现该接口：implements 使用多态的形式进行实现，由具体的子类进行实例化,其实这是多态的一种，叫做接口多态。 3、也可以用一个抽象类去实现 现在我们将猫狗案例加入钻火圈的功能改写。 到目前为止，我们学过了三种多态的表现实现： 1、具体的类中的多态 （最后才是具体类的多
Java面向对象知识测试-A卷-答案.doc
11-15
面向对象是Java编程的核心概念，本测试主要涵盖了面向对象的基础知识，包括函数重写、类设计、封装、静态成员、抽象类与接口、构造函数等多个方面。以下是对这些知识点的详细解释： 1. 函数重写（Override）： - ...
java基础知识学习教程-7面向对象.pptx
最新发布
10-30
Java基础知识学习教程-7面向对象 本资源主要讲解Java的面向对象编程基础知识，涵盖继承、包装类、抽象类与接口、内部类、Lambda表达式和枚举等重要概念。 继承是面向对象编程的核心机制，Java中只允许单继承，但是...
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 ...本章内容涵盖了 JAVA 面向对象编程的基础知识，包括定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等，旨在帮助读者掌握 JAVA 面向对象编程的基础知识和技能。
java基础教程----精华版
09-22
以上只是Java基础知识的一部分，实际的Java基础教程会更深入地讲解每个概念，并配有实例来帮助理解。这份"java基础教程----精华版"应该涵盖了这些主题，并且可能还有更多的实践指导和示例代码，对于学习和巩固Java...
Java面向对象（基础）- 属性赋值过程、JavaBean和UML类图
10-24
【Java面向对象基础】属性赋值过程、JavaBean与UML类图 一、属性赋值过程 ...同时，讲解了JavaBean的基本概念和UML类图的构成，这些都是Java面向对象编程中的基础知识，对于理解和编写高质量的Java程序至关重要。
public void setName(String name) { this.name = name; }
weixin_35757531的博客
01-11 580
这是一段 Java 代码。它定义了一个名为 "setName" 的公共方法，接收一个字符串类型的参数 "name"。方法体中的代码为 this.name = name; 表示将传入的 "name" 参数赋值给当前对象的 "name" 属性。 ...
每日一学Java篇
qq_59336423的博客
05-09 727
今天继续学习Java面向对象的内容，一下素材均来自B站尚硅谷。 JavaBean是一种Java语言写成的可重用组件 所谓JavaBean，是指符合如下标准的Java类； > 类是公共的 > 有一个无参的公共的构造器 > 有属性，且有对应的get、set方法 public class Customer { private int id; private String name; public Customer(){ ...
Java 面向对象基础
今天我学废了吗
08-01 331
万物皆对象，客观存在的事物皆为对象在计算机里，对象是计算机中具体的数据信息对于计算机，相当于一个人关注事物的信息，我们了解一个事物的信息，并且关注她，这个动作叫做面向对象面向对象编程实际上是面向一个具体的对象进行操作类是对现实生活中一类具有共同属性和行为的事物的抽象类的特点●类是对象的数据类型●类是具有相同属性和行为的一组对象的集合属性对象具有的各种特征，每个对象的每个属性都拥有特定的值行为对象能够执行的操作类的重要性是Java程序的基本组成单位类是什么属性和行为●属性成员变量。.........
public void setName(String name)
u012402926的专栏
07-11 6705
public void setName(String name) { 　　this.name = name; 　　} 　　public int getAge() { 　　return age; 　　} 　　public void setAge(int age) { 　　this.age = age; 　　} 　　public void cry(){ 　　System.out.p
新手学习java（五）
baidu_41612355的博客
09-13 292
在第五天的时候，学习了private关键字的使用，今天首先来对它进行简单的运用 我们先定义一个学生类 public class Student { //成员变量 private String name; private int age; //get/set方法 public void setName(String n){ name=n; } public String getName(){ return name;
void关键字的作用java_Java中的关键字void有什么作用?具体用法?
weixin_28935433的博客
02-25 1120
Java中的关键字void用在不需要return，也就是不需要返回一个类型变量的时候。比如：1、static void main(String[] args)这里的主函数就不需要return任何变量，所以使用void修饰。2、public void setName(String name)该方法只需要对该类的成员变量进行赋值即可，不需要返回任何变量，如果return一个变量反而会出错。但是这里有一...
java中用于设置值的方法_包含String实例变量和用于在Java中设置和获取其值的方法的类...
weixin_35632603的博客
02-27 929
类声明可以包含String实例和方法来设置和获取Java中的值。演示此过程的程序如下：示例className{privateStringname;publicvoidsetName(Stringn){name=n;}publicStringgetName(){returnname;}}publicclassDemo{publicstaticvoidmain(...
一个JAVA新手问题，关于setName和getName
热门推荐
别样的风采是我
08-29 1万+
package com.edu.ch7; public class Book { private String name; public String getName(){ //获取属性 int id = 0; setName("java"); return id+this.name; } public void setName(String name){ /
java set name,void setName(String name)
weixin_29243279的博客
03-11 889
void setName(String name)描述 (Description)java.lang.Thread.setName()方法将此线程的名称更改为等于参数name 。声明 (Declaration)以下是java.lang.Thread.setName()方法的声明public final void setName(String name)参数 (Parameters)name - 这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值