【JAVA】十三、基础知识“接口”精细讲解！(二)(新手友好版~)

news2025/4/23 17:14:11

        哈喽大家好呀qvq，这里是乎里陈，接口这一知识点博主分为三篇博客为大家进行讲解，今天为大家讲解第二篇java中实现多个接口，接口间的继承，抽象类和接口的区别知识点，更适合新手宝宝们阅读~更多内容持续更新中~

目录

1. 实现多个接口

完整代码讲解

 2. 接口间的继承

完整代码讲解

3. 抽象类和接口的区别

定义方式上不同

继承/实现方式不同

区别表格

1. 实现多个接口

        在Java中，接口（Interface）定义了一组抽象方法，用于规范类的行为。类和类之间是单继承的，一个类只能由一个父类，即java不支持类的多重继承，但是一个类可以实现多个接口，从而扩展类的功能；这种机制使得Java可以实现类似多重继承的效果。

        比如说：

  • 一个 Bird 类可以同时实现 Flyable 和 Run 这两个接口。

  • 一个 Smartphone 类可以同时实现 Callable（可打电话），Playable（可播放音乐）和 Photographable（可拍照）三个接口。

        像这样实现多个接口的话，我们可以更灵活地设计程序，避免单继承的限制，可以让类具备更多的功能~

首先，我们初步定义了一个狗狗类🐶继承动物类：

//建立一个动物抽象类：
//1.用abstract修饰，表示这是一个抽象类，不能直接创建实例
//2.包含了所有动物共有的属性和方法
public abstract class Animal {
    //公共属性名字和年龄（所有动物和植物都有的）
    public String name;
    public int age;
    //抽象方法：吃东西
    //1.用abstract修饰，没有具体的实现
    //2.所有的子类必须实现这个方法
    public abstract void eat();
    //动物类的构造方法
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
}
//定义了一个狗狗类
//1.继承自动物类（extends Animal）
//2.必须实现父类的抽象方法eat()
public class Dog extends Animal{
    //狗狗的构造方法
    public Dog(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override//表示重写
    public void eat() {
        System.out.println(name+"吃狗粮啦~");
    }
}

        写完上面代码后，我们知道狗狗不仅会游泳，也会跑步，则可以让这个狗狗类实现游泳接口和跑步接口（前提是定义了游泳和跑步的接口）：

 定义的三个接口，狗狗只能实现里面的两个：

public interface Flyable {
    void fly();
}
public interface Running {
    void run();
}
public interface Swimming {
    void swim();
}

  • extends Animal 表示继承Animal类

  • implements Running, Swimming 表示实现两个接口，后面可通过逗号再添加几个狗狗能实现的接口

// Dog通过extends继承Animal并且通过implemens实现了Running和Swimming接口
public class Dog extends Animal implements Running,Swimming{
    ...
}

在实现接口后，我们必须还要实现Running和Swimming接口里面的方法：

// Dog通过extends继承Animal并且通过implemens实现了Running和Swimming接口
public class Dog extends Animal implements Running,Swimming{
    //狗狗的构造方法
    public Dog(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override//表示重写
    public void eat() {
        System.out.println(name+"吃狗粮啦~");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"正在飞跑~");
    }
    //实现Swimming接口的swim()方法
    @Override
    public void swim() {
        System.out.println(name+"正在狗刨~");
    }
}

        所以通过上面的代码我们实现了Dog类继承Animal类，然后通过implements实现了Running和Swimming两个接口，我们要注意一定是先继承再实现接口，如果把extends放后面是会产生错误的啦：

同样的，我们知道java中一个类只能继承一个类，若是再继承一个也会产生错误啦：

        那么我们说过解决多继承的问题，到底是怎么体现的呢？我们往下看，不妨假设一下，没有Running和Swimming这两个接口，而是Running和Swimming两个类，然后Dog再继承它们：

        很显然是不行的啦~怎么可以继承多个类呢，所以我们就需要接口，可以将我们这些规则的行为放到我们接口当中，这样就能解决多继承。很明显不是所有的动物都会飞，如果我们将Flyable放到我们Animal类里面，很明显是不合适的，狗狗是不会飞的。

        我们再定义一个鸟类继承父类Animal并通过implements实现Running和Flyable接口来观察：

// Bird通过extends继承Animal并且通过implemens实现了Running和Flyable接口
public class Bird extends Animal implements Running,Flyable{
    //小鸟儿的构造方法
    public Bird(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override
    public void eat() {
        System.out.println(name+"吃鸟粮");
    }
    //实现Flyable接口的fly()方法
    @Override
    public void fly() {
        System.out.println(name+"正在酷酷飞翔");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"奋力疾走中");
    }
}

        很明显小鸟只能飞和跑，并不能游泳，所以鸟类只能实现Running和Flyable接口，不能实现Swimming接口~

🟢那么我们写下测试类：

public class Test2 {
    //测试方法1 - 接收Animal类型参数;animal可以是Animal类或其任何子类的对象
    public static void test1(Animal animal) {
        // 调用动物的eat方法，具体执行哪个看实际传入对象类型
        // 例如：test1(new Dog()) 会调用Dog类的eat()
        // test1(new Cat()) 会调用Cat类的eat()
        animal.eat();
    }
    //测试方法2 - 接收Running接口类型参数
    //是任何实现了Running接口的对象
    public static void test2(Running running) {
        //调用传入对象的run()方法
        //只要对象实现了Running接口就能传入，不管它是什么具体类
        running.run();
    }
    //测试方法3 - 接收Swimming接口类型参数
    //是任何实现了Swimming接口的对象
    public static void test3(Swimming swimming) {
        //调用传入对象的swim()方法
        //可以接收任何"会游泳"的对象
        swimming.swim();
    }
    //测试方法4 - 接收Flyable接口类型参数
    //是任何实现了Flyable接口的对象
    public static void test4(Flyable flyable) {
        //调用传入对象的fly()方法
        //可以接收任何"会飞"的对象
        flyable.fly();
    }
    //第一个测试主方法 - 演示接口多态
    public static void main1(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test2方法 - 传入会跑步的对象
        test2(bird);// 让鸟儿跑步(Bird实现了Running接口)
        test2(dog);// 让狗狗跑步(Dog实现了Running接口)
        System.out.println("----------------");// 分隔线
        // 测试test3方法 - 传入会游泳的对象
        test3(dog);// 让狗狗游泳(Dog实现了Swimming接口)
        //⚠️不可以test3(bird);Bird没有实现Swimming接口
        System.out.println("----------------");// 分隔线
        // 测试test4方法 - 传入会飞的对象
        test4(bird);// 让鸟儿飞翔(Bird实现了Flyable接口)
        //⚠️不可以test4(dog);Dog没有实现Flyable接口
    }
    //第二个测试主方法 - 演示继承多态
    public static void main2(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test1方法 - 传入动物对象
        test1(bird);// 让鸟儿吃东西(调用Bird的eat方法)
        test1(dog);// 让狗狗吃东西(调用Dog的eat方法)
        // 这里因为Bird和Dog都是Animal的子类，所以都可以传入啦
    }
}

🌟 我们可以从上述代码得出以下的一些个人理解：

1. 多态是什么？

  • 就像同一个"动作"在不同对象上有不同表现
  • 例如：同样是"吃"，鸟吃鸟粮，狗吃狗粮

2. 接口多态（main1演示）

  • test2( )中可以接受任何会跑步的对象（实现了Running接口就可以）

  • 不管传入的是鸟还是狗，只要会跑步就行

3. 继承多态（main2演示）

  • test1( )可以接受任何动物对象（是Animal的子类）

  • 不管传入的是鸟还是狗，因为它们都是动物

4. 那么为什么这样设计呢？

  • 能提高代码灵活性：不需要为每种动物写单独的方法

  • 便于扩展：新增一些动物类型的时候不需要修改测试方法

⚠️还是再提一下：每个测试方法(test1-test4)的行为取决于：实际传入的对象类型，该对象对应方法的实现方式~

完整代码讲解

下面是完整版本的代码：附带超详细注释，更适合新手宝宝们阅读~

// 1. 首先定义接口
public interface Flyable {
    void fly();
}
public interface Running {
    void run();
}
public interface Swimming {
    void swim();
}

// 2. 定义抽象父类
//建立一个动物抽象类：
//1.用abstract修饰，表示这是一个抽象类，不能直接创建实例
//2.包含了所有动物共有的属性和方法
public abstract class Animal {
    //公共属性名字和年龄（所有动物和植物都有的）
    public String name;
    public int age;
    //抽象方法：吃东西
    //1.用abstract修饰，没有具体的实现
    //2.所有的子类必须实现这个方法
    public abstract void eat();
    //动物类的构造方法
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
}

// 3. 定义具体实现类
// Bird通过extends继承Animal并且通过implemens实现了Running和Flyable接口
public class Bird extends Animal implements Running,Flyable{
    //小鸟儿的构造方法
    public Bird(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override
    public void eat() {
        System.out.println(name+"吃鸟粮");
    }
    //实现Flyable接口的fly()方法
    @Override
    public void fly() {
        System.out.println(name+"正在酷酷飞翔");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"奋力疾走中");
    }
}

// Dog通过extends继承Animal并且通过implemens实现了Running和Swimming接口
public class Dog extends Animal implements Running,Swimming{
    //狗狗的构造方法
    public Dog(String name, int age) {
        //通过super调用父类的构造方法初始化name和age
        super(name, age);
    }
    //实现父类的eat()方法
    @Override//表示重写
    public void eat() {
        System.out.println(name+"吃狗粮啦~");
    }
    //实现Running接口的run()方法
    @Override
    public void run() {
        System.out.println(name+"正在飞跑~");
    }
    //实现Swimming接口的swim()方法
    @Override
    public void swim() {
        System.out.println(name+"正在狗刨~");
    }
}

// 4. 定义测试类
public class Test2 {
    //测试方法1 - 接收Animal类型参数;animal可以是Animal类或其任何子类的对象
    public static void test1(Animal animal) {
        // 调用动物的eat方法，具体执行哪个看实际传入对象类型
        // 例如：test1(new Dog()) 会调用Dog类的eat()
        // test1(new Cat()) 会调用Cat类的eat()
        animal.eat();
    }
    //测试方法2 - 接收Running接口类型参数
    //是任何实现了Running接口的对象
    public static void test2(Running running) {
        //调用传入对象的run()方法
        //只要对象实现了Running接口就能传入，不管它是什么具体类
        running.run();
    }
    //测试方法3 - 接收Swimming接口类型参数
    //是任何实现了Swimming接口的对象
    public static void test3(Swimming swimming) {
        //调用传入对象的swim()方法
        //可以接收任何"会游泳"的对象
        swimming.swim();
    }
    //测试方法4 - 接收Flyable接口类型参数
    //是任何实现了Flyable接口的对象
    public static void test4(Flyable flyable) {
        //调用传入对象的fly()方法
        //可以接收任何"会飞"的对象
        flyable.fly();
    }
    //第一个测试主方法 - 演示接口多态
    public static void main1(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test2方法 - 传入会跑步的对象
        test2(bird);// 让鸟儿跑步(Bird实现了Running接口)
        test2(dog);// 让狗狗跑步(Dog实现了Running接口)
        System.out.println("----------------");// 分隔线
        // 测试test3方法 - 传入会游泳的对象
        test3(dog);// 让狗狗游泳(Dog实现了Swimming接口)
        //不可以test3(bird);Bird没有实现Swimming接口
        System.out.println("----------------");// 分隔线
        // 测试test4方法 - 传入会飞的对象
        test4(bird);// 让鸟儿飞翔(Bird实现了Flyable接口)
        //不可以test4(dog);Dog没有实现Flyable接口
    }
    //第二个测试主方法 - 演示继承多态
    public static void main2(String[] args) {
        // 创建一只鸟对象，名字叫"愤怒的小鸟儿"，年龄2岁
        Bird bird = new Bird("愤怒的小鸟儿",2);
        // 创建一只狗对象，名字叫"开心的小狗狗"，年龄3岁
        Dog dog = new Dog("开心的小狗狗",3);
        // 测试test1方法 - 传入动物对象
        test1(bird);// 让鸟儿吃东西(调用Bird的eat方法)
        test1(dog);// 让狗狗吃东西(调用Dog的eat方法)
        // 这里因为Bird和Dog都是Animal的子类，所以都可以传入啦
    }
}

最后的输出结果为：

愤怒的小鸟儿奋力疾走中  
开心的小狗狗正在飞跑~
----------------
开心的小狗狗正在狗刨~
----------------
愤怒的小鸟儿正在酷酷飞翔

 最后总结一下：

        上述代码展示了一个类继承一个父类，同时实现多种接口。继承表达的含义是 is-a，而接口表达的含义是具有某某特性。

 2. 接口间的继承

        想象你正在设计一个动物园管理系统。最初，你定义了Swimming（可游泳）和Flyable（可飞行）两个基础接口。但随着系统发展，你发现有些鸟类既会飞又会潜水（比如企鹅）。这时候，就需要用到接口间的继承啦~重新定义一个接口，这个接口具备Swimming和Flyable这两个接口的功能，让这个新的接口继承Swimming接口和Flyable接口~

例如我们先定义三个接口：

//分别定义了两个个接口
//并分别定义了各自的抽象方法
interface A {
    void testA();
}
interface B {
    void testB();
}

这时候我们想要有一个接口，拥有A和B这两个接口的功能，则这样实现：

//有一个接口，具备A和C接口的功能，extends为扩展
interface C extends A,B {
    //C这个接口具备了B和C的功能,同时也有自己的抽象方法
    void testC();
}

那么当一个类实现我们C接口，需要重写A,B,C里的三个方法：

public class Test4 implements C{

    @Override
    public void testA() {
        
    }
    @Override
    public void testB() {

    }
    @Override
    public void testC() {

    }
}

完整代码讲解

实现接口间继承示例完整的代码如下：

//分别定义了三个接口
//并分别定义了各自的抽象方法
interface A {
    void testA();
}
interface B {
    void testB();
}
//有一个接口，具备A和C接口的功能，extends为扩展
interface C extends A,B {
    //C这个接口具备了B和C的功能,同时也有自己的抽象方法
    void testC();
}
//实现子接口的类必须实现所有继承链上的抽象方法
public class Test4 implements C{

    @Override
    public void testA() {

    }
    @Override
    public void testB() {

    }
    @Override
    public void testC() {

    }
}

        接口C通过extends关键字继承了接口A和B，通过上述代码我们可以总结出接口继承的特点：

  • 一个接口(C)可以继承多个父接口(A,B)
  • 子接口(C)可以继承所有父接口(A,B)的抽象方法
  • 子接口可以定义自己的新方法
  • 接口间的继承相当于把多个接口合并在一起

3. 抽象类和接口的区别

🔴java中抽象类和接口的区别，这是常见的面试题

抽象类和接口都是 Java 中多态的常见使用方式，我们需要知道：

"抽象类管是什么，接口管能做什么"

抽象类关注类的本质，接口关注行为扩展。

定义方式上不同

// 抽象类 - 用abstract修饰
abstract class Animal {
    // 可以有具体属性
    String name;
    int age;
    
    // 可以有具体方法
    public void sleep() {
        System.out.println("动物在睡觉");
    }
    
    // 可以有抽象方法
    public abstract void eat(); 
}

// 接口 - 用interface修饰
interface Swimmable {
    // 只能有常量（默认是public static final）
    int a = 5;
    
    // 只能有抽象方法（Java8前）
    void swim();
}

继承/实现方式不同

// 类继承抽象类（extends）
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃狗粮");
    }
}

// 类实现接口（implements）
class Fish implements Swimmable {
    @Override
    public void swim() {
        System.out.println("鱼在游泳");
    }
}

区别表格

特性抽象类接口
关键字abstract classinterface
子类继承/实现使用extends关键字继承抽象类（单继承）使用implements关键字实现接口（多实现）
构造方法有无
结构组成普通类+抽象方法抽象方法+全局变量
设计理念"是什么"（is-a关系）"能做什么"（has-a能力）
适用场景有共同特征的类

定义类的行为规范

关系一个抽象类可以实现多个接口

接口不能继承抽象类，

但是可以使用extends继承多个父接口

那么我们该选择哪个使用，可以根据以下内容选择：

1. 用抽象类当：

  • 多个类有共同属性和方法时
  • 需要定义一些默认实现时
  • 例子：不同种类的鸟都有羽毛，都会飞，但飞行方式不同

2. 用接口当：

  • 只想定义行为规范时
  • 需要类具备多种能力时
  • 例子：鸭子既能游泳(Swimming)又跑(Running）

💡总结一下：

        抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用(不必重写)。

       而接口中，不能包含普通方法，子类必须重写所有的抽象方法。比如此处的 Animal 中包含一个 name 这样的属性，这个属性在任何子类中都是存在的。因此此处的 Animal 只能作为一个抽象类，而不应该成为一个接口。

class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
 }

在这其中，也经常会有这些面试题： 

  • 一个类能同时继承类和实现接口吗？

✅ 可以的，先extends类后implements接口

  • 接口能继承类吗？

❌ 不能的，接口只能继承接口

制作不易，更多内容加载中~感谢友友们的点赞收藏关注~~

如有问题欢迎批评指正，祝友友们生活愉快，学习工作顺顺利利！

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

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

相关文章

边缘计算盒子是什么？

边缘计算盒子是什么？

边缘计算盒子是一种小型的硬件设备，通常集成了处理器、存储器和网络接口等关键组件，具备一定的计算能力和存储资源，并能够连接到网络。它与传统的云计算不同，数据处理和分析直接在设备本地完成，而不是上传到云端&#…
阅读更多...
大数据系列 | 详解基于Zookeeper或ClickHouse Keeper的ClickHouse集群部署--完结

大数据系列 | 详解基于Zookeeper或ClickHouse Keeper的ClickHouse集群部署--完结

大数据系列 | 详解基于Zookeeper或ClickHouse Keeper的ClickHouse集群部署 1. ClickHouse与MySQL的区别2. 在群集的所有机器上安装ClickHouse服务端2.1. 在线安装clickhouse2.2. 离线安装clickhouse 3. ClickHouse Keeper/Zookeeper集群安装4. 在配置文件中设置集群配置5. 在每…
阅读更多...
19Linux自带按键驱动程序的使用_csdn

19Linux自带按键驱动程序的使用_csdn

1、自带按键驱动程序源码简析 2、自带按键驱动程序的使用 设备节点信息&#xff1a; gpio-keys {compatible "gpio-keys";pinctrl-names "default";pinctrl-0 <&key_pins_a>;autorepeat;key0 {label "GPIO Key L";linux,code &l…
阅读更多...
用银河麒麟 LiveCD 快速查看原系统 IP 和打印机配置

用银河麒麟 LiveCD 快速查看原系统 IP 和打印机配置

原文链接&#xff1a;用银河麒麟 LiveCD 快速查看原系统 IP 和打印机配置 Hello&#xff0c;大家好啊&#xff01;今天给大家带来一篇在银河麒麟操作系统的 LiveCD 或系统试用镜像环境下&#xff0c;如何查看原系统中电脑的 IP 地址与网络打印机 IP 地址的实用教程。在系统损坏…
阅读更多...
.net core 项目快速接入Coze智能体-开箱即用-第2节

.net core 项目快速接入Coze智能体-开箱即用-第2节

目录 一、Coze智能体的核心价值 二、开箱即用-效果如下 三 流程与交互设计 本节内容调用自有或第三方的服务 实现语音转文字 四&#xff1a;代码实现----自行实现 STT 【语音转文字】 五&#xff1a;代码实现--调用字节API实现语音转文字 .net core 项目快速接入Coze智能…
阅读更多...
win10中打开python的交互模式

win10中打开python的交互模式

不是输入python3&#xff0c;输入python&#xff0c;不知道和安装python版本有没有关系。做个简单记录&#xff0c;不想记笔记了
阅读更多...
时序逻辑电路——序列检测器

时序逻辑电路——序列检测器

文章目录 一、序列检测二、牛客真题1. 输入序列连续的序列检测&#xff08;输入连续、重叠、不含无关项、串行输入&#xff09;写法一&#xff1a;移位寄存器写法二&#xff1a;Moore状态机写法三&#xff1a;Mealy状态机 一、序列检测 序列检测器指的就是将一个指定的序列&…
阅读更多...
TikTok X-Gnarly纯算分享

TikTok X-Gnarly纯算分享

TK核心签名校验&#xff1a;X-Bougs 比较简单 X-Gnarly已经替代了_signature参数&#xff08;不好校验数据&#xff09; 主要围绕query body ua进行加密验证 伴随着时间戳 浏览器指纹 随机值 特征值 秘钥转换 自写算法 魔改base64编码 与X-bougs 长a-Bougs流程一致。 视频…
阅读更多...
LPDDR5协议新增特性

LPDDR5协议新增特性

文章目录 一、BL/n_min参数含义二、RDQS_t/RDQS_c引脚的功能三、DMI引脚的功能3.1、Write操作时的Data Mask数据掩码操作3.2、Write/Read操作时的Data Bus Inversion操作四、CAS命令针对WR/RD/Mask WR命令的低功耗组合配置4.1、Write/Read操作前的WCK2CK同步操作4.2、Write/Rea…
阅读更多...
【深度学习】#8 循环神经网络

【深度学习】#8 循环神经网络

主要参考学习资料&#xff1a; 《动手学深度学习》阿斯顿张 等 著 【动手学深度学习 PyTorch版】哔哩哔哩跟李牧学AI 为了进一步提高长线学习的效率&#xff0c;该系列从本章开始将舍弃原始教材的代码部分&#xff0c;专注于理论和思维的提炼&#xff0c;系列名也改为“深度学习…
阅读更多...
Linux学习——UDP

Linux学习——UDP

编程的整体框架 bind&#xff1a;绑定服务器&#xff1a;TCP地址和端口号 receivefrom()&#xff1a;阻塞等待客户端数据 sendto():指定服务器的IP地址和端口号&#xff0c;要发送的数据 无连接尽力传输&#xff0c;UDP:是不可靠传输 实时的音视频传输&#x…
阅读更多...
leetcode205.同构字符串

leetcode205.同构字符串

两个哈希表存储字符的映射关系&#xff0c;如果前面字符的映射关系和后面的不一样则返回false class Solution {public boolean isIsomorphic(String s, String t) {if (s.length() ! t.length()) {return false;}int length s.length();Map<Character, Character> s2…
阅读更多...
软考软件设计师考试情况与大纲概述

软考软件设计师考试情况与大纲概述

文章目录 **一、考试科目与形式****二、考试大纲与核心知识点****科目1&#xff1a;计算机与软件工程知识****科目2&#xff1a;软件设计** **三、备考建议****四、参考资料** 这是一个系列文章的开篇 本文对2025年软考软件设计师考试的大纲及核心内容进行了整理&#xff0c;并…
阅读更多...
Redis—内存淘汰策略

Redis—内存淘汰策略

记&#xff1a;全体LRU&#xff0c;ttl LRU&#xff0c;全体LFU&#xff0c;ttl LFU&#xff0c;全体随机&#xff0c;ttl随机&#xff0c;最快过期&#xff0c;不淘汰&#xff08;八种&#xff09; Redis 实现的是一种近似 LRU 算法&#xff0c;目的是为了更好的节约内存&…
阅读更多...
Power BI企业运营分析——数据大屏搭建思路

Power BI企业运营分析——数据大屏搭建思路

Power BI企业运营分析——数据大屏搭建思路 欢迎来到Powerbi小课堂&#xff0c;在竞争激烈的市场环境中&#xff0c;企业运营分析平台成为提升竞争力的核心工具。 整合多源数据&#xff0c;实时监控关键指标&#xff0c;精准分析业务&#xff0c;快速识别问题机遇。其可视化看…
阅读更多...
oracle将表字段逗号分隔的值进行拆分,并替换值

oracle将表字段逗号分隔的值进行拆分,并替换值

需求背景&#xff1a;需要源数据变动&#xff0c;需要对历史表已存的字段值根据源数据进行更新。如果是单字段存值&#xff0c;直接根据映射表关联修改即可。但字段里面若存的值是以逗号分割&#xff0c;比如旧值&#xff1a;‘old1,old2,old3’&#xff0c;要根据映射关系调整…
阅读更多...
【重走C++学习之路】16、AVL树

【重走C++学习之路】16、AVL树

目录 一、概念 二、AVL树的模拟实现 2.1 AVL树节点定义 2.2 AVL树的基本结构 2.3 AVL树的插入 1. 插入步骤 2. 调节平衡因子 3. 旋转处理 4. 开始插入 2.4 AVL树的查找 2.5 AVL树的删除 1. 删除步骤 2. 调节平衡因子 3. 旋转处理 4. 开始删除 结语 一、概念 …
阅读更多...
597页PPT丨流程合集：流程梳理方法、流程现状分析，流程管理规范及应用，流程绩效的管理，流程实施与优化，流程责任人的角色认知等

597页PPT丨流程合集：流程梳理方法、流程现状分析，流程管理规范及应用，流程绩效的管理，流程实施与优化，流程责任人的角色认知等

流程梳理是通过系统化分析优化业务流程的管理方法&#xff0c;其核心包含四大步骤&#xff1a;①目标确认&#xff0c;明确业务痛点和改进方向&#xff1b;②现状分析&#xff0c;通过流程图、价值流图还原现有流程全貌&#xff0c;识别冗余环节和瓶颈节点&#xff1b;③优化设…
阅读更多...
来啦，烫，查询达梦表占用空间

来啦，烫，查询达梦表占用空间

想象一下oracle&#xff0c;可以查dba_segments&#xff0c;但是这个不可靠&#xff08;达梦官方连说明书都没有&#xff09; 先拼接一个sql set lineshow off SELECT SELECT ||||OWNER|||| AS OWNER,||||TABLE_NAME|||| AS TABLE_NAME,TABLE_USED_SPACE(||||OWNER||||,||||T…
阅读更多...
vue3:十一、主页面布局(修改左侧导航条的样式)

vue3:十一、主页面布局(修改左侧导航条的样式)

一、样式 1、初始样式 2、 左侧导航栏搭建完成样式 二、实现 1、设置左侧导航栏底色 (1)去掉顶部和左侧导航栏的底色 初始页面效果 顶部与左侧底色样式 将代码中与顶部与左侧的样式删掉 移除后页面效果 加入设定背景色 #f4f6f9 加入底色后颜色展示 (2)去除菜单项底色 初…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023