面向对象编程第三式: 多态 (Java篇)

news2025/2/28 17:13:07

本篇会加入个人的所谓‘鱼式疯言’

❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言
而是理解过并总结出来通俗易懂的大白话,
小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.
🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人能接受我们这个概念 ！！！

在这里插入图片描述

前言

在前面两篇文章中,小编带着友友们详细的熟悉了我们面向对象的前两式-------- 封装, 继承

而在本篇文章中小编讲带着小伙伴具体走进咱们第三式: 多态

竟然都进入第三式了, 我们的难度也会加大哦,小伙伴们一定要认真的阅读小编的讲解哦 💖 💖 💖

还是老规矩，小伙伴们从目录开始吧 💖 💖 💖

目录

  1. 重写
  2. 向上转型与向下转型
  3. 多态的实现
  4. 多态的优缺点

当小编写出第一个小标题的时候，小爱同学就问了，

我们不是讲多态吗？ 怎么变成重写了，那重写是什么？ 向下转型和向上转型又什么呢？

浅浅和小伙伴先透露一下哦，我们要实现多态就需要两个原理：

一个是 重写

另外一个就是我们的 向上转型 。

所以让小编带着带着循序渐进，脚踏实地的走入多态的海洋哦。 💖 💖 💖

一. 重写

1. 重写的初识

重写(override)：也称为覆盖。

重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。

重写的好处在于 子类可以根据需要，定义特定于自己的行为。

也就是说子类能够根据需要实现父类的方法。

鱼式疯言

如果非要小编用9个字来概括的话，非他们莫属了 😁 😁 😁

即外壳不变，核心重写！

2. 举个栗子

class Dog {
    public void bark() {
        System.out.println("woof");
    }
}


class Hound extends Dog {
    public void sniff() {
        System.out.println("sniff");
    }

    @Override
    public void bark() {
        System.out.println("bowl");
    }
}


class Test {
    public static void main(String[] args) {
        Hound hound=new Hound();
        hound.bark();
    }
}

在这里插入图片描述

通过上面的栗子证明了我们方法重写的哪些规则呢

方法重写规则

  • 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
    被重写的方法返回值类型可以不同，但是必须是具有父子关系的

  • 访问权限不能比父类中被重写的方法的 访问权限更低 。

  • 例如：如果父类方法被 public修饰 ，则子类中重写该方法就不能声明为 protected

  • 父类被static、private修饰的方法、构造方法都不能被重写。

  • 重写的方法, 可以使用 @Override 注解来显式指定.

  • 有了这个注解能帮我们进行一些 合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet),

  • 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

鱼式疯言

给大家举个生活中的栗子就明白我们 重写的重要性 了

对于已经投入使用的类，尽量不要进行修改。

最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。

例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示的时候，不仅仅可以显示号码，还可以显示头像，地区等。

在这个过程当中，我们不应该在原来老的类上进行修改，因为原来的类，可能还在有用户使用，正确做法是：新建一个新手机的类，对来电显示这个方法重写就好了，这样就达到了我们当今的需求了。

在这里插入图片描述

当我们熟悉了重写之后，和我们之前学过的重载又有什么异同之处呢 💕 💕 💕

3. 重写与重载的区别

class Dog {
    public void bark() {
        System.out.println("woof");
    }

    public void bark(int num) {
        for (int i = 0; i < num; i++) {
            System.out.print("woof ");
        }
    }
}


class Hound extends Dog {
    public void sniff() {
        System.out.println("sniff");
    }

    @Override
    public void bark() {
        System.out.println("bowl");
    }
}


class Test {
    public static void main(String[] args) {
        Hound hound=new Hound();
        hound.bark();

        Dog dog=new Dog();
        dog.bark(5);
    }
}

在这里插入图片描述

从中我们把他们分解着来看

在这里插入图片描述

从什么的图解中我们就明白了，重写和重载的最本质的区别

即： 方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

鱼式疯言

有图有真相

在这里插入图片描述

、

二. 向上转型和向下转型

1. 向上转型

<1>. 向上转型简介

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

语法格式：：父类类型 对象名 = new 子类类型()

et：Animal animal = new Cat(“元宝”,2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

<2>. 举个栗子

class Animal {
    String name;
    int age;

    public  Animal (String name,int age) {
        this.name=name;
        this.age=age;
    }
        public void eat() {
            System.out.println(name+"吃饭");
        }

}


class Cat extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }
}


class Dog extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }
}

class Test {
    public static void main(String[] args) {
        Animal animal1=new  Cat("小喵",14);
        animal1.eat();

        Animal animal2=new Dog("小汪",18);
        animal2.eat();
    }
}

在这里插入图片描述
鱼式疯言：

画个小图说明下：

在这里插入图片描述

<3>. 向上转型的实际运用

小编总结向上转型的三个使用场景

  1. 直接赋值
  2. 方法传参
  3. 方法返回

下面让小伙们一起来证明下这三个使用场景吧

class Animal {
    String name;
    int age;

    public  Animal (String name,int age) {
        this.name=name;
        this.age=age;
    }
        public void eat() {
            System.out.println(name+"吃饭");
        }

}


class Cat extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }
}


class Dog extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }
}




class TestAnimal {

    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
        a.eat();
    }

    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗".equals(var) ){
            return new Dog("狗狗",1);
        }else if("猫" .equals(var)){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
    public static void main(String[] args) {


        // 1. 直接赋值：子类对象赋值给父类对象
        Animal cat = new Cat("元宝",2);

        Dog dog = new Dog("小七", 1);
        eatFood(cat);
        eatFood(dog);

        Animal animal = buyAnimal("狗");
        animal.eat();

        animal = buyAnimal("猫");
        animal.eat();
    }
}

在这里插入图片描述

鱼式疯言

最后小编补充个点哦

向上转型的 优点 ：让代码实现更简单灵活。

向上转型的 缺陷 ：不能调用到子类特有的方法。

2. 向下转型

有 向上转型 就必然有 向下转型

<1>. 向下转型的简介

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法。

但有时候可能需要调用 子类特有的方法 。

此时：将父类引用再还原为子类对象即可，即向下转换。

这是下面这张图啦 😁 😁 😁

在这里插入图片描述

<2>. 举个栗子

class Animal {
    String name;
    int age;

    public  Animal (String name,int age) {
        this.name=name;
        this.age=age;
    }
        public void eat() {
            System.out.println(name+"吃饭");
        }

}


class Cat extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }
}


class Dog extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }
}


 class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
// 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();

        // 编译失败，编译时编译器将animal当成Animal对象处理
        // 而Animal类中没有bark方法，因此编译失败
        // animal.bark();

        // 向上转型
        // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
        // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        cat = (Cat)animal;
        cat.eat();

        // animal本来指向的就是狗，因此将animal还原为狗也是安全的
        dog = (Dog)animal;
        dog.eat();
    }
}

在这里插入图片描述
上面的结果怎么会出现这样子呢，原来啊
在这里插入图片描述

所以 向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。

Java中为了提高向下转型的安全性

引入了instanceof ，如果该表达式为true，则可以安全转换。

    class Animal {
    String name;
    int age;

    public  Animal (String name,int age) {
        this.name=name;
        this.age=age;
    }
        public void eat() {
            System.out.println(name+"吃饭");
        }

}


class Cat extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }

    public void mew() {
        System.out.println(super.name+"正在mew~~~~");
    }
}


class Dog extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }

    public void bark() {
        System.out.println(super.name+"正在bark~~~~");
    }
}


class TestAnimal {
        public static void main(String[] args) {
            Cat cat = new Cat("元宝",2);
            Dog dog = new Dog("小七", 1);
// 向上转型
            Animal animal = cat;
            animal.eat();
            animal = dog;
            animal.eat();
            if(animal instanceof Cat){
                cat = (Cat)animal;
                cat.mew();
            }
            if(animal instanceof Dog){
                dog = (Dog)animal;
                dog.bark();
            }
        }
    }

在这里插入图片描述

很明显我们看到当我们用 instanceof 关键字时，代码的安全性就提高了很多

三. 多态的实现

1.多态的简介

多态的概念：通俗来说，就是多种形态

具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

好比下面这些小图 😎 😎 😎

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

鱼式疯言

总的来说：同一件事情，发生在 不同对象身上，就会产生不同的结果。

2. 多态实现的条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

  1. 必须在 继承体系 下
  1. 子类必须要对父类中方法进行重写
  1. 通过父类的引用 调用重写的方法

<1>. 举个栗子

class Animal {
    String name;
    int age;

    public  Animal (String name,int age) {
        this.name=name;
        this.age=age;
    }
        public void eat() {
            System.out.println(name+"吃饭");
        }

}


class Cat extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }

    public void mew() {
        System.out.println(super.name+"正在mew~~~~");
    }
}


class Dog extends Animal {

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

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }

    public void bark() {
        System.out.println(super.name+"正在bark~~~~");
    }
}


///分割线//

 class TestAnimal {


        // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
        // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
        // 注意：此处的形参类型必须时父类类型才可以
public static void eat(Animal a){

        a.eat();
    }
public static void main(String[] args) {
    Cat cat = new Cat("元宝", 2);
    Dog dog = new Dog("小七", 1);
    eat(cat);
    eat(dog);
}

}

在这里插入图片描述
在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类)

在这里插入图片描述

此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型 (哪个子类)的实例.

此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态.

我们面向对象编程的多态只是一种 编程思维

而真正操作是我们称为： 动态绑定

2. 静态绑定与动态绑定

<1>. 静态绑定

静态绑定：也称为 前期绑定(早绑定)

class Test9 {
    public static int sum(int x,int y) {
        return x+y;
    }

    public static double sum (double x,double y,double z) {
        return x+y+z;
    }
    public static void main(String[] args) {

        System.out.println(sum(2, 6));

        System.out.println(sum(1.2, 3.5, 9.3));
    }
}

在这里插入图片描述

即在编译时，根据用户所传递实参类型就确定了具体 调用 那个方法。
在这里插入图片描述

典型代表函数重载。

<2>. 动态绑定

动态绑定：也称为 后期绑定(晚绑定)

具体的栗子我们在多态中已经充分的体现了，下编在这里就不赘述了 😊 😊 😊
在这里插入图片描述

即在编译时，不能确定 方法的行为 ，需要等到 程序运行 时，才能够确定具体调用那个 类的方法 。

鱼式疯言

用大白话说就是

动态绑定： 编译时确定，运行时改变

静态绑定： 编译时确定，运行时也确定

四. 多态的优缺点

class Shape {
    //属性....
    public void draw() {
        System.out.println("画图形！");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("●");
    }
}

【使用多态的好处】

什么叫 “圈复杂度” ?

圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解.

而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.

因此小伙伴们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”.

如果一个方法的圈复杂度太高, 就需要考虑重构.

不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 .

1. 圈复杂度低

<1>.普通栗子one

class Shape {
    //属性....
    public void draw() {
        System.out.println("画图形！");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("●");
    }
}

class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}


class Test {
    public static void drawShapes() {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
        for (String shape : shapes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("rect")) {
                rect.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
        }
    }

    public static void main(String[] args) {
        drawShapes();
    }
}

在这里插入图片描述

从这个普通栗子中是不是就能看出我们的 圈复杂度 是不是 很高

那如果是使用多态的思想来解决问题呢 🤔 🤔 🤔

<2>.多态栗子two

class Shape {
    //属性....
    public void draw() {
        System.out.println("画图形！");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("●");
    }
}

class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}


class Test {
    public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
        Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
                new Rect(), new Flower()};
        for (Shape shape : shapes) {
            shape.draw();
        }
    }

    public static void main(String[] args) {
        drawShapes();
    }
}

在这里插入图片描述

2. 可扩展能力强

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

class Triangle extends Shape {
@Override
public void draw() {
System.out.println("△");
}
}

对于类的调用者来说**(drawShapes方法),** 只要创建一个新类的实例就可以了, 改动成本很低.

而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

有优点就会有缺点

3. 多态的缺陷

  1. 属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

  1. 构造方法没有多态性

见如下代码

4. 避免在构造方法中调用重写方法

class B {
    public B() {
// do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

在这里插入图片描述

  • 构造 D 对象的同时, 会调用 B 的构造方法.
  • B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
  • 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0. 如果具备多态性，num的值应该是1.
  • 所以在构造函数内，尽量避免使用实例方法，除了final和private方法。

鱼式疯言

结论:

“用尽量简单的方式使对象进入可工作状态”, 尽量不要在
构造器中调用方法

(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成)

可能会出现一些隐藏的但是又极难发现的问题.

总结

  1. 重写： 理解了重写是在什么前提下进行，并与重载进行对比
  2. 向上转型与向下转型： 明白了向上整型的初始化以及不同的使用场景，向下转型的 instanceof 检验运用
  3. 多态的实现： 理解多态的概念，以及多态的实际运用和使用特点
  4. 多态的优缺点：多态的优点的多个典型栗子说明，以及多态的缺点的不规范使用的详解

如果觉得小编写的还不错的咱可支持 三连 下 (定有回访哦) , 不妥当的咱请评论区 指正

希望我的文章能给各位宝子们带来哪怕一点点的收获就是 小编创作 的最大 动力 💖 💖 💖

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1523776.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2024.3.17每日一题

2024.3.17每日一题

LeetCode 最小高度树 题目链接&#xff1a;310. 最小高度树 - 力扣&#xff08;LeetCode&#xff09; 题目描述 树是一个无向图&#xff0c;其中任何两个顶点只通过一条路径连接。 换句话说&#xff0c;一个任何没有简单环路的连通图都是一棵树。 给你一棵包含 n 个节点的…
阅读更多...
vue3 el-form中嵌套el-tabale 对输入动态校验

vue3 el-form中嵌套el-tabale 对输入动态校验

简单案例 <el-form :model"Form" :rules"rules" ref"FormRef" class"formDiv"><el-table :data"Form.copyWriters" style"width: 100%"><el-table-column label"文案链接"><temp…
阅读更多...
TPU浅谈

TPU浅谈

前言 大家好&#xff0c;我是jiantaoyab&#xff0c;上篇文章讲了FPGA和ASIC&#xff0c;讲解了 FPGA 如何实现通过“软件”来控制“硬件”&#xff0c;以及我们可以进一步把 FPGA 设计出来的电路变成一块 ASIC 芯片。今天我们来看看TPU。大家可以点击这篇文章TPU深入了解TPU。…
阅读更多...
BUUCTF-----[CISCN 2019 初赛]Love Math

BUUCTF-----[CISCN 2019 初赛]Love Math

<?php error_reporting(0); //听说你很喜欢数学&#xff0c;不知道你是否爱它胜过爱flag if(!isset($_GET[c])){show_source(__FILE__); }else{//例子 c20-1$content $_GET[c];if (strlen($content) > 80) {die("太长了不会算");}$blacklist [ , \t, \r, \n…
阅读更多...
如何在webapp中手动部署

如何在webapp中手动部署

前言&#xff1a;这个有不知道怎么下载Tomcat的可以看我这篇博客的前面&#xff0c;有相关链接&#xff0c;下载好后我那边也有如何运行成功的 在idea中配置tomcat服务器&#xff0c;部署一个项目-CSDN博客 接下来进入这篇博客的正题&#xff01;怎么手动部署 先找到我们下载…
阅读更多...
基于SpringBoot+Vue的个人云盘管理系统的设计与实现（源码+部署说明+演示视频+源码介绍）

基于SpringBoot+Vue的个人云盘管理系统的设计与实现（源码+部署说明+演示视频+源码介绍）

您好&#xff0c;我是码农飞哥&#xff08;wei158556&#xff09;&#xff0c;感谢您阅读本文&#xff0c;欢迎一键三连哦。&#x1f4aa;&#x1f3fb; 1. Python基础专栏&#xff0c;基础知识一网打尽&#xff0c;9.9元买不了吃亏&#xff0c;买不了上当。 Python从入门到精通…
阅读更多...
AI预测福彩3D第11弹【2024年3月17日预测--新算法重新开始计算第8次测试】

AI预测福彩3D第11弹【2024年3月17日预测--新算法重新开始计算第8次测试】

今天继续对第一套算法进行测试。废话不多说了&#xff0c;直接上分析出的图表&#xff0c;再上结果。 最终&#xff0c;经过研判分析&#xff0c;2024年3月17日福彩3D的七码预测结果如下&#xff1a; 百位&#xff1a;4 5 3 8 6 2 9 十位&#xff1a;9 8 7 6 2 4 5 个位&#x…
阅读更多...
三次握手seq和ack的流程 TCP协议栈seq和ack深层理解

三次握手seq和ack的流程 TCP协议栈seq和ack深层理解

☆ 大家可以把想了解的问题在评论发给我?我会根据问题补充到后面 ☆ 三次握手seq和ack的流程 是的，在TCP/IP协议中，三次握手过程确实涉及到序列号（Sequence Number, 简称Seq）和确认号（Acknowledgment Number, 简称Ack）的交换。这个过程是为了建立可靠的连接，确保数据能…
阅读更多...
Vue3-响应式基础:单文件和组合式文件

Vue3-响应式基础:单文件和组合式文件

单文件&#xff1a;html <!DOCTYPE html> <html> <head><title>响应式基础</title> </head> <body><div id"app" ><!-- dynamic parameter:同样在指令参数上也可以使用一个 JavaScript 表达式&#xff0c;需要包…
阅读更多...
基于深度学习的唇语识别系统的设计与实现

基于深度学习的唇语识别系统的设计与实现

概要 人工智能作为三大工程之一&#xff0c;从上个世纪至今仍然活跃于各个行业的研究与应用之中&#xff0c;应时代的热潮方向&#xff0c;本 课题主要针对深度学习技术应用于唇语识别当中&#xff0c;实现词语唇语的翻译功能。唇语识别在图像处理中一直是一个富 有挑战性的课题…
阅读更多...
记一些有关Element Plus的样式修改

记一些有关Element Plus的样式修改

先记一个放着&#xff0c;后续慢慢补充。。。 一个 Vue 3 UI 框架 | Element Plus Radio 单选框 1、去除radio的圆圈 .box-radio {/deep/ .el-radio__input {display: none;} }
阅读更多...
如何使用ArcGIS Pro生成带计曲线等高线

如何使用ArcGIS Pro生成带计曲线等高线

等高线作为常见的地图要素经常会被使用到&#xff0c;一般情况下生成的等高线是不带计曲线的&#xff0c;在某些情况下我们需要带计曲线的等高线&#xff0c;这里为大家介绍一下ArcGIS Pro生成带计曲线等高线的方法&#xff0c;希望能对你有所帮助。 数据来源 教程所使用的数…
阅读更多...
wireshark解析https数据包

wireshark解析https数据包

Debian11环境&#xff1a; 在linux环境下抓取访问某个https的网址时抓取的数据包都是加密的&#xff0c;导致无法跟踪到数据包流&#xff0c;现在尝试将抓取的https包进行解密。 1、解密https数据包需要设置SSLKEYLOGFILE变量&#xff0c;推荐写入配置文件中。 echo "exp…
阅读更多...
1.实用Qt：解决绘制圆角边框时，圆角锯齿问题

1.实用Qt：解决绘制圆角边框时，圆角锯齿问题

目录 问题描述 解决方案 方案1&#xff1a; 方案2&#xff1a; 结果示意图 问题描述 做UI的时候&#xff0c;我们很多时候需要给绘制一个圆角边框&#xff0c;初识Qt绘制的童鞋&#xff0c;可能绘制出来的圆角边框很是锯齿&#xff0c;而且粗细不均匀&#xff0c;如下图&…
阅读更多...
跨域问题？无需担心！学习如何解决 Axios 的跨域限制

跨域问题？无需担心！学习如何解决 Axios 的跨域限制

跨域是指访问另外一个域的资源&#xff0c;由于浏览器的同源策略&#xff0c;默认情况下使用 XMLHttpRequest 和 Fetch 请求时是不允许跨域的。跨域的根本原因是浏览器的同源策略&#xff0c;这是由浏览器对 JavaScript 施加的安全限制。 Axios 跨域常见报错 跨域请求被阻止 (…
阅读更多...
封装哈希表

封装哈希表

本文旨在讲解哈希表的封装&#xff0c;我们以哈希桶的结构来进行封装unorderedmap/set。要想实现封装哈希表&#xff0c;我们首先得先将哈希表的结构给搭建出来&#xff0c;然后再根据哈希桶的结构进一步封装unorderedmap/set&#xff01; 下面我们先来实现哈希桶的结构&#x…
阅读更多...
【C#】【SAP2000】SAP2000中批量修改指定荷载工况下所有Frame对象的温度荷载

【C#】【SAP2000】SAP2000中批量修改指定荷载工况下所有Frame对象的温度荷载

if (build true){// 连接到正在运行的 SAP2000cOAPI mySapObject (cOAPI) System.Runtime.InteropServices.Marshal.GetActiveObject("CSI.SAP2000.API.SapObject");cSapModel mySapModel mySapObject.SapModel;// 获取所有框架单元的总数int numberFrames 0;str…
阅读更多...
动态航线图

动态航线图

申请百度地图密钥 注意&#xff1a;随着版本的变化 &#xff0c;申请百度地图密钥的界面和方式可能会发生变化&#xff0c;这里的步骤仅供参考。 注册百度账号 注册后&#xff0c;使用账号进行登录。 申请百度地图密钥 打开http://lbsyun.baidu.com&#xff0c;依次点击“控…
阅读更多...
PostgreSQL开发与实战(6.3)体系结构3

PostgreSQL开发与实战(6.3)体系结构3

作者&#xff1a;太阳 四、物理结构 4.1 软件安装目录 bin //二进制可执行文件 include //头文件目录 lib //动态库文件 share //文档以及配置模版文件4.2 数据目录 4.2.1 参数文件 pg_hba.conf //认证配置文件 p…
阅读更多...
小蓝的漆房——算法思路

小蓝的漆房——算法思路

题目链接&#xff1a;1.小蓝的漆房 - 蓝桥云课 (lanqiao.cn) 本题只要是通过枚举的方法&#xff0c;算出涂成每一种颜色所需的天数&#xff0c;最后在所有天数中找出最小值&#xff08;由题可知&#xff0c;最多只有60种颜色&#xff0c;所以可以尝试算出每种颜色所需的时间&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023