java语法：继承与多态

news2024/11/25 19:21:09

导言:

在Java中，继承和多态是面向对象编程的两个重要概念，它们允许我们创建更加灵活和可扩展的代码。本文主要对继承和多态的语法和一些细节做一个介绍和解释。

目录

导言:

正文：

一.继承

1. 基本语法

2. 继承的特点

3.子类中访问父类的成员变量

4. 子类中访问父类的成员方法 

5.super关键字

6.代码的执行顺序

二.多态

1.基本概念：

2.重写

 3.向上转型

4.向下转型 

5.多态的优缺点

总结：

正文：

一.继承

继承是面向对象编程中的一种机制，允许一个类（称为子类）继承另一个类（称为父类）的属性和方法。通过继承，子类可以获得父类的所有属性和方法，同时可以在其基础上添加新的属性和方法，或者修改已有的属性和方法。通俗来讲，继承主要就是用来对类和类之间进行共性抽取，从而实现代码复用。

1. 基本语法

在Java中，继承通过使用关键字extends来实现。子类可以继承父类的非私有属性和方法。基本的继承语法如下：

class ParentClass {
        // 父类的属性和方法
    
    }

    class ChildClass extends ParentClass {
        // 子类的属性和方法
     
    }

 需要 注意的是：子类会将父类中的成员变量或者成员方法继承到子类中。 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了 

2. 继承的特点

要知道子类并不能将父类的所有东西都继承下来，需要遵循一定的规则。

对于构造方法而言：

子类无法继承父类的构造方法，但是子类可以可以调用父类的构造方法来帮助父类进行初始化。

对于成员变量而言：

子类可以继承父类的所有成员变量。

对于成员方法而言：

子类可以继承非私有的成员方法，但不能继承私有的成员方法。

下面是一些关于Java中继承的重要特点：

  • 子类可以继承父类的非私有属性和方法，这意味着子类可以直接访问父类的属性和方法。
  • 子类可以重写父类的方法，从而实现对父类方法的覆盖。
  • Java中不支持多继承，一个类只能有一个直接父类。
  • 子类可以调用父类的构造方法来初始化父类的属性。
  • 子类可以在继承父类的基础上添加新的属性和方法，从而实现代码的扩展。
3.子类中访问父类的成员变量
  • 当子类和父类不存在同名变量时：
class ParentClass {
        // 父类的属性和方法
        int a;
        int b;
    }

    class ChildClass extends ParentClass {
        // 子类的属性和方法
        int c;

        public void method() {
            a = 10; // 访问从父类中继承下来的a
            b = 20; // 访问从父类中继承下来的b
            c = 30; // 访问子类自己的c
        }
    }

在Java中，如果子类和父类不存在同名变量，子类可以直接使用父类的成员变量。这是因为子类会继承父类的变量，即使没有同名的变量也可以直接使用父类的变量。

  •  当子类和父类存在成员变量同名时：
public class Base {
        int a;
        int b;
        int c;
    }
    //----------------------------------------------------------------

    public class Derived extends Base{
        int a; // 与父类中成员a同名，且类型相同
        char b; // 与父类中成员b同名，但类型不同
        public void method(){
            a = 100; // 访问的成员变量与父类中成员变量同名，优先访问自己的。
            b = 101; // 访问的成员变量子类中没有，则访问父类继承下来的
            c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
            // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b
        }
    }

通过子类对象访问成员时遵循以下几点：

  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
  • 成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。 
4. 子类中访问父类的成员方法 
  • 当子类和父类成员方法名字不同时：
class Parent {
    public void display() {
        System.out.println("This is the display method in the Parent class");
    }
}

class Child extends Parent {
    public void callParentMethod() {
        display(); // 子类直接调用父类的成员方法
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.callParentMethod(); // 输出：This is the display method in the Parent class
    }
}

和成员变量一样，如果子类和父类不存在同名方法，子类可以直接使用父类的成员方法。在子类方法中或者通过子类对象访问方法时，优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

  • 当子类和父类成员方法名字相同时：
  public class Base {
        public void methodA(){
            System.out.println("Base中的methodA()");
        }
        public void methodB(){
            System.out.println("Base中的methodB()");
        }
    }
    public class Derived extends Base{
        public void methodA(int a) {
            System.out.println("Derived中的method(int)方法");
        }
        public void methodB(){
            System.out.println("Derived中的methodB()方法");
        }
        public void methodC(){
            methodA(); // 没有传参，访问父类中的methodA()
            methodA(20); // 传递int参数，访问子类中的methodA(int)
            methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
        }
    }

 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

可见成员方法和变量一致，优先访问子类的，但是我们可以指定其优先访问父类，我们可以通过super关键字来实现。

5.super关键字

super关键字在Java中用于引用对象的直接父类，可以用于调用父类的构造方法，访问父类的成员变量和成员方法，以及在子类中调用父类的构造方法和成员方法。我们可以通过super.的形式访问到父类的成员方法和变量。

 public class Base {
        int a;
      
        public void methodA(){
            System.out.println("Base中的methodA()");
        }
        public void methodB(){
            System.out.println("Base中的methodB()");
        }
    }
    public class Derived extends Base{
        int a;
        
        public void methodB(){
            System.out.println("Derived中的methodB()方法");
        }
        public void methodC(){
            a=10;//直接访问，访问到的都是子类中的变量
            super.a=10;//super调用，访问到了父类的成员变量
            
            methodA(); // 子类没有，访问父类的方法
            methodB(); // 直接访问，访问到的都是子类中的methodB()，基类的无法访问到
            super.methodB();//super调用，访问到了父类的成员方法

        }
    }

在子类中，如果想要明确访问父类中成员时，借助super关键字即可。 

同时我们还可以利用super来调用父类的构造方法：

调用父类的构造方法：在子类的构造方法中使用super()来调用父类的构造方法。可以使用super()来调用父类的无参构造方法，也可以使用super(参数列表)来调用父类的有参构造方法。

public class Child extends Parent {
    public Child() {
        super(); // 调用父类的无参构造方法
    }
}

在构造方法中也存在着一些细节： 

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

 需要注意的是，super与this一样， 只能在非静态方法中使用。

6.代码的执行顺序

在Java中，当涉及到继承体系时，代码的执行顺序遵循以下规则：

  1. 静态代码块和静态变量初始化：首先，会按照继承层次从上到下的顺序依次执行每个类中的静态代码块和静态变量初始化。这意味着父类的静态代码块和静态变量会先被初始化，然后是子类的静态代码块和静态变量。
  2. 父类构造方法：父子父子，先有父再有子，接着，会调用父类的构造方法。如果父类还有父类，那么会依次调用父类的构造方法，直到最顶层的父类。
  3. 父类的实例代码块
  4. 子类成员变量和实例代码块初始化：接下来，会初始化子类的成员变量和实例代码块，按照声明的顺序执行。
  5. 子类构造方法：最后，会调用子类的构造方法。

代码验证：

class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person：构造方法执行");
    }

    {
        System.out.println("Person：实例代码块执行");
    }

    static {
        System.out.println("Person：静态代码块执行");
    }
}

class Student extends Person {
    public Student(String name, int age) {
        super(name, age);
        System.out.println("Student：构造方法执行");
    }

    {
        System.out.println("Student：实例代码块执行");
    }

    static {
        System.out.println("Student：静态代码块执行");
    }
}

public class test {
    public static void main(String[] args) {
        Student student1 = new Student("张三", 19);
        System.out.println("===========================");
        Student student2 = new Student("gaobo", 20);
    }


}

 结果如下：

通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

二.多态

1.基本概念：

多态，是指一个引用通过不同的对象的调用，呈现出不同的状态。通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。多态的一种体现，就是在代码运行时，当传递不同类对象时，会调用对应类中的方法。

多态的一种表现形式是：

父类类型 对象名称 = 子类对象;

例如：

class Person {
    
}

class Student extends Person {
   
}

public class test {
    public static void main(String[] args) {
      Person p = new Student();
    }


}

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

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

下面是一个多态的实例：

// 定义一个动物类
class Animal {
    public void makeSound() {
        System.out.println("动物发出叫声");
    }
}

// 定义一个狗类，继承自动物类
class Dog extends Animal {
    public void makeSound() {
        System.out.println("狗发出汪汪的叫声");
    }
}

// 定义一个猫类，继承自动物类
class Cat extends Animal {
    public void makeSound() {
        System.out.println("猫发出喵喵的叫声");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 使用父类引用指向子类对象
        Animal animal2 = new Cat(); // 同样使用父类引用指向另一个子类对象

        animal1.makeSound(); // 输出：狗发出汪汪的叫声
        animal2.makeSound(); // 输出：猫发出喵喵的叫声
    }
}

当类的调用者在编写 makeSound 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的引用指向的是哪个类型(哪个子类)的实例. 此时 这个引用调用 makeSound方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态. 

2.重写

Java中，方法重写（Override）是指子类重新定义父类中已有的方法，以实现特定的功能。方法重写是实现多态性的一种方式，它允许子类提供对继承的方法的自定义实现。当子类重写父类的方法时，子类对象调用该方法时将执行子类中的实现，而不是父类中的实现。

以下是方法重写的一些重要规则和注意事项：

  • 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
  • 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
  • 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
  • 父类被static、private修饰的方法、构造方法都不能被重写。
  • 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

下面是一个重写的案例：

// 父类
class Animal {
    public void makeSound() {
        System.out.println("动物发出叫声");
    }

}

// 子类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗发出汪汪的叫声");
    }
}

public class OverrideExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 使用父类引用指向子类对象
        animal.makeSound(); // 输出：狗发出汪汪的叫声
    }
}

重写和重载有很多类似的地方，为了防止混淆，这里做一个总结。 

重写和重载的区别：

  1. 重载方法是在同一个类中定义多个方法，而重写方法是子类重新定义父类中已有的方法。
  2. 重载方法的方法名相同，但参数列表不同，而重写方法的方法名、参数列表和必须与父类中被重写的方法完全一致。
  3. 重载方法的调用是根据参数列表的类型和数量来确定的，而重写方法的调用是根据对象的实际类型来确定的。
  4. 重载可以修改访问限定符，但重写的访问限定符子类必须大于父类。
 3.向上转型

向上转型是指将子类的实例赋给父类引用的过程。在向上转型中，子类的实例可以赋给父类的引用变量，这样就可以通过父类的引用变量来访问子类对象的方法和属性。向上转型是安全的，因为子类对象具有父类对象的所有属性和方法，但不能访问子类特有的方法和属性。

实例代码：

class Animal {
    public void makeSound() {
        System.out.println("动物发出叫声");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("狗发出汪汪的叫声");
    }

    public void wagTail() {
        System.out.println("狗摇尾巴");
    }
}

public class UpcastingExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        animal.makeSound(); // 输出：狗发出汪汪的叫声
        // animal.wagTail(); // 编译错误，无法访问子类特有的方法
    }
}

在这个例子中，子类Dog的实例被赋给了父类Animal的引用变量，这就是向上转型。通过父类引用变量animal可以调用子类重写的方法makeSound，但无法访问子类特有的方法wagTail。

4.向下转型 

向下转型是指将父类引用转换为子类引用的过程。在向下转型中，需要使用强制类型转换将父类引用转换为子类引用，以便访问子类特有的属性和方法。向下转型是不安全的，因为父类引用指向的对象可能不是子类的实例，如果强制类型转换失败会抛出ClassCastException异常。

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了instanceof ，instanceof 的作用是判断 object 是否是 class 的实例或者子类的实例，如果是则返回 true，否则返回 false。如果 object 为 null，则返回 false。的作用是判断 object 是否是 class 的实例或者子类的实例，如果是则返回 true，否则返回 false。如果 object 为 null，则返回 false。如果该表达式为true，则可以安全转换。

实例代码：

public class DowncastingExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // 向下转型
            dog.makeSound(); // 输出：狗发出汪汪的叫声
            dog.wagTail(); // 输出：狗摇尾巴
        }
    }
}

在这个例子中，animal instanceof Animal 返回 true，因为 animal 是 Animal 类的实例；animal instanceof Dog 也返回 true，因为 animal 是 Dog 类的实例。 

5.多态的优缺点

优点：

  1. 灵活性：多态使得代码更加灵活，能够适应不同的对象和场景。通过多态，可以使用父类类型的引用变量来引用子类对象，从而实现统一的接口访问不同的子类对象，简化了代码的设计和实现。

  2. 可扩展性：多态使得代码更易于扩展。当需要添加新的子类时，无需修改现有的代码，只需要创建新的子类并实现父类的抽象方法，就可以直接在现有代码中使用新的子类对象。

  3. 维护性：多态提高了代码的可维护性。通过多态，可以将代码模块化，降低了代码之间的耦合度，便于单独修改和维护各个模块。

  4. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else
     

缺点：

  1. 性能损失：多态会带来一定的性能损失。由于多态需要在运行时动态确定对象的类型，因此需要额外的运行时开销，可能会导致一定的性能损失。

  2. 可读性降低：过度使用多态可能会降低代码的可读性。如果在代码中过度使用多态，可能会导致代码难以理解和维护，降低代码的可读性。

  3. 不适合所有场景：多态并不适合所有的场景。有些情况下，需要明确地知道对象的具体类型，而不是使用多态。过度使用多态可能会导致代码的复杂性增加，不利于理解和维护。

总结：

继承：一个类可以继承另一个类的属性和方法，这样可以避免重复编写相似的代码，并且可以实现多层次的类组织管理。

多态：允许不同的对象对同一消息作出不同的响应，通过动态绑定的方式，可以根据对象的实际类型来确定调用的方法，从而实现代码的灵活性和可扩展性。

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

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

相关文章

新品上市|米尔RZ/G2UL核心板上市，助力工业4.0发展！

新品上市|米尔RZ/G2UL核心板上市，助力工业4.0发展！

浩瀚的芯片海洋中能被人记住的寥寥无几，那些在人们脑海中留下印记的往往是踩中了时代的脉搏。32位ARMv7架构的A7/A8系列处理器自发布以来，以ARM9处理器的价格，升级了工业领域绝大部分应用需求，成为最近十年最受欢迎的通用工业级AR…
阅读更多...
怎么写日语开发信？写外贸日语开发信技巧？

怎么写日语开发信？写外贸日语开发信技巧？

如何写好日语开发信？日语开发信格式是怎么样的？ 无论您是初学者还是有经验的营销专家，都需要掌握一些关键技巧，以确保您的邮件在日本市场取得成功。蜂邮将向您介绍怎样写一封令人印象深刻的日语开发信，以吸引潜在客户…
阅读更多...
2022年09月 Python（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

2022年09月 Python（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

Python等级考试（1~6级）全部真题・点这里 一、单选题（共25题，每题2分，共50分） 第1题 下列不是评判一个算法优劣的标准是？（ ） A: 时间复杂度 B: 空间复杂度 C: 难易度 D: 健壮性 答案：C 评价算法的优劣是：时间复杂度，空间复杂度，健壮性，正确性，可读性。因此选…
阅读更多...
Laplacian Redecomposition for Multimodal Medical Image Fusion

Laplacian Redecomposition for Multimodal Medical Image Fusion

LRD方法 GDIE means ‘gradient-domain image enhancement’，DGR means ‘decision graph redecomposition’ MLD means ‘maximum local difference’ LEM means ‘local energy maximum’，OD means ‘overlapping domain’，LP means ‘L…
阅读更多...
2023.11.8 hadoop学习-概述,hdfs dfs的shell命令

2023.11.8 hadoop学习-概述,hdfs dfs的shell命令

目录 1.分布式和集群 2.Hadoop框架 3.版本更新 4.hadoop架构详解 5.页面访问端口 6.Hadoop-HDFS HDFS架构 HDFS副本 7.SHELL命令 8.启动hive服务 1.分布式和集群 分布式: 多台服务器协同配合完成同一个大任务(每个服务器都只完成大任务拆分出来的单独1个子任务)集 群:…
阅读更多...
Java jdbc连接Oracle时出现ORA-28040: No matching authentication protocol报错

Java jdbc连接Oracle时出现ORA-28040: No matching authentication protocol报错

一、问题描述 升级了oracle数据库版本后，同时也更新了oracle的驱动为ojdbc8.jar，Java重新通过jdbc连接Oracle时出现ORA-28040: No matching authentication protocol报错。 完整报错信息 java.sql.SQLException: ORA-28040: No matching authenticati…
阅读更多...
重庆市5米数字高程(DEM)数据

重庆市5米数字高程(DEM)数据

重庆位于中国西南部、长江上游地区，地跨东经10511~11011、北纬2810~3213之间的青藏高原与长江中下游平原的过渡地带。东邻湖北、湖南，南靠贵州，西接四川，北连陕西；辖区东西长470千米，南北宽450千米&#xf…
阅读更多...
uni-app——項目day01

uni-app——項目day01

配置uni-app開發環境 uni-app快速上手 | uni-app官网 创建项目 图中四个划线就是要配置的地方. 选择vue2还是vue3看个人选择。 目录结构 但是现在新版本创建的项目已经没有components目录了，需要自己创建。 项目运行到微信开发者工具 使用git管理项目 node-mod…
阅读更多...
C++初阶（十）模板初阶

C++初阶（十）模板初阶

📘北尘_：个人主页 🌎个人专栏:《Linux操作系统》《经典算法试题 》《C》 《数据结构与算法》 ☀️走在路上，不忘来时的初心 文章目录 一、泛型编程1、如何实现一个通用的交换函数呢？2、引出模板 二、函数模板1、函数模…
阅读更多...
蓝桥杯之模拟与枚举day1

蓝桥杯之模拟与枚举day1

Question1卡片(C/CA组第一题) 这个是一道简单的模拟枚举题目&#xff0c;只要把对应每次的i的各个位都提取出来&#xff0c;然后对应的卡片数目减去1即可。属于打卡题目。注意for循环的特殊使用即可 #include <iostream> using namespace std; bool solve(int a[],int n…
阅读更多...
Android逆向fiddler抓包工具——理解HTTP协议

Android逆向fiddler抓包工具——理解HTTP协议

HTTP协议格式 HTTP协议是一种应用非常广泛的应用层协议&#xff0c;当我们在浏览器中输入一个URL(“网址”)时&#xff0c;浏览器就会给客户端发送一个HTTP请求&#xff0c;服务器收到请求之后&#xff0c;就会返回一个HTTP响应。 为了能够看到HTTP请求和响应的详细内容&…
阅读更多...
SQL触发器

SQL触发器

触发器是与表有关的数据库对象。 在insert/update/delete之前(BEFORE)或之后(AFTER)&#xff0c;触发并执行触发 器中定义的SQL语句集合。 触发器的这种特性可以协助应用在数据库端确保数据的完整性, 日志记录 , 数据校验等操作 。 使用别名OLD和NEW来引用触发器中发生变化的…
阅读更多...
linux系统中查看防火墙开放的端口状态 开放端口和禁用端口号操作命令

linux系统中查看防火墙开放的端口状态 开放端口和禁用端口号操作命令

一、查看防火墙状态 查看防火墙状态&#xff1a;systemctl status firewalld 开启防火墙&#xff1a;systemctl start firewalld 关闭防火墙&#xff1a;systemctl stop firewalld 若遇到无法开启 先用&#xff1a;systemctl unmask firewalld.service 然后&#xff1a;s…
阅读更多...
1.3数据结构之复杂度 力扣题目移除元素

1.3数据结构之复杂度 力扣题目移除元素

移除元素首先我们可能会想到内存的释放&#xff0c;但是内存的释放是一次性的&#xff0c;不能断断续续&#xff0c;所以不能直接free掉。 思路1&#xff1a;时间复杂度是&#xff1a;O(n) 空间复杂度是&#xff1a;O(n) 思路2&#xff1a;时间复杂度&#xff1a;O(n) 空间复…
阅读更多...
TortoiseSVN 状态图标不显示的两种解决办法

TortoiseSVN 状态图标不显示的两种解决办法

文章目录 TortoiseSVN 方式解决注册表方式解决 TortoiseSVN 方式解决 在桌面或者资源管理器中鼠标右键打开 TortoiseSVN 设置选择 Icon Overlays (图标覆盖)Status cache&#xff08;状态缓存&#xff09; 选择 ‘Shell’ 选择 Icon Overlays&#xff08;图标覆盖&#xff09;…
阅读更多...
在软件测试过程中如何有效的开展接口自动化测试！

在软件测试过程中如何有效的开展接口自动化测试！

一.简介 接口自动化测试是指使用自动化测试工具和脚本对软件系统中的接口进行测试的过程。其目的是在软件开发过程中&#xff0c;通过对接口的自动化测试来提高测试效率和测试质量&#xff0c;减少人工测试的工作量和测试成本&#xff0c;并且能够快速发现和修复接口错误&…
阅读更多...
ARMday04（开发版简介、LED点灯）

ARMday04（开发版简介、LED点灯）

开发版简介 开发板为stm32MP157AAA,附加一个拓展版 硬件相关基础知识 PCB PCB&#xff08; Printed Circuit Board&#xff09;&#xff0c;中文名称为印制电路板&#xff0c;又称印刷线路板&#xff0c;是重要的电子部件&#xff0c;是电子元器件的支撑体&#xff0c;是电子…
阅读更多...
JVM虚拟机-虚拟机性能监控、故障处理工具

JVM虚拟机-虚拟机性能监控、故障处理工具

1基础故障处理工具 jps&#xff08;JVM Process Status Tool&#xff09;是&#xff1a;虚拟机进程状况工具 作用&#xff1a;可以列出正在运行的虚拟机进程&#xff0c;并显示虚拟机执行主类&#xff08;Main Class&#xff0c;main()函数所在的类&#xff09;名称以及这些进…
阅读更多...
人工智能数学基础3：用Python 编程求极限

人工智能数学基础3：用Python 编程求极限

求极限&#xff0c;并用Python 编程求极限 使用洛必达法则来求解 利用泰勒展开的方法来求解这个极限 import sympyx sympy.Symbol(x) f (sympy.sin(x) - x * sympy.cos(x)) / (sympy.sin(x) ** 3)limit_value sympy.limit(f, x, 0) print(limit_value)
阅读更多...
【QT】qt打包程序后无法正常启动

【QT】qt打包程序后无法正常启动

本人在自己电脑上打包Qt程序后可以正常运行&#xff0c;但换了个电脑就无法运行了&#xff0c;显示应用程序无法正常启动&#xff08;0xc000007b&#xff09;。 造成这种情况的原因是因为系统变量的原因&#xff0c;我用的win10自带的cmd。 应该采用Qt自带的cmd&#xff0c;打开…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023