day02-面向对象-多态&抽象类&接口

于 2024-08-27 22:00:52 发布
阅读量768 收藏 8
点赞数 18
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58478983/article/details/141613433
版权

一、⭐多态⭐

1.1 概述

1.多态
    是在继承/实现情况下的一种现象, 表现为对象多态和行为多态
​
2.⭐对象多态写法：
​
        继承：
            父类 变量 = new 子类1()；
​
            父类 变量 = new 子类2()；
        实现：
            接口 变量 = new 实现类();
​
3.多态的前提（对象多态的前提为1,2条；行为多态的前提为这3条）
    1. 有继承/实现关系
    2. 存在父类引用指向子类对象
    3. 有方法的重写
​
4.多态的注意事项
    多态是对象、行为的多态； 变量则不涉及多态
   
5.代码执行:
    编译看左，运行看右
//父类
public class People {
    private int age;
    private String name;
    //定义父类People, 内含跑步run方法
    public void run(){
        System.out.println("父类People, 跑步run方法");
    }
}
​
//子类
public class Student extends People{
    @Override
    public void run() {
        System.out.println("学生跑");
    }
}
public class Teacher extends People{
    @Override
    public void run() {
        System.out.println("老师跑");
    }
}
​
//测试类
public class Demo {
    public static void main(String[] args) {
        //使用多态的形式创建Student对象
        People p1 = new Student();
        p1.run();
        //使用多态的形式创建Teacher对象
        People p2 = new Teacher();
        p2.run();
    }
}

 

1.2 多态的好处和弊端

多态的好处
    1. 在多态形式下，等号左右两边松耦合，更便于修改和维护
    2. 在多态下, 定义方法时, 可以使用父类类型作为形参, 那么该方法可以接收该父类下所有子类的对象
​
public class Demo {
    public static void main(String[] args) {
        //好处1: 在多态形式下，等号左右两边松耦合，更便于修改和维护
        //创建一个老师对象,调用5次跑步的方法=======有一天需求改了========>创建一个学生对象,调用5次跑步的方法
       //使用普通写法
        Teacher teacher = new Teacher();//改成学生对象的话，需要整体修改
        teacher.run();
        teacher.run();
        teacher.run();
        teacher.run();
        teacher.run();

        //*使用多态的写法
        Person person = new Teacher();//改成学生对象的话，直接就将Teacher 改成 Student就完成了
        person.run();
        person.run();
        person.run();
        person.run();
        person.run();
------------------------------------------------------------------
        //调用login方法,可以使用父类类型作为形参, 那么该方法可以接收该父类下所有子类的对象
        Person person1 = new Student();
        person1.login();//学生登录
        Person person2 = new Teacher();
        person2.login();//老师登录
    }

    //好处2: 在多态下, 定义方法时, 可以使用父类类型作为形参, 那么该方法可以接收该父类下所有子类的对象
    //创建一个login方法,接收一个老师对象,然后调用对象的login方法=======有一天需求改了========>接收一个学生对象,然后调用对象的login方法
    //使用普通写法
    public static void login(Teacher teacher){//改成学生对象的话，需要整体修改
        teacher.login();
    }
    //*使用多态的写法
    public static void login(Person person){//直接让父类类型作为形参
        person.login();
    }
}

//父类
class Person{
    public void run(){}
    public void login(){}
}
//学生子类
class Student extends Person{
    @Override
    public void run() {
        System.out.println("学生跑的快");
    }

    @Override
    public void login() {
        System.out.println("学生登录");
    }
}
//老师子类
class Teacher extends Person{
    @Override
    public void run() {
        System.out.println("老师跑的慢");
    }

    @Override
    public void login() {
        System.out.println("老师登录");
    }
}
多态的弊端
    不能直接使用子类特有的功能
    解决方案: 强制类型转换
​
多态中的转型
    子-->父 (小到大 自动转换): 
            也称为向上转型, 父类引用指向子类对象 Person p = new Student();
    父-->子 (大到小 强制转换): 
            也称为向下转型, 父类引用转为子类对象 Student s = (Student)p;
​
强转风险
    强转是存在风险的, 如果转为父类引用记录的真实子类对象,那么不会报错(否则会报ClassCastException)
    如果想规避这个风险,可以在强转前,使用instanceof关键字, 判断变量对应的类型
public class Demo {
    public static void main(String[] args) {
        //1.多态创建一个学生对象
         Person p1 = new Student();
         //Person p1 = new Teacher();//强转时报错ClassCastException:真实类型与强转类型不一致
         System.out.println(p1);
        //2.调用方法
        p1.run();
        //3.调用学生独有功能
        //4.判断真实类型与强转类型不一致   语法：变量 instanceof 类型
        //报错ClassCastException:真实类型与强转类型不一致
        if (p1 instanceof Student){
            //将p1转化为子类的对象(父类转化为子类，用强转)
            Student s1 = (Student) p1;
            s1.study();
        }else {
            System.out.println("真实类型与强转类型不一致");
        }
        
        System.out.println("------------------------------------------------");
        Person p2 = new Teacher();
        method(p2);
    }
    
     public static void method(Person person){
        //调用老师的run()方法
        person.run();
​
        //需求: 想再调用一下老师的teach()方法
        if(person instanceof Teacher){
            Teacher t1 = (Teacher) person;
            t1.teach();
        }else {
            System.out.println("真实类型与强转类型不一致");
        }
    }
    
}
​
class Person{
    public void run(){}
}
​
class Student extends Person {
    @Override
    public void run() {
        System.out.println("学生跑的快");
    }
​
    //独有方法
    public void study(){
        System.out.println("学生在学习~~~~");
    }
}
​
class Teacher extends Person {
    @Override
    public void run() {
​
        System.out.println("老师跑的慢");
    }
​
    //独有方法
    public void teach(){
​
        System.out.println("老师在上课~~~~");
    }
}

运行结果：

二、final

final关键字是最终的意思，可以修饰（类、方法、变量） ⭐ 修饰类：该类被称为最终类, 类不能再被继承 ⭐ 修饰方法：该方法被称为最终方法, 方法不能被重写 ⭐ 修饰变量：该变量只能被赋值一次, 赋值完毕之后不能再修改 成员变量: 声明时赋完值,或者在构造方法结束之前完成赋值 局部变量: 变量只能被赋值一次

⭐final修饰变量的注意事项 基本类型变量: 变量记录的数据不能再被改变 引用类型变量: 变量记录的地址不能再被改变, 但是地址对应的堆内存中的内容可以改变

public class Demo {
    public static void main(String[] args) {
       //基本类型变量: 变量记录的数据不能再被改变    
            final int age = 10;
            //age = 20;//编译报错, 因为age被final修饰了, 不能再被赋值
            System.out.println(age);
            final Son son = new Son();
            //son = new Son();//编译报错, 因为son被final修饰了, 不能再被赋值
         son.run();
        
        //引用类型变量: 变量记录的地址不能再被改变, 但是地址对应的堆内存中的内容可以改变
            final int[] arr = {1,2,3};
            arr[0] = 5;//内容可变
            int[] arr1 = {1,2,4};
            //arr = arr1;//编译报错, 因为arr被final修饰了, 地址不能改变
        
    }
}
​
class Father {
    public  void run() {
        System.out.println("爸爸在跑");
    }
}
​
class Son extends Father {
    final String name = "lisi";
    String school;
​
    @Override
    public void run() {
        int age = 10;
        //name = "zhangsan"; //编译报错, 因为name被final修饰了, 不能再被赋值
        System.out.println(age + "岁的儿子在跑");
    }
}

三、抽象类

3.1 抽象类概述

1.抽象类和抽象方法
    在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。
        abstract修饰类，这个类就是抽象类
        abstract修饰方法，这个方法就是抽象方法，抽象方法没有方法体
        
 2.语法：
​
        修饰符 abstract class 类名{
​
            修饰符 abstract 返回值类型 方法名称（形参列表）；
​
        }       
​
3.抽象类的特点
    1. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
    2. 类该有的成员（成员变量、方法、构造器）抽象类都可以有。
    3. 抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
    4. 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
public class Demo {
    public static void main(String[] args) {
        Person p1 = new Student();
        p1.run();
        Person p2 = new Teacher();
        p2.run();
​
        //Person p3 = new Person();//抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
    }
}
​
//需求1: 将Person类声明为抽象类
abstract class Person {
    //成员变量
    private String name;
​
    //成员方法
    public  void eat(){
        System.out.println("吃饭");
    }
​
    //需求2: 将run方法修改为抽象方法
    public abstract void run();
}
​
class Student extends Person{
    @Override
    public void run() {
        System.out.println("学生跑步");
    }
}
​
class Teacher extends Person{//鼠标放在这里看提示，Alt+Enter
    @Override
    public void run() {
        System.out.println("老师跑步");
    }
}
//一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
abstract class Employee extends Person{
​
}

3.2 抽象类的场景和好处

抽象类的应用场景和好处
    1、将所有子类中重复的代码，抽取到抽象的父类中，提高了代码的复用性(先编写子类，再编写抽象类)
    2、我们不知道系统未来具体的业务时，可以先定义抽象类，将来让子类去继承实现，提高了代码的扩展性 (先编抽象类，再编写子类)
/*
需求
    某宠物游戏，需要管理猫、狗的数据。
        猫的数据有：名字；行为是：喵喵喵的叫~
        狗的数据有：名字；行为是：汪汪汪的叫~
 */       
public class Demo {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.setName("小花");//小花喵喵喵的叫~
        cat.cry();
        System.out.println("-------------------");
        Animal dog = new Dog();
        dog.setName("小黑");//小黑汪汪汪的叫~
        dog.cry();
​
    }
}
​
//动物的父类，公共的属性和方法
abstract class Animal {
    private String name;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
    public abstract void cry();
}
​
//猫
class Cat extends Animal {
​
    @Override
    public void cry() {
        System.out.println(getName() + "喵喵喵的叫~");
    }
}
​
//狗
class Dog extends Animal {
​
    @Override
    public void cry() {
        System.out.println(getName() + "汪汪汪的叫~");
    }
}

3.3 模板方法设计模式（为了解决某些特定问题的编码套路）

设计模式
    对于某类问题,前人总结出类的解决问题的套路
​
模板方法设计模式用来解决什么问题？
    1.一个功能的完成需要经过一系列步骤,这些步骤是固定的
    2.但是中间某些步骤具体行为是待定的,在不同的场景中行为不同
​
使用思路
    1、定义一个抽象类(Person作为父类)，提供模板方法
    2、模板方法中，需要让子类自己实现的地方，定义为抽象方法
    3、子类(Teacher Student)只需要继承该抽象类，重写抽象方法即可完成对应的功能
​
多学一招:
    建议使用final关健字修饰模板方法
        模板方法是给对象直接使用的，不能被子类重写
        一旦子类重写了模板方法，模板方法就失效了

 

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Person p1 = new Student();
        //执行模板方法
        p1.work();
        System.out.println("-------------------");
        Person p2 = new Teacher();
        p2.work();
    }
}
/**
 * 抽象类模板
 */
abstract class Person {
​
    /**
     * 1.定义模板（必须具有执行的步骤和顺序）
     * 建议使用final关健字修饰模板方法
     *         模板方法是给对象直接使用的，不能被子类重写
     *         一旦子类重写了模板方法，模板方法就失效了
     */
   final public void work() {
        System.out.println("1.吃饭");
        dowork();
        System.out.println("3.睡觉");
    }
    //2.定义抽象方法，让子类实现
    public abstract void dowork();
}
​
/**
 * 子类
 */
class Teacher extends Person {
    @Override
    public void dowork() {
        System.out.println("2.教课");
    }
}
​
class Student extends Person {
​
    @Override
    public void dowork() {
        System.out.println("2.学习");
    }
}

执行结果：

四、⭐接口⭐

4.1 概述

⭐接口
    Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口
​
⭐定义格式
    public interface 接口名 {
        成员变量（接口中的成员变量都是常量, 默认是被public static final修饰的）
        成员方法（接口中的成员方法都是抽象方法, 默认是被public abstract修饰的）
        注意: 接口中不能有构造方法和代码块
    }
​
⭐注意事项
    1. 接口不能直接创建对象
    2. 接口是用来被类实现（implements）的，实现接口的类称为⭐实现类⭐。
    3. 一个类可以实现多个接口，实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。
        修饰符 class 实现类 implements 接口1, 接口2, 接口3 , ... {
            
        }
        
⭐步骤：    
    1.定义接口 ： interface
    2.定义接口实现类，实现上面接口中的所有抽象方法 ： implements
    3.测试类：创建 接口 变量 = new 实现类()
//定义接口
public interface UserInterface {
    //定义成员变量,默认是public static final
    String name = "张三";
​
    //定义成员方法,默认是public abstract
    void save();//抽象方法
}
/**
 * 1. 定义一个实现类, 实现UserInterface接口
 * 2.实现接口中的抽象方法
 */
public class UserInterfaceImpl implements UserInterface {
    @Override
    public void save() {
        System.out.println("保存用户" + name);
    }
}
// 测试类
public class Demo {
    public static void main(String[] args) {
        //面向接口编程，创建对象，调用方法  
        //接口 变量名 = new 实现类()
        UserInterface ui = new UserInterfaceImpl();
        ui.save();//保存用户张三
    }
}

4.2 接口特点、好处

 ⭐接口特点、好处
    让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。(解耦合)
 ⭐接口的作用：解耦
    1.接口是用来定义规范
    2.定义好xxx功能的方法名，参数，返回值类型（规范定义好，方法名不能随便改）

4.3 接口新特性（了解）

JDK8开始，接口中新增的三种方法
    1、默认方法（jdk8开始支持）：对接口中的方法提供默认实现
        使用default修饰，有方法体,可以但是不强制要求实现类重写, 只能通过实现类的对象调用
    2、静态方法（jdk8开始支持）：方便调用
         使用static修饰，有方法体，只能通过接口名调用
    3、私有方法（jdk9开始支持）：提高代码复用性
        使用private修饰，服务于接口内部，用于抽取相同的功能代码
public class Demo {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.eat();
        a.print1();// dog实现了default方法
​
        System.out.println("-----------------");
​
        Animal b = new Cat();
        b.eat();
        b.print1();// cat未实现default方法，默认调用接口的默认方法
​
        System.out.println("-----------------");
​
        Animal.print2();//dog实现了static方法
​
​
    }
}
​
interface Animal{
    void eat();
    // 默认方法：有方法体，有默认的功能实现，实现类可以选择实现此方法，也可以不实现
    default void print1(){
        System.out.println("defaultPrint");
        print3();//调用私有方法
    }
    // 静态方法：有方法体，只能通过接口名调用，不能通过实现类的对象调用
    static void print2(){
        System.out.println("staticPrint");
    }
    // 私有方法：有方法体，只能用于接口内部，用于抽取相同的功能代码
    private void print3(){
        System.out.println("privatePrint");
    }
}
​
class Dog implements Animal{
    public void eat(){
        System.out.println("动物苏醒了");
        System.out.println("动物开始用膳");
    }
​
    @Override
    public void print1() {
        System.out.println("dog实现了default方法");
    }
}
​
class Cat implements Animal{
    public void eat(){
        System.out.println("动物苏醒了");
        System.out.println("动物开始用膳");
    }
}

4.4 注意事项（了解）

接口使用注感事项
    1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
    2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
    3、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
    4、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的

五、总结

类和接口的关系总结
    1、类和类: 继承(extends)关系，对于类只支持单继承，不支持多继承，但是可以多层继承
    2、接口和接口: 继承(extends)关系，对于接口,支持多继承
    3、类和接口:实现(implements)关系，支持多实现，一个类同时实现多个接口
1. 抽象类 (Abstract Class)

  • 定义: 抽象类是一个不能实例化的类，旨在作为其他类的基类。它可以包含抽象方法（没有实现）和具体方法（有实现）。

  • 字段和构造函数: 抽象类可以有字段（成员变量）和构造函数，并且这些字段可以有初始化值。构造函数可以用来初始化对象的状态。

  • 访问修饰符: 抽象类中的方法可以有不同的访问修饰符（如 private、protected、public）。

  • 继承: 一个类只能继承一个抽象类，但可以实现多个接口。抽象类适用于需要共享代码和状态的情况。

  • 用途: 当多个子类共享一些方法和字段时，使用抽象类是合适的。例如，抽象类可以定义一些通用的方法实现，并允许子类扩展或重写这些方法。

2. 接口 (Interface)

  • 定义: 接口是一种纯粹的抽象类型，用于定义一组方法的签名（即方法名和参数），并可以提供一些方法的默认实现（从 Java 8 开始）。接口不能包含字段（除了 public static final 的常量）和构造函数。

  • 实现: 接口中的方法默认是 public 和 abstract（除非它们是 default 或 static 方法）。实现接口的类必须提供这些方法的具体实现。

  • 多重实现: 一个类可以实现多个接口，这样可以弥补 Java 单继承的局限性，允许类从多个来源获取功能。

  • 用途: 接口适用于定义某些行为的契约，而这些行为可以由不同的类实现。这对于需要不同类之间共享某种行为而又不需要继承特定类时非常有用。例如，Runnable 接口允许不同的类实现并定义线程的行为。

总结

  • 抽象类 适用于有一些共用实现和状态的场景，子类可以继承这些共用的实现。

  • 接口 适用于定义行为契约，类可以实现多个接口，从而在不同的类中实现这些行为。

在实际使用中，选择使用抽象类还是接口取决于具体的设计需求和架构要求。

3.多态

Java中的多态主要通过以下两个方面实现：

（1）方法重写

方法重写是指子类提供对父类方法的具体实现，实现行动多态。在Java中，当子类重写父类的方法时，子类方法的签名必须与父类中的方法完全一致。

（2）接口实现 (Interface Implementation)

接口定义了一组方法，任何实现这个接口的类都必须提供这些方法的具体实现。接口使得不同的类可以实现相同的行为，但它们不需要有共同的祖先类。

多态的优势

  • 灵活性: 多态允许程序在运行时决定调用哪个方法，提供了灵活的调用方式。

  • 可扩展性: 通过接口和方法重写，新的类可以轻松地加入到现有系统中，而无需修改现有代码。

  • 代码重用: 通过父类和接口定义通用的方法，子类可以重用这些方法的签名和行为，而只需实现具体的逻辑。

关键点

  • 动态绑定: 多态是动态绑定的基础。Java 在运行时根据对象的实际类型决定调用哪个方法，而不是编译时。

  • 继承和接口: 方法重写依赖于继承，而接口允许不同类实现相同的方法，都是实现多态的方式。

通过这两个机制，Java 提供了一种强大的方式来实现灵活的代码设计和运行时行为的变化。

草莓屁屁不酸
关注
  • 18
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【js数组对象合并相同ID的对象】
刘优秀的博客
06-27 1万+
背景：dbc文件配置 将fileid一直的signal合并在一起 意指将 [fileId: “239”,signal:{CDU_4:[‘CDU_NavilimitSpdVD’,‘CDU_ICM_ModeSet’]} [fileId: “239”,signal:{TheMessage:[‘TheSignal’]}中ID相同的signal进行合并 组成新的数组 成为 [fileId: “239”,signal:{TheMessage:[‘TheSignal’]，CDU_4:[‘CDU_NavilimitSpdV
Arguments 对象
weixin_49035434的博客
03-30 3591
arguments 是一个对应于传递给函数的参数的类数组对象。 arguments对象是所有(非箭头)函数中都可用的局部变量. 可以使用arguments对象在函数中引用函数的参数.索引从0开始. arguments对象是一个伪数组. 除了length和索引外,不能用任何数组的方法 提供几个伪数组转真数组的方法. var args = Array.prototype.slice.call(arguments); var args = [].slice.call(arguments); //
面向对象程序设计概念
kangjialong_的博客
11-02 2367
一. 程序设计范型   面向对象程序设计（object-oriented programming，OOP）是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格，它是一类程序设计语言的基础。 面向对象设计范型的主要特征是：  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是：一、程序一般由类的定义和类的使用两部分组成；二、程序中的一切操作都是向对象发送消息来实现的，对象收到消息后，启动有关方法完成相应的操作。   需要说明的是，某一种程序设计语言不一定与一种程
document对象
你若盛开，清风自来
02-13 6095
一、Document对象 1、什么是Document对象？ DOM(Document Object Model,文档对象模型)定义了访问和操作HTML文档的标准方法。它把HTML文档表现为带有元素、属性和文本的树结构（节点树），如下图所示： 文档对象:代表浏览器窗口中的文档，每个载入浏览器的HTML文档都会成为Document对象。 作用：访问HTML文档中包含的任何HTML标记并可动态地改变HT...
吃人的那些 Java 名词：对象、引用、堆、栈
热门推荐
沉默王二
09-05 5万+
作为一个有着 8 年 Java 编程经验的 IT 老兵，说起来很惭愧，我被 Java 当中的四五个名词一直困扰着：**对象、引用、堆、栈、堆栈**（栈可同堆栈，因此是四个名词，也是五个名词）。每次我看到这几个名词，都隐隐约约觉得自己在被一只无形的大口慢慢地吞噬，只剩下满地的衣服碎屑（为什么不是骨头，因为骨头也好吃）。
JS对象数组去重
老电影故事的博客
11-08 3737
【代码】JS对象数组根据对象的多个属性值去重。
JavaScript对象解构
CSPsy的博客
04-04 5529
JavaScript对象解构 解构赋值对象 JS对象解构 对象解构是什么，对象解构的基本使用 对象的嵌套解构，在函数参数列表中使用解构赋值，部分解构，什么是部分解构
ts 遍历对象
卜卦的博客
09-02 4138
不要使用 for in，参考这里 for (const [key, val] of Object.entries(obj)) { console.log(key, val) }
Java中各种比较对象方式对比
老徐的博客只有干货
06-14 4228
1.介绍 比较对象是面向对象编程语言的一个基本特征。在本教程中，我们将介绍Java语言的一些特性，这些特性允许我们比较对象。此外，我们还将研究外部库中的这些特性。 2.==和!=操作符 让我们从==和！=开始可以分别判断两个Java对象是否相同的操作符。 2.1 原始类型（Primitives） 对于原始类型，相同意味着具有相等的值： assertThat(1 == 1).isTrue(); 感谢自动拆箱，在将原语值与其包装类型对应值进行比较时，也可以这样做： Integer a = new Intege
前端 - Map对象详解
kelly0721的博客
09-20 7318
Map对象属性、Map对象和普通对象的区别、Map对象和WeakMap对象的区别
asp.net运行提示未将对象引用设置到对象的实例错误解决方法
01-02
未将对象引用设置到对象的实例 一、网络上的一般说法 1、ViewState对象为Null。 2、DateSet空。 3、sql语句或Datebase的原因导致DataReader空。 4、声明字符串变量时未赋空值就应用变量。 5、未用new初始化对象。 6...
深度探索c++对象模型(2012版本)
02-07
《深度探索C++对象模型》是一本专注于C++底层机制的专著，主要针对2012年的标准进行深入解析。C++是一种多范式、静态类型、编译型、并发型、通用程序设计语言，它以其强大的功能和灵活性而闻名。这本书的目标是帮助...
未将对象引用设置到对象的实例 (System.NullReferenceException)
10-28
【未将对象引用设置到对象的实例 (System.NullReferenceException)】是.NET开发中常见的运行时错误，这个异常表示尝试访问或操作一个尚未初始化的对象，即该对象的引用是`null`。这个问题无论对于初学者还是有经验的...
面向对象软件工程
05-12
《面向对象软件工程》 作者：Stephen.R.Schach 学校：(美)范德比尔特大学 书名原名：Objected-Oriented Software Engineering 目录： 第一部分　面向对象软件工程简介 　第一章　面向对象软件工程的范畴 　第二章　...
Vue如何循环提取对象数组中的值
01-21
1.数据如下，提取name和callcount 2代码. getQueryCallStatistics(sesp1, this.provinceId).then((res) => { let arr = []; let arr1 = []; let arr2 = [];... this.xunshiMap = res.data.callstatistics;...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 103
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 176
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 607
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1101
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值