Java学习打卡第四天——[抽象类，多态，接口，形参的简介和使用]

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量855 收藏
点赞数 1
分类专栏： # JavaSE 文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44606952/article/details/122406697
版权

Javaee之【抽象类】

Javaee之【多态】

Javaee之【接口】

Javaee之【抽象类，多态，接口，继承】

Javaee之【形参】

抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
在抽象类中子类必须重写父类的抽象方法；
示例：
动物类：

public abstract class Animal {
    private String name;
    private String age;

    public Animal() {
    }

    public Animal(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public abstract void eat();

    public void show(){
        System.out.println(name+","+age);
    }
}

猫类：

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫喜欢吃鱼");
    }

    public Cat() {
    }

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

}

狗类：

public class Dog extends Animal{
    public Dog() {
    }

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

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

测试类：

public class AbstraDemo {
    public static void main(String[] args) {

        //多态的使用
        Animal a1 = new Cat();
        a1.setName("加菲猫");
        a1.setAge("1");
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();
        a1.show();

        Animal a2 = new Cat("加菲","1");
        System.out.println(a2.getName()+","+a2.getAge());
        a2.eat();
        a2.show();

        Animal a3 = new Dog();
        a3.setName("明明");
        a3.setAge("2");
        System.out.println(a3.getName()+","+a3.getAge());
        a3.eat();
        a3.show();

        Animal a4 = new Dog("花花","2");
        System.out.println(a4.getName()+","+a4.getAge());
        a4.eat();
        a4.show();
    }
}

多态

多态：

多态是同一个行为具有多个不同表现形式或形态的能力。

例如：
一个抽象类：里面有一个吃的行为
在狗的类里面表现的是吃骨头，在猫的类里面表现的是吃鱼的行为；
也可以这样简单理解：
一个抽象类不能实例化对象，必须依靠子类来创建对象
在抽象类中已经使用了多态：

Animal a = new Cat();
Animal a3 = new Dog();

多态就是同一个接口，使用不同的实例而执行不同操作；
多态使用的前提：
1、有继承关系
2、有方法重写
3、父类指向子类对象
动物类：

public class Animal {

    public int age=8;

    public void eat(){
        System.out.println("动物类有的喜欢吃鱼");
    }
}

猫类：

public class Cat extends Animal{
    public int age=6;
    public int weight;

    @Override
    public void eat() {
        System.out.println("猫爱吃鱼");
    }
    public void catchmouth(){
        System.out.println("猫喜欢抓老鼠");
    }
}

测试类：

public class Duotai02 {
    public static void main(String[] args) {
        Animal a1 = new Cat();

        //多态方法编译看左边，运行看右边（子类的）
        a1.eat();

//        多态中使用的方法父类也要有
//        a1.catchmouth();

        //运行中成员变量使用的是父类的
        System.out.println(a1.age);
        //父类也要有变量才可以使用
//        System.out.println(a1.weight);
    }
}

接口

简介：

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现接口的方式，从而来实现接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口使用示例：
接口：

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

动物类：

public abstract class Animal {
    private String name;
    private String age;

    public Animal() {
    }

    public Animal(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
    public abstract void eat();
}

猫类：

public class Cat extends Animal implements Jumping{

    public Cat() {
    }

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

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

    @Override
    public void jump() {
        System.out.println("猫可以调高了");
    }
}

测试类：

public class Interfacempl {
    public static void main(String[] args) {
        //猫使用无参构造，狗使用带参构造
        Animal a1 = new Cat();
        a1.setName("加菲");
        a1.setAge("2");
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();
        Jumping j1 = (Cat) a1;
        j1.jump();

        /*Animal a2 = new Dog("花花","1");
        System.out.println(a2.getName()+","+a2.getAge());
        a2.eat();
        Jumping J2 = (Dog) a2;
        ((Dog) a2).jump();*/

        //具体实现的时候使用最多的就是直接使用Cat来创造对象
        //因为它可以直接使用抽象类和接口里面的方法
        Cat c = new Cat("加菲猫","2");
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

抽象类，接口，继承综合案例

题目：

在这里插入图片描述
分析：
在这里插入图片描述
英语接口

public interface SpeakEnglish {
    public abstract void speakEnglish();
}

教练类：

public abstract class Coach extends Person{

    public Coach() {
    }

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

    public abstract void teach();


}

运动员类：

public abstract class Player extends Person{

    public Player() {
    }

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

    public abstract void study();

}

篮球教练类：

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

    public BasketballTeacher(String name, String age) {
        super(name, age);
    }

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


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

篮球运动员类：

public  class BasketballStudent extends Player{

    public BasketballStudent() {
    }

    public BasketballStudent(String name, String age) {
        super(name, age);
    }


    @Override
    public  void study(){
        System.out.println("篮球运动员在学习打篮球");
    }

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

兵乓球教练类：

public  class PingpangTeacher extends Coach implements SpeakEnglish{

    public PingpangTeacher() {
    }

    public PingpangTeacher(String name, String age) {
        super(name, age);
    }

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

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

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

乒乓球运动员类：

public  class PingpangStudent extends Player implements SpeakEnglish{
    public PingpangStudent() {
    }

    public PingpangStudent(String name, String age) {
        super(name, age);
    }

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

    @Override
    public  void study(){
        System.out.println("学习乒乓球");
    }

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

测试类：

public class Demo {
    public static void main(String[] args) {
        BasketballStudent bs = new BasketballStudent();
        bs.setName("王明");
        bs.setAge("21");
        System.out.println(bs.getName()+","+bs.getAge());
        bs.eat();
        bs.study();

        System.out.println("----------------------");

        PingpangStudent ps = new PingpangStudent();
        ps.setName("王浩");
        ps.setAge("22");
        System.out.println(ps.getName()+","+ps.getAge());
        ps.eat();
        ps.study();
        ps.speakEnglish();

        System.out.println("----------------------");

        BasketballTeacher bt = new BasketballTeacher();
        bt.setName("姚明");
        bt.setAge("23");
        System.out.println(bt.getName()+","+bt.getAge());
        bt.eat();
        bt.teach();

        System.out.println("----------------------");

        PingpangTeacher pt = new PingpangTeacher("李华","24");
        System.out.println(pt.getName()+","+pt.getAge());
        pt.eat();
        pt.teach();
        pt.speakEnglish();

    }
}

形参

这里主要介绍的是类作为形参，类作为返回值的情况； 代码中有注释直接看代码即可 下面直接给出示例： 猫类： 
public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

猫操作类：

public class Catoperator {

    //类作为形参传递的是一个具体的对象
    public void useCat(Cat c){
        c.eat();
    }

    //Cat作为返回值类型返回的是一个Cat对象
    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();
        c2.eat();
    }
}
皮皮皮皮皮皮皮卡乒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 普通方法中形参列表中以接口作为数据类型实现继承和多态
TonyHTY的博客
09-18 1246
今天见了一种很奇怪的写法，以前没有见到过，所以做个小记录，供以后思考使用。 在我的印象中，java的接口是不可以实例化的，也就是说没有构造器，没有属性，只有一堆定义好形参和返回值的方法名。不能在程序中用new去实例化一个对象。所以理所应当的在脑海中深化了一种思维，就是接口不可以当做数据类型来定义形参。 直到我膝盖中了一箭。。。 下面把今天所见...
JavaSE之面向对象之继承、多态、抽象类、接口
m0_62764440的博客
12-01 2307
一、继承 （一）、继承的概述 继承是面向对象的三大特征之一，可以使得子类具有父类的方法和属性，还可以在子类中重新定义，追加属性和方法。 继承的格式 ● 格式：public class 子类名extends父类名{} ●范例：public class Zi extends Fu{} ●Fu：是父类，也被称为基类和超类。 ●Zi：是子类，也被称为派生类。 父类： 子类： 当在测试类里面通过子类调用show 方法时报错，因为show方法在父类，此时我们可以通过子类继承父类来调用show
Java---包，继承，组合，多态，抽象类，接口（万字详解）
baiyang2001的博客
11-16 742
???? 文章前提： 我们已经知道 Java 是面向对象进行编程的，那么具体的怎样去面向对象进行编程，本篇博客将进行深入探讨???? ???? 文章目录： 1.包 - 1.1 导入包中的类 - 1.2 静态导入 - 1.3 将类放到包中 - 1.4 包的访问权限控制 - 1.5 常见的系统包 2.继承 - 2.1 什么是继承 - 2.2 语法规则 - 2.3 protected 关键字 - 2.4 更复杂的继承关系 - 2.5 final 关键字 3.组合 - 3.1 has - a - 3.2 i
浅谈Java面向对象编程之多态、继承、抽象类、接口
na 小子叫坚强的博客
07-24 1166
1. 包 包 (package) 是组织类的一种方式。 使用包的主要目的是保证类的唯一性。 1.1 导入包中的类 java中提供了很多现成的类供我们使用 public class Test { public static void main(String[] args) { java.util.Date date = new java.util.Date(); // 得到一个毫秒级别的时间戳 System.out.println(date.getT
Java继承、多态接口和抽象类总结
weixin_45923633的博客
04-29 479
一、继承（extends） 继承的理解：当我们定义很多部分具有相同属性和行为的类时，如果使用之前我们所讲类的定义方式进行定义，那么是不是发现有大量的代码重复书写，为了允许使用现有的类的功能，并在无须改写原来的类的情况下，引入了继承的概念。我们把允许重用现有类称为基类（或超类，父类），由基类派生出来的类称为派生类(子类)。 Java类的继承主要通过extends关键字来完成的。一旦继承后，子类将获...
学习Java，你需要知道这些——接口与多态
12-20
总之，接口和多态是Java中实现抽象和解耦的重要工具，它们让代码更具有灵活性、可维护性和扩展性，也是理解面向对象编程的关键点。通过学习和熟练运用接口与多态，开发者可以编写出更加高效、可复用的代码。
Java抽象类接口与多态PPT教案学习.pptx
09-30
Java抽象类接口与多态PPT教案学习 Java抽象类接口与多态是Java编程语言的核心概念，本篇资源文件将详细介绍Java中的抽象类、接口和多态的概念、特点和应用。 一、抽象类 抽象类是Java中的一种特殊的类，它不能被...
Java中使用接口实现多继承和多态的方法
01-19
1.JAVA里没有多继承，一个类之能有一个父类。 　而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样...
接口，多态，抽象类，final
08-10
在 Java 编程语言中，接口、多态、抽象类和 final 是四个非常重要的概念，它们在面向对象编程（Object-Oriented Programming，OOP）中扮演着关键角色。 1. 接口 接口是 Java 中的一种特殊的抽象类，所有方法都是...
java用接口、多态、继承、类计算三角形和矩形周长及面积的方法
09-03
在Java编程中，面向对象是核心特性之一，它允许我们通过类、接口、继承和多态来设计和实现复杂的程序。本示例中，我们探讨了如何利用这些概念来计算三角形和矩形的周长和面积。 首先，定义了一个名为`Shape`的接口...
java多态
weixin_50307533的博客
07-29 3198
向下转型将一个指向子类对象的父类引用赋值给一个子类的引用，称为向下转型，此时必须进行强制类型转换。向上转型语法=new();此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。使用父类作为方法的形参，是Java中实现和使用多态的主要方式之一。向上转型将父类的引用指向子类对象，称为向上转型，自动进行类型转换。多态同一个引用类型，使用不同的实例而执行不同操作。（3）父类的引用指向子类的对象。子类到父类的转换（向上转型）...
java中类、抽象类、接口作为形参和返回值
jtjeeeee的博客
03-17 5523
一，类名作为形参和返回值 方法的形参是类名，其实需要的是该类的对象 方法的返回值是类名，其实返回的是该类的对象 二，抽象类名作为形参和返回值 方法的形参是抽象类名，其实需要的是抽象类的子类对象 方法的返回值是抽象类名，其实返回的是抽象类的子类对象 三，接口名作为形参和返回值 方法的形参是接口名，其实需要的是接口的实现类对象 方法的返回值是接口名，其实返回的是接口的实现类对象 四，案例 类名作为形参和返回值之前的学生信息管理案例有所涉及，不再练习 PlayGame接口 publ.
【Java -- 类/抽象类/接口作为形参和返回值】
qq_45312083的博客
08-09 1054
类作为形参时，传入的需耀世类的对象；类作为返回类型时，返回的也是类的对象； 抽象类作为方法形参时，由于抽象类不能实例化，因此需要利用多态创建该抽象类的子类对象，将其子类对象作为参数传入方法；当以抽象类作为方法的返回类型时，实际返回的也是其子类对象；类似于抽象类，接口也不能实例化，所以接口作为形参和返回值时传入的和接受的都是实现该接口的类的对象。...
如何理解Java中的接口？类名，抽象类名，接口名作为形参和返回值？
wangkexiang21的博客
04-07 1100
接口：为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些事物需要被扩展，只需要这部分事物把这些额外功能实现即可。 接口的特点： 接口用关键字interface表示 格式: interface 接口名 {} 类实现接口用implements表示 格式: class 类名 implements 接口名 {} 接口不能实例化，如果非要实例化，那么按照多态的方式来进行实例化，通过类对象实例化，这叫接口多态。多态的前提：有继承或实现关系，有方法重写，有父（类/接口）
JAVA子类作为实参父类作为形参,JAVA——多态的应用
weixin_35899659的博客
03-21 2369
多态的两种实现方式1 使用父类作为方法形参2 使用父类作为方法返回值(注： 当作为参数的父类是普通类或者抽象类时，构成继承多态；当作为参数的父类是一个接口时，构成接口多态)1、使用父类方法作为形参(形式参数的类型： ①基本类型 ②引用类型 )普通类形参： 当一个形参希望我们传入的是一个普通类时,我们实际上传入的是该类的对象/匿名对象抽象类形参： 当一个形参希望我们传入...
Java中的多态
WuJieBest_的博客
07-31 686
Java中三大特性之一，多态的介绍
Java多态详解
热门推荐
m0_67599274的博客
04-28 3万+
目录1. 基本介绍1.1 多态的概念1.2 对象的多态1.3 入门案例2. 具体细节2.1 向上转型2.2 向下转型2.3 instanceOf 比较操作符3. 实现技术：动态绑定4. 应用4.1 多态数组4.2 多态参数5. 多态的优点 1. 基本介绍 1.1 多态的概念 多态是继封装、继承之后，面向对象的第三大特性。 多态体现为父类引用变量可以指向具体的子类对象。 1.2 对象的多态 1.3 入门案例 2. 具体细节 2.1 向上转型 2.2 向下转型 2.3 instanceOf 比较操作符 3. 实
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 199
从本地导入Junit
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 343
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

皮皮皮皮皮皮皮卡乒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值