站在C/C++的肩膀速通Java面向对象

默认学过C或C++，对变量、表达式、选择、循环都会。

运行特征

  1. 解释型语言（JavaScript、Python等）
    源文件-(平台专属解释器)->解释器中执行
  2. 编译型语言（C++、Go等）
    源文件-(平台编译器)->平台可执行文件
  3. Java
    源文件-(通用编译器)->.class二进制文件-(平台JVM)->JVM中执行

Java名词解释

  1. JVM（Java Virtual Machine）虚拟机
  2. JRE（Java Runtime Environment）运行环境（包含JVM和解释器），有这个就能运行Java程序
  3. JDK（Java Development Kit）包含JRE和相关工具的Java开发环境

常用Dos命令

dir查目录，不是ls
cd进目录
d:进D盘
mkdir创建文件夹
rd删除文件夹
cls清屏
exit退出

Java的相关文件（Windows平台）

  1. .java文件：Java源代码文件，包含了程序员编写的Java代码。
  2. .class文件：Java字节码文件，是由Java编译器编译生成的中间代码文件，可以由Java虚拟机（JVM）执行。
  3. .jar文件：JavaArchive文件，是一种归档文件格式，用于将多个Java类文件、资源文件和元数据打包成一个文件。通常用于分发和部署Java应用程序、库或组件。
  4. java.exe：Java程序的执行器，用于执行已编译成的Java字节码文件（.class文件）。
  5. javac.exe：Java编译器，用于编译Java源代码文件（.java文件）成为Java字节码文件（.class文件）。
  6. jar.exe：Java归档工具，用于创建和管理Java归档文件（.jar文件），可以将多个.class文件打包成一个可执行的JAR文件。
  7. javadoc.exe：Java文档生成工具，用于根据源代码中的注释生成API文档，将Java代码注释转换为HTML格式的文档。
  8. jdb.exe：Java调试器，用于在调试Java程序时启动Java调试器，允许暂停程序、检查变量值、设置断点等操作。
  9. javap.exe：Java反汇编器，用于反编译Java字节码文件（.class文件）成为Java源代码的形式，可以查看.class文件的内容，了解其中包含的类、方法、字段等信息。

一个Java程序开发通常如下：编写.java源文件，使用javac.exe编译成.class文件，使用java.exe执行.class文件（不能带.class后缀，直接java 类名）。

基本数据类型

  1. 整型（Integer Types）：
    • byte：8位，有符号，范围为 -128 到 127。
    • short：16位，有符号，范围为 -32,768 到 32,767。
    • int：32位，有符号，范围为 -2^31 到 2^31 - 1。
    • long：64位，有符号，范围为 -2^63 到 2^63 - 1。123L
  2. 浮点型（Floating-Point Types）：
    • float：32位，单精度浮点数，范围为大约 1.4e-45 到 3.4e+38，精确度为约 7 位小数。12.2f
    • double：64位，双精度浮点数，范围为大约 4.9e-324 到 1.8e+308，精确度为约 15 位小数。
  3. 字符型（Character Type）：
    • char：16位，Unicode字符，范围为 ‘\u0000’（即 0）到 ‘\uffff’（即 65,535）。
  4. 布尔型（Boolean Type）：
    • boolean：表示 true 或 false 值。

易错：image.png
image.png

引用数据类型

  1. 类（Class）：类是用户定义的数据类型，用于创建对象。类包含属性（字段）和方法，可以通过实例化（创建对象）来访问它们。
  2. 接口（Interface）：接口是一种抽象数据类型，用于定义类应该实现的方法。类可以实现一个或多个接口，以达到实现多态性和代码复用的目的。
  3. 数组（Array）：数组是一组相同类型的数据元素的集合。数组在内存中是连续存储的，可以通过索引访问其中的元素。
  4. 枚举（Enum）：枚举是一种特殊的类，用于定义一组命名的常量。枚举常量通常用于表示有限的一组可能值，如星期几、月份等。
  5. 字符串（String）：字符串是Java中的特殊对象，用于表示文本数据。字符串是不可变的，可以进行各种操作，如连接、截取、替换等。
  6. 包装类（Wrapper Classes）：包装类是一种将基本数据类型封装为对象的类。Java提供了一组包装类，如Integer、Double、Boolean等，用于在需要对象的上下文中使用基本数据类型。
  7. 自定义引用数据类型：除了以上提到的内置引用数据类型外，开发人员还可以创建自定义的引用数据类型，通过定义类和接口来实现自己的数据结构和算法。

控制台输入

import java.util.Scanner;

class UseScanner {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Input your name: ");
        String name = input.next();	// 取字符串
        System.out.println("OK~ next... input your age: ");
        int age = input.nextInt();	// 取整数
        System.out.println("Hello " + name + ". And your age is " + age + ". Choose A or B please.");
        char a = input.next().charAt(0);	// 取字符串第0个字
        System.out.println("You choose " + a);
        input.close();
    }
}

Java特别注意

  1. switch语句中允许接受byte、short、int、char、String作为变量，但不支持long

数组

class UseArray {
    public static void main(String[] args) {
        int[] arr; // 声明数组
        arr = new int[5]; // 分配空间

        int[] arr2 = { 1, 2, 3, 4, 5 }; // 声明，并（包含分配空间）赋值

        printArray(arr);
        System.out.println();
        printArray(arr2);
    }

    static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

class UseArray {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };

        // 拷贝扩容
        arr = Arrays.copyOf(arr, 10);
        printArray(arr);

        // 也能截取
        arr = Arrays.copyOf(arr, 2);
        printArray(arr);
    }

    static void printArray(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

import java.util.Arrays;

class UseArray {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };
        printArray(arr);

        arr = extendArray(arr);
        printArray(arr);

        addArray(arr);
        printArray(arr);
    }

    static void printArray(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }

    // 传入的是arr所指的地址
    static void addArray(int[] arr) {
        arr[0] = 10086;
    }

    static void extendArray(int[] arr) {
        arr = Arrays.copyOf(arr, 10);
        return arr;
    }

}

可变长参数

只能放最后一个参数位置，作为数组形式使用。

class UseArray {
    public static void main(String[] args) {
        System.out.println(sumup("Hello", 1, 2, 3, 4, 5, 6, 7));
    }

    public static int sumup(String str, int... nums) {
        int sum = 0;
        System.out.println("Input String: " + str);
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }

}

二维数组

class UseArray {
    public static void main(String[] args) {
        int[][] arrs1 = new int[3][5];
        arrs1[0][0] = 0;
        printArrays(arrs1);

        int[][] arrs2 = new int[3][];
        arrs2[0] = new int[5];
        arrs2[1] = new int[3];
        arrs2[2] = new int[1];
        printArrays(arrs2);

        int[][] arrs3 = { { 1, 2, 3 }, { 2, 3 }, { 3 } };
        printArrays(arrs3);

        return;
    }

    public static void printArrays(int[][] arrs) {
        for (int i = 0; i < arrs.length; i++) {
            for (int j = 0; j < arrs[i].length; j++)
                System.out.print(arrs[i][j] + " ");
            System.out.println();
        }
        System.err.println("--------------");
        return;
    }

}

面向对象基础

public class Person {
    String name;
    int age;

    public void speak(String words) {
        System.out.println(name + "say: " + words);
    }

    public void jump() {
        System.out.println(name + "jumps to " + age);
    }
}


public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "小明";
        person.age = 18;
        person.speak("哈哈哈");
        person.jump();
    }
}
  1. 类由成员变量和方法组成
  2. 类中定义的变量是成员变量，实例化后存在堆空间中，创建后就有默认值，不会因为没有初始化成员变量而报错。
  3. 局部变量的优先级高于成员变量，在类方法中的同名局部变量会先于成员变量。如果在方法中需要使用成员变量，需要加上this.来访问。

方法重载

一个类中定义多个相同名称的方法，但是参数列表不同（类型、顺序、个数不同都算不同）。这与形参名、方法访问修饰符、返回值类型无关！
可以参考println()函数的实现，有很多方法重载的例子。、

 public void println(boolean x) {
    if (getClass() == PrintStream.class) {
        writeln(String.valueOf(x));
    } else {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
}
public void println(char x) {
    if (getClass() == PrintStream.class) {
        writeln(String.valueOf(x));
    } else {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
}

构造方法

类中的特殊方法，与类名同名。
没有返回值类型，只在创建对象时调用，无法通过方法调用。
没有在类中显式定义构造方法，由编译器提供无参构造方法。
构造方法也可以重载！在定义带参构造后需要补充无参构造！

public class Person {
    String name;
    int age;

    public Person() {
        System.out.println("Person created!");
    }

    public Person(String name) {
        this.name = name;
    }

    public void speak(String words) {
        System.out.println(name + "say: " + words);
    }

    public void jump() {
        System.out.println(name + "jumps to " + age);
    }
}

对象的创建步骤

image.png

this关键字

指向当前实例对象。实际是对象在虚拟机中的堆地址（在new的时候就已经确定）

  1. 在类方法中，可以避免与局部同名变量冲突。用于调用成员变量/方法。
  2. 构造方法内自调用this()
public class Person {
    String name;
    int age;

    public Person() {
        System.out.println("Person created!");
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this(name);
        this.age = age;
    }

    public void speak(String words) {
        System.out.println(name + "say: " + words);
    }

    public void jump() {
        System.out.println(name + "jumps to " + age);
    }
}

封装

隐藏必要的对象内部实现细节，控制对象属性、方法的使用与修改权限。
使用访问修饰符private（私有，仅本类可见）。
属性的访问与修改使用getter和setter。

public class Person {
    String name;
    int age;
    private int score;

    public void setScore(int score) {
        if (score >= 0 && score <= 100)
            this.score = score;
        else
            this.score = 0;
    }

    public int getScore() {
        return this.score;
    }
}

继承

使用extends关键字继承父类，实例化子类时，会先调用父类的构造方法，然后调用子类的构造方法。
默认会调用无参父类构造，如果需要调用带参构造，使用super(a,b,c...)调用。
子类创建对象时并没有创建父类对象，只是在子类空间中创建了super指向的父类空间，所以只有一个子类对象实例。

public class Animal {
    private String name;
    int age;
    private double price;

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

    public Animal(String name) {
        System.out.println("Animal with name Created!");
        setName(name);
    }

    public Animal(String name, int age, double price) {
        this.name = name;
        this.age = age;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

}


public class Dog extends Animal {

    int age;

    public Dog() {
        super("MAKA");
        System.out.println("Dog created!");
        this.age = 233;
        super.age = 666;
    }

    public void speak() {
        System.out.println(getName() + " wang wang!");
    }

}


public class Test {
    public static void main(String[] args) {
        Dog pt = new Dog();
        System.out.println(pt.age);
        pt.speak();
        return;
    }
}
// Animal with name Created!
// Dog created!
// 233
// MAKA wang wang!

属性的继承

父类的所有属性都可以被继承，但是私有属性不能被访问。
当子类和父类有同名属性时，通过super关键字区分，没标注this/super优先访问this的。
image.png

public class Sup {
    int a;
    int b;

}


public class Sub extends Sup {
    int b;

    public void speak() {
        System.out.println("a: " + a);
        System.out.println("this.b: " + this.b);
        System.out.println("super.b: " + super.b);
    }
}


public class Test {
    public static void main(String[] args) {
        Sub sub = new Sub();
        sub.a = 1;
        sub.b = 2;
        sub.speak();
        return;
    }
}

// a: 1
// this.b: 2
// super.b: 0

方法的覆盖（重写）

当父类提供的方法无法满足子类需求时，对父类相同的方法（包括方法名和参数列表结构完全一致）覆盖。
子类覆盖的方法不能比父类的方法可见性小。父类私有的方法不会被重写（相当于不可见）。
子类返回值类型只能与父类一样或者是父类的子类和null，如果是基本数据类型，需要完全一致。

public class Sup {
    int a;
    int b;

    Sup speak() {
        return new Sub();
    }

    Sub speak(String words) {
        System.out.println("233");
        return new Sub();
    }

}


public class Sub extends Sup {
    int b;

    Sub speak(String words) {
        super.speak(words);
        System.out.println("666");
        return new Sub();
    }
}


public class Test {
    public static void main(String[] args) {
        Sub sub = new Sub();
        sub.a = 1;
        sub.b = 2;
        sub.speak();
        sub.speak("");
        return;
    }
}
// 233
// 666

访问修饰符

image.png

多态

父类引用指向子类对象，产生了多态。（向上转型、里氏替换）
要求有继承关系，多态只能调用父类有的属性、方法，不能调用子类有的。
如果子类有父类方法的重写，则会调用子类的重写方法。
Pet pet = new Dog();
使用场景1：父类作为方法的形参实现多态，使得方法参数类型更宽泛（能用多个子类作为参数类型）

public class Animal {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println("Animal eat what?");
    }

    public void feed(Animal animal) {
        animal.eat();	// 实际上是调用子类的eat重写方法
    }

}


public class Dog extends Animal {
    public void eat() {
        System.out.println("Dog eat something!");
    }
}


public class Cat extends Animal {
    public void eat() {
        System.out.println("Cat eat fish!");
    }
}


public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
        Animal cat = new Cat();
        cat.eat();
    }
}
// Dog eat something!
// Cat eat fish!

使用场景2：父类作为方法的返回值实现多态，使得方法返回不同的子类对象（能用多个子类作为返回值）

public class Animal {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println("Animal eat what?");
    }

    public void feed(Animal animal) {
        animal.eat();
    }

    public Animal getAnimal(String type) {
        if (type.equals("Dog"))
            return new Dog();
        if (type.equals("Cat"))
            return new Cat();
        return null;
    }
}


public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal = animal.getAnimal("Cat");
        animal.eat();
    }
}
// Cat eat fish!

向下转型

父类无法调用子类的特有方法，需要强转（向下转型）后才能调用。要保证强转后的子类确实有这个方法。

public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.eatFish(); // Cat独有的方法
        }
    }
}

抽象类和抽象方法

https://www.bilibili.com/video/BV1994y1r7uV/?p=83&spm_id_from=pageDriver&vd_source=9cf1572a869a6a64c75ab4bdbe55f984

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

算法详解:滑动窗口-- 最大连续1的个数 III

算法详解:滑动窗口-- 最大连续1的个数 III

题目来源:力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 本期讲解滑动窗口经典例题,我会从三个点开始讲解题目1.题目解析2.算法原理 3.编写代码 1.题目解析 这道题目理解起来还是比较简单的,我们简单分析一下,也就是给定一个数组,数组是由1和0组成…
阅读更多...
AtCoder Beginner Contest 335 (Sponsored by Mynavi) --- F - Hop Sugoroku -- 题解

AtCoder Beginner Contest 335 (Sponsored by Mynavi) --- F - Hop Sugoroku -- 题解

目录 F - Hop Sugoroku 题目大意&#xff1a; 思路解析&#xff1a; 代码实现&#xff1a; F - Hop Sugoroku 题目大意&#xff1a; 思路解析&#xff1a; 容易想到这是一个dp题&#xff0c;然后初始转移方程为&#xff1a; 如果当a[i] 较大时&#xff0c;时间复杂度为 O(N…
阅读更多...
【AI视野·今日NLP 自然语言处理论文速览 第七十九期】Thu, 18 Jan 2024

【AI视野·今日NLP 自然语言处理论文速览 第七十九期】Thu, 18 Jan 2024

AI视野今日CS.NLP 自然语言处理论文速览 Thu, 18 Jan 2024 Totally 35 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computation and Language Papers Deciphering Textual Authenticity: A Generalized Strategy through the Lens of Large Language Semantics …
阅读更多...
MySQL数据库-MVCC多版本并发控制

MySQL数据库-MVCC多版本并发控制

mvcc,多版本并发控制&#xff08;Multi-Version Concurrency Control&#xff09;,是一种用于数据库管理系统中的并发控制方法. 在传统的并发控制方法中,如锁定机制,当一个事务修改数据时,会对相关的数据对象进行锁定,其他事务需要等待该锁释放才能进行操作。这种方法存在着事…
阅读更多...
操作系统-408

操作系统-408

一、操作系统概述 1、定义 负责协调软件和硬件的计算机资源的工作为上层应用提供简易的服务操作系统是系统软件 2、功能&#xff1a; 操作系统是系统资源的管理者 处理机管理存储器管理文件管理设备管理向上层提供方便易用的服务 命令接口程序接口对硬件机器的扩展 3、特征…
阅读更多...
详解tomcat中的jmx监控

详解tomcat中的jmx监控

目录 1.概述 2.如何开启tomcat的JMX 3.tomcat如何实现JMX的源码分析 1.概述 本文是博主JAVA监控技术系列文章的第二篇&#xff0c;前面一篇文章中我们介绍了JAVA监控技术的基石——jmx&#xff1a; 【JMX】JAVA监控的基石-CSDN博客 本文我们将从使用和源码实现两个方面聊…
阅读更多...
springboot743二手交易平台

springboot743二手交易平台

springboot743二手交易平台 获取源码——》公主号&#xff1a;计算机专业毕设大全
阅读更多...
Python面向对象学习小记——面向过程VS面向对象

Python面向对象学习小记——面向过程VS面向对象

【面向过程就好比你是一个工人&#xff0c;你得亲自去做一个个任务 面向对象就好比你一个包工头&#xff0c;你可以差遣你下面的工人去做】
阅读更多...
日期类运算符重载以及const成员详细解析

日期类运算符重载以及const成员详细解析

个人主页&#xff1a;点我进入主页 专栏分类&#xff1a;C语言初阶 C语言进阶 数据结构初阶 Linux C初阶 算法 欢迎大家点赞&#xff0c;评论&#xff0c;收藏。 一起努力&#xff0c;一起奔赴大厂 目录 一.前言 二.运算符重载 2.1概念 2.2比较的符号重载 2.2.1…
阅读更多...
linux 安装docker

linux 安装docker

目录 环境 操作步骤 1 下载脚本 2 执行脚本 3 检查docker版本&#xff0c;证明安装成功 环境 阿里云 ubuntu 22.04 64位 操作步骤 参考linux系统安装docker-腾讯云开发者社区-腾讯云 (tencent.com) 1 下载脚本 curl -fsSL https://get.docker.com -o get-docker.sh …
阅读更多...
JavaWeb学习|Filter与ThreadLocal

JavaWeb学习|Filter与ThreadLocal

学习材料声明 所有知识点都来自互联网&#xff0c;进行总结和梳理&#xff0c;侵权必删。 引用来源&#xff1a;尚硅谷最新版JavaWeb全套教程,java web零基础入门完整版 Filter 1、Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是&#xff1a;Servlet 程序、Liste…
阅读更多...
RH850从0搭建Autosar开发环境【2X】- Davinci Configurator之XCP模块配置详解(上)

RH850从0搭建Autosar开发环境【2X】- Davinci Configurator之XCP模块配置详解(上)

XCP模块配置详解 - 上 一、XCP模块配置项处理1.1 Tx Pdu配置项二、XCP模块其他配置项2.1 参数XcpMainFunctionPeriod2.2 参数XcpOnCanEnabled2.3 容器XcpOnCan总结从本节开始先专注与配置项错误处理以及构建Autosar Rh850的最小系统搭建。 XCP模块在汽车电子各控制器中处于十分…
阅读更多...
使用ShardingJDBC实现分库分表

使用ShardingJDBC实现分库分表

一、测试环境 JDK&#xff1a;1.8SpringBoot&#xff1a;2.7.17MySQL驱动&#xff1a;5.1.49MyBatis&#xff1a;2.3.1shardingJDBC&#xff1a;5.1.0 二、核心依赖 <!-- mysql 驱动 --> <dependency><groupId>mysql</groupId><artifactId>mysq…
阅读更多...
Django学习笔记教程全解析:初步学习Django模型，初识API,以及Django的后台管理系统（Django全解析，保姆级教程）

Django学习笔记教程全解析:初步学习Django模型，初识API,以及Django的后台管理系统（Django全解析，保姆级教程）

把时间用在思考上是最能节省时间的事情。——[美]卡曾斯 导言 写在前面 本文部分内容引用的是Django官方文档&#xff0c;对官方文档进行了解读和理解&#xff0c;对官方文档的部分注释内容进行了翻译&#xff0c;以方便大家的阅读和理解。 概述 在上一篇文章里&#xff0…
阅读更多...
【Python】高级数据类型

【Python】高级数据类型

&#x1f6a9; WRITE IN FRONT &#x1f6a9; &#x1f50e; 介绍&#xff1a;"謓泽"正在路上朝着"攻城狮"方向"前进四" &#x1f50e;&#x1f3c5; 荣誉&#xff1a;2021|2022年度博客之星物联网与嵌入式开发TOP5|TOP4、2021|2222年获评…
阅读更多...
8.JS中的== 操作符的强制类型转换规则

8.JS中的== 操作符的强制类型转换规则

对于 来说&#xff0c;如果对比双方的类型不一样&#xff0c;就会进行类型转换。假如对比 x 和 y 是否相同&#xff0c;就会进行如下判断流程&#xff1a; 首先会判断两者类型是否相同&#xff0c;类型相同的话就比较两者的大小&#xff1b;类型不相同的话&#xff0c;就会进…
阅读更多...
Compose低级别API动画指南

Compose低级别API动画指南

Google官方为Compose提供的动画API与原生View体系的动画API相差甚远&#xff0c;目前总共分为四类&#xff1a;高级别动画API、低级别动画API、自定义动画、手势和动画&#xff08;其他&#xff09;&#xff0c;下图是官方提供的流程指示图&#xff0c;以供根据不同使用场景来选…
阅读更多...
PMDG 737

PMDG 737

在Simbrief中生成计划后下载两个文件 放到A:\Xbox\Community\pmdg-aircraft-738\Config\Flightplans中
阅读更多...
深度学习疆界：探索基本原理与算法，揭秘应用力量，展望未来发展与智能交互的新纪元

深度学习疆界：探索基本原理与算法，揭秘应用力量，展望未来发展与智能交互的新纪元

目录 什么是深度学习 深度学习的基本原理和算法 深度学习的应用实例 深度学习的挑战和未来发展方向 挑战 未来发展方向 深度学习与机器学习的关系 深度学习与人类的智能交互 什么是深度学习 深度学习是一种基于神经网络的机器学习方法&#xff0c;旨在模仿人类大脑分析…
阅读更多...
LabVIEW虚拟测试与分析仪

LabVIEW虚拟测试与分析仪

LabVIEW虚拟测试与分析仪 在现代工程技术领域&#xff0c;虚拟仪器的开发和应用已成为一种趋势。利用LabVIEW软件平台开发的虚拟测试与分析仪器进行展开&#xff0c;实现工程测试和分析中的实际需求。通过结合LabVIEW的强大功能和灵活性&#xff0c;成功实现了一套高效、精确的…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站