面向对象-多态

最新推荐文章于 2024-07-29 18:00:00 发布
最新推荐文章于 2024-07-29 18:00:00 发布
阅读量71 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Susir001/article/details/133817479
版权

一、多态

1.1 介绍

多态：多种形态

代码：方法的多态性 --> 同一个方法，出现不同的功能 -> aniaml.play()

（属性没有多态性）

多态的好处：

  • 扩展性强，让代码更灵活
  • 减少耦合度 —> 开发思想：高内聚（即尽可能自己完成），低耦合（即使用别人的东西）

多态出现的前提：

  • 继承/实现
  • 重写
  • 向上转型（父类引用指向子类对象）

1.2 示例

父类：

public class Animal {
    String name;

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

子类：

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

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

测试类：

public class Test {
    public static void main(String[] args) {
        //这也算是类型转换；小向大默认进行
        //向上转型 -- 父类引用（父类对象）指向子类对象
        Animal animal = new Dog();
        Animal animal1 = new Cat();

        /**
         * 编译看父类，运行看子类
         */
        animal.eat();//狗吃骨头
        animal1.eat();//猫吃鱼

        //new Dog -  子类
        feedAnimal(new Dog());
        feedAnimal(new Cat());
    }

    /**
     * 多态的应用场景1：把方法的参数设计成父类
     * 调用方法时传入子类，让方法出现多态性
     * 目的：扩展性强
     * @param animal
     */dd
    public static void feedAnimal(Animal animal){
        animal.eat();
    }
}

1.3 instanceof【了解】

向上转型 ：子类对象赋值给父类引用

向下转型：父类引用（对象）赋值给子类引用

  • 注意：向下转型是必须先有向上转型，才能成功向下转型
public static void main(String[] args) {
    //向上转型
    Animal animal = new Dog();
    //调用父类与子类都有的方法  --  父类编译，子类运行
    animal.eat();
    //向上转型后，无法调用子类特有的方法
    //animal.watch();

    System.out.println("------------");
    //向下转型
    Dog dog = (Dog) animal;
    //调用子类特有的方法
    dog.watch();//狗会看门

    System.out.println("-------------------");
    feedAnimal(new Dog());
    feedAnimal(new Cat());

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

    //instanceof 可以调用子类特有方法
    show(new Dog());
    show(new Cat());
    //System.out.println(cover(65));
}

//多态设计方法 --  输出狗类与猫类重写父类的共有方法
public static void feedAnimal(Animal animal) {
    animal.eat();
}

// 多态设计方法（instanceof）  --  输出狗类与猫类的特有方法
public static void show(Animal animal) {
    /**
     * instanceof 判断对象是否属于某个类的实例
     */
    if (animal instanceof Dog) {
        Dog dog = (Dog) animal;
        dog.watch();
    } else if (animal instanceof Cat) {
        Cat cat = (Cat) animal;
        cat.sleep();
    }
}

ASCII码值

在这里插入图片描述

设计一个方法，将数字转成ASCII中的对应的字母
//数字65 ==> A 97 ==> a
//65~90 A~Z; 97~122 a~z;
//0-65535之间的整数可以赋值给char,char是对应的ascii值
//char c2 = 65;//A
public static String cover(int a) {
String result = “”;//作用域
if (a>=65 && a<=90 || a>=97 && a<=122){
char c = (char) a;//将int型强转为char型
result = c +“”;//任何数据拼接字符串，都会变成字符串
}else {
System.out.println(“err”);
}
return result;
}

测试方法

System.out.println(cover(65));//A

二、多态总结

2.1 总结

代码写法：类中有另外一个类的属性，部门类中员工属性，老师类中学生类数组属性

静态：

  • 当想要共享时就用static
  • 当想要方便调用时方法/属性时，加static

多态

  • 前提：继承、重写、向上转型
  • 运行效果：编译看父类，运行看子类
  • 好处：扩展、灵活
  • 多态使用场景（大装小，父类装子类）
    • 场景1：方法的参数列表是父类类型，传参数传子类对象
    • 场景2：父类数组，装子类对象
    • 场景3：父类类型当方法的返回值类型，return 返回子类对象

2.2 场景2：

父类：

//形状 - -父类
public class Shape {
    //面积方法
    public double area(){
        return 0.0;
    }
    //周长方法
    public double girth(){
        return 0.0;
    }
}

子类：

//圆类
public class Circle extends Shape {
    private double r;

    public Circle(double r) {
        this.r = r;
    }

    @Override
    public double area() {
        return 3.14 * r * r;
    }

    @Override
    public double girth() {
        return 2 * 3.14 * r;
    }
}

//矩形类
public class Rect extends Shape {
    private double l;//长
    private double w;//宽

    public Rect(double l, double w) {
        this.l = l;
        this.w = w;
    }

    @Override
    public double area() {
        return l * w;
    }

    @Override
    public double girth() {
        return 2 *(l+w);
    }
}

//正方形类
public class Square extends Shape {
    private double l;//边长

    public Square(double l) {
        this.l = l;
    }

    @Override
    public double area() {
        return l * l;
    }

    @Override
    public double girth() {
        return 4 * l;
    }
}

测试类：

public static void main(String[] args) {
    //创建一个长度为3的数组，且可以存储不同类型的对象
    Shape[] shapeArr = new Shape[3];
    //向上转型（圆形对象赋值给父类形状对象）
    shapeArr[0] = new Circle(10);
    shapeArr[1] = new Rect(10,10);
    shapeArr[2] = new Square(10);
    for (int i = 0; i < shapeArr.length; i++) {
        System.out.println("形状的面积"+shapeArr[i].area());//能把方法放在输出语句中的，是因为方法有返回值
        System.out.println("形状的周长"+shapeArr[i].girth());
    }
}

结果：
在这里插入图片描述

三、抽象类（abstract）

抽象：抽象就是不具体

抽象类： 方法变的不具体

3.1 语法

/**
 * Created by slc on 2023/10/12.
 * 1.方法抽象是指方法没有方法体，还需要abstract修饰
 * 2.抽象方法需要放在抽象类，使用abstract修饰类
 *   -- 解释1.父类定义了方法，子类也重写了父类方法，此时就不用父类方法了，干脆就直接定义为抽象方法
 * 3.抽象类可以有正常方法
 * 4.abstract 不能修饰属性
 * 5.抽象类中可以有构造方法，但是不能直接new出来
 *      --即抽象方法所在的类不能被创建对象
 * 6.抽象方法存在作用：是用来被子类继承的（重写）
 */
public abstract class Animal {
    String name = "huahua";

    public abstract void eat();
    public abstract void play();

    public  Animal(){
        System.out.println("Animal()");
    }
}

/**
 * Created by slc on 2023/10/12.
 * 1.子类继承抽象类，二选一操作
 *      1）要么本身定义为抽象类
 *      2）要么实现所有的抽象方法（重写）
 */
public class Dog extends Animal{
    public Dog(){
        System.out.println("Dog()");
    }
    @Override
    public void eat() {
    }

    @Override
    public void play() {
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //抽象类不能实例化  -- 抽象类不能创建对象
        //new Animal();

        //创建子类对象 （继承了抽象类） --
        Dog dog = new Dog();
        System.out.println(dog.name);
        
		System.out.println("-----------");
        //抽象类虽然不创建对象，但是可以当作父类引用指向子类对象
        //向上转型
        Animal animal = new Dog();
        animal.eat();
    }
}

结果：
在这里插入图片描述

3.2 使用总结

抽象类应用就是一种约束的效果，是一种限制，子类一旦继承父类，就必须要重写方法

当设计程序时，有些类需要被子类继承且必须重写方法时，就把父类设计成抽象类

抽象类是用来抽象性差异。具体共同点的

也就是将差异性方法抽象化，提供给子类用于重写。共同的方法具体化，所有子类继承使用

把子类不一样的方法抽象成抽象方法，每个子类都重写

把子类都一样的方法提取到父类，每个子类直接用，不用重写。

四、 接口 （interface）

比抽象还抽象的Java文件就是 - 接口

4.1 特性

类就是一个模板，来描述一些统一的特性

接口不是类，只是一种定义，只是一种规范

引用数据类型：数组、类、接口

接口不是类，比抽象类还抽象的一种Java文件

  • 接口不是类，使用interface所修饰

  • 接口中没有属性，所有属性都是常量，默认被public static final所修饰

  • 接口中不能定义普通方法，所有的方法都是抽象的，默认都是被public abstract所修饰

  • 接口中没有构造方法，既不能创建对象

  • 接口主要是用来被子类实现implements

  • 子类实现接口，必须重写接口中的所有抽象方法，否则就要将自己定义为抽象类

  • 子类允许多实现接口，中间用逗号隔开

  • 子类在允许继承的同时，还可以实现接口

  • public class UDisk extends Electron implements USB,IA,Disk{}

  • 接口之间允许继承，且允许多继承（类不允许多继承）

4.2 应用

与抽象类用处基本一致，多用在多态的场景

USB usb = new UDisk();

4.3 代码演示

U盘类：

/**
 * Created by slc on 2023/10/13.
 * - 子类实现接口，必须重写接口中的所有抽象方法，（否则就要将自己定义为抽象类）
 * - 子类允许多实现接口，中间用逗号隔开
 * - 子类在允许继承的同时，还可以实现接口
 */
//U盘类
public class UDisk extends Electron implements USB,Disk{
    //重写Electron中的抽象方法
    @Override
    public void show() {
        System.out.println("UDisk show()");
    }
    //重写USB接口中的抽象方法
    @Override
    public void trans() {
        System.out.println("UDisk trans()");
    }

    //重写Disk接口中的抽象方法
    @Override
    public void save() {
        System.out.println("UDisk save()");
    }
}

抽象类（电子设备）

//电子设备
public abstract class Electron {
    public abstract void show();
}

USB接口：

/**
 * Created by slc on 2023/10/13.
 * 接口不是类，是使用interface修饰
 * <p>
 * 接口可以继承接口，且是多继承
 */
public interface USB extends Disk {
    /**
     * 接口中属性默认被pubulic修饰 ，而且只能被public修饰
     * 即接口中的属性都是 静态常量
     * -- -static 是静态，可以直接通过类名.属性直接调用
     */
    public static final int length = 5;

    /**
     * 接口中的方法全部
     * 默认被public abstract所修饰
     * 即所有方法都是抽象类
     */
    public abstract void trans();
    /**
     * 接口中没有构造方法
     *   --- 即不允许创建构造方法
     */
    // public USB(){};
}

接口：

//接口
public interface Disk {
    void save();
}

测试类：

public class Test {
    public static void main(String[] args) {
        //创建对象
        //USB usb = new USB();//因为USB是abstract，无法实例化，既无法创建对象

        //向上引用  -- 即父类引用指向子类对象
        USB usb = new UDisk();
        usb.trans();
    }
}

输出结果：
在这里插入图片描述

4.4 继承与实现的经验

对于以后写代码，该怎么设计？

  • 很多类有公共的属性，方法抽取成父类来继承
  • 有些类中的方法被抽取到父类中，但是子类又不合适还需要重写，那就把类和方法定义成抽象
  • 将一些功能性的行为定义成接口，让想拥有这些功能的类去实现即可

五、内部类

5.1 概述

内部类的概念：

在一个类中定义的类，称之为内部类，外面的类称为外部类

内部类的分类：

  • 1.成员内部类
  • 2.静态内部类
  • 3.局部内部类
  • 4.匿名内部类

内部类的特点：

  • 1.内部类可以访问到外部类的私有成员，且不破坏封装性
  • 2.内部类也会生成.class文件.名为：外部类名$内部类名.class

外部类的特点：

  • 1.一个Java文件中可以编写多个类，但是只能有一个类能使用public修饰，称之为主类。主类名必须与文件名一致
  • 建议：以后开发中，一个Java文件就编写一个类

5.2 示例：

public class Outer {
    private int outer = 1;

    void testOuter() {
        //外部类访问不到内部的属性与方法
        //System.out.println(inner);//访问不到
    }

    //成员内部类
    public class Inner {
        int inner = 2;

        void testInner() {
            //内部类可以用外部变量与方法
            System.out.println(outer);
            testOuter();
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //创建Outer类
        Outer outer = new Outer();
        outer.testOuter();
        //创建内部内对象
        Outer.Inner inner = new Outer().new Inner(); 
    }
}

5.3 匿名内部类

语法：

new 父类/接口（）{

​ 重写接口类的方法

}

实例：

USB接口：

//USB接口
public interface USB {
    void trans();
}

测试类：

public class TestUSB {
    public static void main(String[] args) {
        /**
         * 按以前，需要新建一个类实现USB接口，创建子类实现对象
         * 但是如果该接口的方法只需要实现一次，那么这么做就浪费时间
         *
         * 可以使用匿名内部类来简写
         * 匿名内部类语法：
         *      new 接口名(){
         *          重写接口类中方法()
         *      }
         *      相对于： 实现了接口并重写了方法且创建了子类对象
         */
        //匿名内部类
        new USB() {
            @Override
            public void trans() {
                System.out.println("传输");
            }
        }.trans();//传输

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

        USB usb = new USB() {//引入局部变量
            @Override
            public void trans() {
                System.out.println("传输");
            }
        };
        usb.trans();//传输
    }
}

特点：

  • 1.匿名内部类本身就是一个对象
  • 2.一般匿名内部类中都不会定义属性和方法，因为没有意义
  • 3.匿名内部类的父类一般都是抽象类或者是接口

匿名内部类的应用场景

  • 1.如果一个方法的参数是接口，且这个接口只需要实现一次，那么就可以使用匿名内部类

示例：

public static void main(String[] args) {
        /**
         * 按以前，需要新建一个类实现USB接口，创建子类实现对象
         * 但是如果该接口的方法只需要实现一次，那么这么做就浪费时间
         *
         * 可以使用匿名内部类来简写
         * 匿名内部类语法：
         *      new 接口名(){
         *          重写接口类中方法()
         *      }
         *      相对于： 实现了接口并重写了方法且创建了子类对象
         */
        //匿名内部类
        new USB() {
            @Override
            public void trans() {
                System.out.println("传输");
            }
        }.trans();//传输

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

        USB usb = new USB() {//引入局部变量
            @Override
            public void trans() {
                System.out.println("传输");
            }
        };
        usb.trans();//传输

        System.out.println("--------");
    	//调用接口参数方法
        addUSB(new USB() {//lambda表达式
            @Override
            public void trans() {
                System.out.println("chuanshu");
            }
        });
    }

    //方法传入接口参数
    public static void addUSB(USB usb) {
        usb.trans();
    }

}

六、抽象类 && 接口对比

抽象接口
修饰符abstractinterface
类是类不是类
属性正常属性全是静态常量
方法可以定义普通方法，抽象方法全部都是抽象方法
构造方法有构造方法没有构造方法
子类继承抽象类，单继承实现接口，多实现
应用多个类有共同特点，行为时。向上抽取形成父类，如果子类都会重写的方法，可以定义为抽象接口一般用来定义功能，行为

-------- | ------------------------------------------------------------ | -------------------------- |
| 修饰符 | abstract | interface |
| 类 | 是类 | 不是类 |
| 属性 | 正常属性 | 全是静态常量 |
| 方法 | 可以定义普通方法，抽象方法 | 全部都是抽象方法 |
| 构造方法 | 有构造方法 | 没有构造方法 |
| 子类 | 继承抽象类，单继承 | 实现接口，多实现 |
| 应用 | 多个类有共同特点，行为时。向上抽取形成父类，如果子类都会重写的方法，可以定义为抽象 | 接口一般用来定义功能，行为 |

Su sir～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
面向对象—多态
qq_44346427的博客
10-17 3618
多态
面向对象--多态
简之恨寒的博客
08-08 301
是指同一行为，具有多个不同表现形式。面向对象的三大特性，为封装、继承、多态。个人认为，继承是三大特性的核心。封装是将代码进行整合，封装后增加代码的聚合度；继承是建立了类与类之间的关系，建立了耦合度；多态是通过重写方式实现不同效果的展示，降低了耦合度。三大特性是一个整体，虽然可以独立使用，但是相互配合，整合起来的代码，更有优势和效果，真正的去实现了代码的高内聚，低耦合。...
java多态
2201_75467648的博客
06-06 101
首先，继承是多态的充分不必要条件，多态必须要在继承的前提下进行，并且必须要有方法的重写。System.out.println("小猫跳得高");System.out.println("小狗吃骨头");System.out.println("小狗跑得快");System.out.println("什么都吃");System.out.println("小猫吃鱼");这里重写了eat方法，我们去使用这个方法。我们可以把多态对象看作父类，使用方法。
java面向对象 --- 多态
火车头的博客
05-08 728
目录 多态 多态的由来 多态的分类 转型技术 基本数据类型之间的转换 引用数据类型也能做强转或自动转 引用数据类型转换的本质 父类引用指向子类对象有何特点？ 父类引用指向子类对象后的弊端 instanceof 多态的应用 多态参数 异构集合 多态 多态的由来 多态在面向对象中的含义：相同的行为，不同的实现。 相同的行为的体现： 1、多态是描述行为的，也就是方法； 2、相同行为其实在本质上就是“同名”方法。 不同的实现： 同名的方法，但是个各自有各自的方法实现体，也就是
JAVA面向对象-多态（完结）
12-13
JAVA面向对象---多态（完结）
java面向对象-多态.docx
05-10
Java初学者
carefree185#python-learn#面向对象-多态和鸭子类型1
07-25
三十一、多态多态指的是一类事物有多种形态，比如动物有多种形态：猫、狗、猪31.1 多态性def talk(animal: Animal): # 统一接口定义不考
day14-面向对象-多态&final&抽象类
12-12
* 多态是面向对象中的一大特征 * 多态的发生前提：必须有继承或实现关系、有方法的重写、父类引用指向子类的对象 * 多态可以分为两种形式：方法多态和成员变量多态 Java 中的 final 关键字： * final 关键字可以...
C#面向对象编程-多态习题[整理].pdf
10-11
C#面向对象编程-多态习题[整理].pdf
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 269
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1058
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 117
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 582
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 752
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 707
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 447
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 395
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 143
新建springboot项目找不到java版本8?
Java 面向对象 - 多态
09-08
多态是面向对象编程中的一个重要概念，它允许我们使用父类的引用来指向子类的对象，并且在运行时根据实际对象的类型来确定调用哪个方法。 在Java中，多态性可以通过继承和方法重写实现。假设有一个父类Animal和两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Su sir～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值