抽象类和接口

于 2022-03-28 12:59:58 发布
阅读量383 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/msn131420/article/details/123744715
版权

一、抽象类

1.1抽象类概述--抽象方法和抽象类

抽象类是一个不具体的类，不能描述出一个完整对象。

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

public abstract class Animal {

    /*
    public void eat() {
        System.out.println("吃东西");
    }
    */

    public abstract void eat();

}


/*
    测试类
 */
public class AnimalDemo {

    public static void main(String[] args) {
        /*
        Animal a = new Animal();
        a.eat();
        */
    }

}

1.2抽象类的特点

  • 抽象类和抽象方法必须使用 abstract 关键字修饰

// 抽象类的定义
public abstract class 类名 {}
// 抽象方法的定义
public abstract void eat ();
  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 抽象类不能实例化
    抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态
  • 抽象类的子类
    要么重写抽象类中的所有抽象方法
    要么是抽象类

1.3抽象类的成员特点

抽象类中成员特点：可以有成员变量、常量，有构造方法，有抽象和非抽象方法

  • 成员变量

可以是变量

也可以是常量

  • 构造方法

有构造方法，但是不能实例化

那么，构造方法的作用是什么呢？用于子类访问父类数据的初始化

  • 成员方法

可以有抽象方法：限定子类必须完成某些动作

也可以有非抽象方法：提高代码复用性

案例：猫和狗

需求：
请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

思路：

1 、定义动物类 (Animal)
成员变量：姓名，年龄
构造方法：无参，带参
成员方法： get/set 方法，吃饭（）；
2 、定义猫类 (Cat) ，继承动物类
构造方法：无参，带参
成员方法：重写吃饭 (){...} 
3 、定义狗类 (Dog) ，继承动物类
 构造方法：无参，带参
成员方法：重写吃饭 (){...} 
4 、定义测试类 (AnimalDemo) ，写代码测试

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


public class Cat extends Animal {

    public Cat() {
    }

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

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


public class Dog extends Animal {

    public Dog() {
    }

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

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


/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，按照多态的方式
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");

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

二、接口

2.1接口的概述

概述：接口就是一种公共规范标准，只要符合规范标准，大家可以通用；

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

2.2接口的特点

  1. 接口用关键字 interface修饰                                                                                                  public interface 接口名 {}
  2. 类实现接口用implements （类实现接口就像类继承类）                                                        public class 类名 implements 接口名 {}
  3. 接口不能直接实例化
         接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
         多态的形式：具体类多态，抽象类多态，接口多态。

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

        4.接口实现类（相当于继承的子类）

              要么重写接口中所有方法

              要么是抽象类

2.3接口的成员特点

  • 成员变量：
      只能是常量
      默认修饰符： public static final
  • 构造方法：

接口没有构造方法，因为接口主要对行为进行抽象，没有具体存在

如果一个类没有父类，默认继承Object类

  • 成员方法

只能是抽象方法

默认修饰符 public abstract

案例：猫和狗

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

思路：

1、定义接口（Jumpping）

成员方法：跳高（）；

1 、定义抽象动物类 (Animal)
成员变量：姓名，年龄
构造方法：无参，带参
成员方法： get/set 方法，吃饭（）；
2 、定义猫类 (Cat) ，继承动物类，实现跳高接口
构造方法：无参，带参
成员方法：重写吃饭 (){...} ，重写跳高方法(){...}
3 、定义狗类 (Dog) ，继承动物类，实现跳高接口
 构造方法：无参，带参
成员方法：重写吃饭 (){...} ，重写跳高方法(){...}
4 、定义测试类 (AnimalDemo) ，写代码测试
 

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



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




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("猫可以跳高了");
    }
}


/*
    测试类
 */
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(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
//        a.jump();

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

        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

2.4类和接口的关系

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

2.5抽象类和接口的区别

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

案例：运动员和教练 

//抽象人类
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();
}


//抽象运动员类
public abstract class Player extends Person {
    public Player() {
    }

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

    public abstract void study();
}



//抽象教练类
public abstract class Coach extends Person {
    public Coach() {
    }

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

    public abstract void teach();
}


//说英语的接口
public interface SpeakEnglish {
    public abstract void speak();
}

//篮球教练
public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }

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

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

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

//乒乓球教练
public class PingPangCoach extends Coach implements SpeakEnglish {

    public PingPangCoach() {
    }

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

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

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

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

//乒乓球运动员
public class PingPangPlayer extends Player implements SpeakEnglish {

    public PingPangPlayer() {
    }

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

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

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

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

//篮球运动员
public class BasketballPlayer extends Player {

    public BasketballPlayer() {
    }

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

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

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


//测试类
public class PersonDemo {
    public static void main(String[] args) {
        //创建对象
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("王浩");
        ppp.setAge(30);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
        System.out.println("--------");

        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("姚明");
        bp.setAge(35);
        System.out.println(bp.getName()+","+bp.getAge());
        bp.eat();
        bp.study();
    }
}

三、形参和返回值--参数传递

3.1类名作为形参和返回值

需要或返回的是类的对象

  • 方法的形参是类名，其实需要的是该类的对象
  • 方法的返回值是类名，其实返回的是该类的对象
class Cat {
public void eat () {
System . out . println ( " 猫吃鱼 " );
}
}
class CatOperator {
public void useCat ( Cat c ) { //Cat c = new Cat();
c . eat ();
}
public Cat getCat () {
Cat c = new Cat ();
return c ;
}
}
public class CatDemo {
public static void main ( String [] args ) {
// 创建操作类对象，并调用方法
CatOperator co = new CatOperator ();
Cat c = new Cat ();
co . useCat ( c );
Cat c2 = co . getCat (); //new Cat()
c2 . eat ();
}
}

3.2抽象类作为形参和返回值

需要或返回的是该抽象类的子对象

  • 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
  • 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
abstract class Animal {
public abstract void eat ();
}
class Cat extends Animal {
@Override
public void eat () {
System . out . println ( " 猫吃鱼 " );
}
}
class AnimalOperator {
public void useAnimal ( Animal a ) { //Animal a = new Cat();
a . eat ();
}
public Animal getAnimal () {
Animal a = new Cat ();
return a ;
}
}
public class AnimalDemo {
public static void main ( String [] args ) {
// 创建操作类对象，并调用方法
AnimalOperator ao = new AnimalOperator ();
Animal a = new Cat ();
ao . useAnimal ( a );
Animal a2 = ao . getAnimal (); //new Cat()
a2 . eat ();
}
}

3.3接口作为形参和返回值

需要或返回的是接口的实现类对象

  • 方法的形参是接口名，其实需要的是该接口的实现类对象
  • 方法的返回值是接口名，其实返回的是该接口的实现类对象
interface Jumpping {
void jump ();
}
class JumppingOperator {
public void useJumpping ( Jumpping j ) { //Jumpping j = new Cat();
j . jump ();
}
public Jumpping getJumpping () {
Jumpping j = new Cat ();
return j ;
}
}
class Cat implements Jumpping {
@Override
public void jump () {
System . out . println ( " 猫可以跳高了 " );
}
}
public class JumppingDemo {
public static void main ( String [] args ) {
// 创建操作类对象，并调用方法
JumppingOperator jo = new JumppingOperator ();
Jumpping j = new Cat ();
jo . useJumpping ( j );
Jumpping j2 = jo . getJumpping (); //new Cat()
j2 . jump ();
}
}
丑八怪223
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中抽象类和接口的区别介绍
09-05
抽象类(abstract class)和接口(interface)的概念是面向对象设计中常用的概念, 也是比较容易混淆的概念. 在这里, 我提出一种区分它们的思路
Java基础篇：抽象类与接口
张维鹏的博客
09-27 1万+
（1）抽象类和接口都用于抽象化具体对象的，都不能直接实例化，但是两者的侧重点不同：抽象类主要用来抽象类型，表示这个对象是什么；接口主要用来抽象功能，表示这个对象能做什么； （2）接口可以看成抽象类的变体，所有方法都是抽象的，因此接口只能做方法的声明，不能有方法的实现；而抽象类可以有默认的方法实现，既可以做方法的声明，也可以做方法的实现；
详细解答Java中抽象类和接口的区别问题！
gg7894125的博客
08-25 661
接口(Interface)和抽象类(Abstract Class)是支持抽象类定义的两种机制。 一、抽象类 在Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法称为抽象方法，抽象方法只有方法的声明，没有方法体。抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。 以JDK中的GenericServlet为例： 复制代码 public abstract class GenericServlet implemen
抽象类和接口实验报告.doc
12-11
抽象类和接口实验报告
PHP抽象类和接口用法实例详解
01-03
本文实例讲述了PHP抽象类和接口用法。分享给大家供大家参考，具体如下： 前言 对于oop，估计大多数人并不陌生。有些人除PHP外也学习不少其他语言，会发现php的不同之处，可能语法极其丑陋，但并不妨碍它成为世界上...
基于Java抽象类和接口实现疯狂动物城
05-11
本项目主要包括项目开发环境搭建、不同功能的类的设计、抽象类的设计、接口的设计、及其继承抽象类重写和接口实现类等具体功能的实现。 ●工程项目搭建与游戏初始化功能实现(2学时) ; ●动物城成员列表与动物信息...
如何理解Java抽象类和接口
12-22
在面试中我们经常被问到：Java中抽象类和接口的区别是什么？ 　然后，我们大说一通抽象类可以有方法，接口不能有实际的方法啦；一个类只能继承一个抽象类，却可以继承多个接口啦，balabala一大堆，好像把标准答案...
c#中抽象类和接口的详细介绍
09-04
介绍了c#中抽象类和接口，有需要的朋友可以参考一下
C#抽象类和接口的区别分析
01-01
很多C#的初学者在编程时都容易把抽象类和接口搞混,本文就为大家从概念上讲解抽象类和接口的区别： 一、抽象类： 含有abstract修饰符的class即为抽象类，抽象类是特殊的类，只是不能被实例化，可以创建一个变量，其...
Java为什么使用抽象类和接口
01-20
Java接口和Java抽象类代表的是抽象类型，是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，必须是面向接口的编程，面向抽象的编程，正确地使用接口、...
浅析php中抽象类和接口的概念以及区别
12-18
复制代码 代码如下://抽象类的定义：abstract class ku{ //定义一个抽象类 abstract function kx(); ……}function aa extends ku{ //实现抽象类的方法 function kx(){ echo ‘sdsf’; }}//使用方法$aa=new ...
Java接口的实例应用：致敬我的偶像——何塞·穆里尼奥
weixin_34290390的博客
12-21 502
文/沉默王二 曹操在《短歌行》中为杜康酒打过一个价值一亿个亿的广告——“何以解忧，唯有杜康”，我替曹操感到惋惜的是他本人并不会收到这笔不菲的代言费。想一想，要是三国时期的明星人物们有这个代言意识的话，保证各家的军费收入会多出来一个重量级的来源。 不过，酒真的能解忧吗？我不大敢相信。李白就曾质疑过：“举杯消愁愁更愁，抽刀断水水更流。”我和李白持相同的观点，酒啊，真的不容易解忧，但绝对可以增加作者莫...
接口和抽象类的区别
热门推荐
奋斗男孩的博客
11-25 1万+
不同点： 1、接口只能定义抽象方法不能实现方法，抽象类既可以定义抽象方法，也可以实现方法。 2、单继承，多实现。接口可以实现多个，只能继承一个抽象类。 3、接口强调的是功能，具有什么能力。抽象类强调的是所属关系。4、接口中的所有成员变量 为public static final（默认，变量也是属于全局变量）， 静态不可修改，当然必须初始化。接口中的所有方法都是public abstract 公开抽象的（public可不写）。而且不能有构造方法。抽象类就比较自由了，和普通的类差不多，可以有抽象方法也可以没有，
c++抽象类和接口类
最新发布
09-06
抽象类和接口类是面向对象编程中的两个重要概念。 抽象类是一个不能被实例化的类，它只能被继承。抽象类可以包含抽象方法和普通方法。抽象方法是没有实现体的方法，需要在子类中进行具体实现。子类继承抽象类后，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值