Java面向对象（进阶）-- 四种权限测试与方法的重写（override_overwrite）

news2024/11/26 18:40:05

文章目录

  • 一、四种权限修饰
  • 二、测试四种权限修饰
    • （1）准备
    • （2）同一个类
    • （3）同一个包
    • （4）同一个包子类
    • （5）不同包子类
    • （6）跨包不是子类
    • （7）总结
  • 三、方法的重写(overwrite / override)
    • （1）引入
    • （2）举例
      • 举例1
      • 举例2
      • 举例3
    • （3）方法重写应遵循的规则
    • （4）面试题
  • 四、方法的重写--练习题
    • （1）练习1
    • （2）练习2

一、四种权限修饰

前面说了四种权限修饰，其中protected（受保护的）没有细说，因为它权限调用的过程中涉及到它不同包子类的问题。现在说过了继承性，就可以说一说它的使用了。

  • 封装性的权限修饰：https://blog.csdn.net/m0_55746113/article/details/133980641?spm=1001.2014.3001.5502
  • 继承性：https://blog.csdn.net/m0_55746113/article/details/134135984?spm=1001.2014.3001.5502

下面这个表格要会，不会的去看封装性那一篇的博客：
image.png

注意：

  • 实际开发中，各权限修饰的使用频率是怎样的？ public、private是使用频率最高的！
  • 若不设置，其实也是一种权限–缺省。
  • 属性方面，通常是private，基本是通过方法（get/set）来调用属性。
  • 方法方面，通常是public。

有一类属性会声明为public，就是常量，后边讲final关键字的时候再说。

二、测试四种权限修饰

（1）准备

在yuyi08包下创建两个package：test1和test2，测试Java中提供的4种权限修饰。

image.png

（2）同一个类

在test1包下创建Order类。

image.png

【Order.java】

package yuyi08.test1;

/**
 * ClassName: Order
 * Package: yuyi08.test1
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/1 0001 15:21
 */
public class Order {    //类的权限是public，可以跨包访问
    //声明四种不同属性的权限和方法
    //属性
    private int orderPrivate;
    int orderDefault;
    protected int orderProtected;
    public int orderPublic;

    //方法
    private void methodPrivate(){

    }

    void methodDefault(){

    }

    protected void methodProtected(){

    }

    public void methodPublic(){

    }

    //类内部都可以访问
    public void show(){
        orderPrivate=1;
        orderDefault=2;
        orderProtected=3;
        orderPublic=4;

        methodPrivate();
        methodDefault();
        methodProtected();
        methodPublic();

    }
}

（3）同一个包

image.png

在test1包下再建立OrderTest类（与Order类同包)。

【OrderTest.java】

package yuyi08.test1;

/**
 * ClassName: OrderTest
 * Package: yuyi08.test1
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/1 0001 15:37
 */
public class OrderTest {
    public void method1(){
        //在OrderTest类里面想要调用Order类里面的属性和方法，没有继承性关系，想要使用只能通过对象
        Order order=new Order();

        //通过对象来调用Order类中声明的属性、方法

        //不能调用OrderTest类中的私有属性、方法
        order.orderPublic=1;
        order.orderProtected=2;
        order.orderProtected=3;
        //order.orderPrivate=4;    //受封装性的影响，不能够调用

        order.methodPublic();
        order.methodProtected();
        order.methodProtected();
        //order.methodPrivate();   //受封装性的影响，不能够调用

    }
}

正常调用的时候，私有属性也不会显示，如下：

image.png

出了类本身，在同一个包下，私有的属性、方法是不能互相调用的。

（4）同一个包子类

比如在test1包下造一个Order子类，本来private（私有）的属性出了类就用不了，别提子类了；default在同一个包下都能看到（不论是不是子类）；public更不用说了，项目内都能看见。

所以这里就不用测试了。

（5）不同包子类

在test2包下创建SubOrder类，继承于Order类：

image.png

由于在不同的包下，所以在SubOrder类中使用别的包下的Order类时需要调包。

image.png

Order类本身也有权限，一种是public，一种是默认的。

若此时将Order类的public去掉，就会出问题。（跨包的话，默认权限的Order类就看不见了）

如下：

image.png

在另一个包（test2）下创建当前类（Order）的子类（SubOrder），当前类（Order）的权限修饰只能是public。

若当前类的权限修饰是默认（就是不写），当前类的public属性和方法都不能被调用。

【SubOrder.java】

package yuyi08.test2;

import yuyi08.test1.Order;

/**
 * ClassName: SubOrder
 * Package: yuyi08.test2
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/1 0001 15:57
 */
public class SubOrder extends Order {
    //子类中调用父类的属性和方法时不用创建对象
    public void method(){

        orderProtected=1;   //不同包下的子类受保护的属性可以使用
        orderPublic=2;
        //orderPrivate=3;  //私有属性不能使用
        //orderDefault=4; //出了包，默认权限不能用了

        methodProtected();
        methodPublic();
        //methodPrivate();  //权限问题
        //methodDefault();  //权限问题
    }
}

（6）跨包不是子类

在test2包下创建OrderTest2类。

image.png

此类与Order类没有什么关系，所以想要测试属性和方法得造对象，同时也需要导包，如下：

image.png

可以发现，此时只能调用公共的属性、方法了：

image.png

【OrderTest2.java】

package yuyi08.test2;

import yuyi08.test1.Order;

/**
 * ClassName: OrderTest2
 * Package: yuyi08.test2
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/1 0001 16:13
 */
public class OrderTest2 {
    public void method(){
        //此类与Order类没有什么关系，所以想要测试属性和方法得造对象
        Order order=new Order();
        order.orderPublic=1;
        order.methodPublic();

        //不能访问
        /*order.orderPrivate=2;
        order.orderDefault=3;
        order.orderProtected=4;
        
        order.methodPrivate();
        order.methodDefault();
        order.methodProtected();*/

    }
}

（7）总结

权限修饰符：public,protected,缺省,private

修饰符本类本包其他包子类其他包非子类
private√×××
缺省√√（本包子类非子类都可见）××
protected√√（本包子类非子类都可见）√（其他包仅限于子类中可见）×
public√√√√

外部类：public和缺省

成员变量、成员方法等：public,protected,缺省,private

1、外部类要跨包使用必须是public，否则仅限于本包使用

（1）外部类的权限修饰符如果缺省，本包使用没问题

在这里插入图片描述

（2）外部类的权限修饰符如果缺省，跨包使用有问题

在这里插入图片描述

2、成员的权限修饰符问题

（1）本包下使用：成员的权限修饰符可以是public、protected、缺省

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

（2）跨包下使用：要求严格

在这里插入图片描述

（3）跨包使用时，如果类的权限修饰符缺省，成员权限修饰符>类的权限修饰符也没有意义

image.png

三、方法的重写(overwrite / override)

之前说过重载，不要混淆了，博客链接：https://blog.csdn.net/m0_55746113/article/details/133964522?spm=1001.2014.3001.5502

（1）引入

父类的所有方法子类都会继承，但是当某个方法被继承到子类之后，子类觉得父类原来的实现不适合于自己当前的类，该怎么办呢？

子类可以对从父类中继承来的方法进行改造，我们称为方法的重写 (override、overwrite)。也称为方法的重置、覆盖。

在程序执行时，子类的方法将覆盖父类的方法。

①问：为什么需要方法的重写？

子类在继承父类以后，就获取了父类中声明的所有的方法。但是，父类中的方法可能不太适用于子类，换句话说，子类需要对父类中继承过来的方法进行覆盖、覆写的操作。

②问：何为方法的重写？

子类对父类继承过来的方法进行的覆盖、覆写的操作，就称为方法的重写。

（2）举例

举例1

比如新的手机增加来电显示头像的功能，代码如下：

package com.atguigu.inherited.method;

public class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");
    }
}


package com.atguigu.inherited.method;

//SmartPhone：智能手机
public class SmartPhone extends Phone{
    //重写父类的来电显示功能的方法
	@Override
    public void showNum(){
        //来电显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
    //重写父类的通话功能的方法
    @Override
    public void call() {
        System.out.println("语音通话 或 视频通话");
    }
}

package com.atguigu.inherited.method;

public class TestOverride {
    public static void main(String[] args) {
        // 创建子类对象
        SmartPhone sp = new SmartPhone();

        // 调用父类继承而来的方法
        sp.call();

        // 调用子类重写的方法
        sp.showNum();
    }
}

@Override使用说明：

写在方法上面，用来检测是不是满足重写方法的要求。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

举例2

【银行账户】

class Account{//账户
    double balance;//余额

    //取钱
    public void withdraw(double amt){
        //判断balance余额是否够amt取钱的额度
    }
}

class CheckAccount extends Account{ //信用卡
    double protectedBy;//透支额度


    public void withdraw(double amt){
        //判断balance余额是否够amt取钱的额度
        //如果不够，还可以考虑从protectedBy额度里取
    }
}

class AccountTest{
    public static void main(String[] args){
        CheckAccount acct = new CheckAccount();
        acct.withdraw(); //执行的是子类重写父类的方法
    }
}

举例3

【Person.java】

package yuyi09;

/**
 * ClassName: Person
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/29 0029 16:39
 */
public class Person {
    //属性
    String name;
    private int age;

    //方法
    public void eat(){
        System.out.println("人吃饭");
    }

    public void sleep(){
        System.out.println("人睡觉");
    }

    public void show(){
        System.out.println("age: "+age);
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

【Student.java】

package yuyi09;

/**
 * ClassName: Student
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/29 0029 16:40
 */
public class Student extends Person {
    //属性
    //String name;
    //int age;

    String school;

    //方法
    /*public void eat(){
        System.out.println("人吃饭");
    }

    public void sleep(){
        System.out.println("人睡觉");
    }*/

    public void study(){
        System.out.println("学生学习");
    }

    public void show1(){
        //System.out.println("age: "+age);

        //无法直接访问私有属性age，可以通过getAge方法获取
        System.out.println("age: "+ getAge());
    }
}

测试一下：

【OverrideTest.java】

package yuyi09;

/**
 * ClassName: OverrideTest
 * Package: yuyi09
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/1 0001 19:09
 */
public class OverrideTest {
    public static void main(String[] args) {
        //这里不涉及继承性了，直接造子类对象
        Student s1=new Student();

        //eat()方法与sleep()方法在Student类中没有声明过，这里调用就是调用父类中的方法
        s1.eat();
        s1.sleep();
    }
}

`

eat()方法与sleep()方法在Student类中没有声明过，这里调用就是调用父类中的方法，执行过后就是父类中的的输出值，如下：

image.png

现在这两个方法不适合子类Student了，需要做重写。

最基本的方法是，将eat()方法从父类Person中直接赋值过来：

image.png

可以在Student类中改方法体：（声明没有动）

public void eat(){
    System.out.println("学生应该多吃有营养的食物");
}

再次回到测试类OverrideTest，打印输出：

image.png

可以发现，eat()方法输出的是Student类重写父类的输出值；sleep()方法没有重写还是输出父类中的方法。

（3）方法重写应遵循的规则

【复习】方法声明的格式：

权限修饰符 返回值类型 方法名(形参列表) [throws 异常类型] {
	//方法体 
}

【具体规则】

① 父类被重写的方法与子类重写的方法的方法名和形参列表必须相同。

  • 父类中的某个方法可能有重载，子类要重写该方法，必须知道覆盖的是哪一个方法，需要通过名字和形参列表来判定覆盖的是哪一个方法。

② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。

  • 子类不能重写父类中声明为private权限修饰的方法。
  • 若在子类中赋值了父类中的方法，不算是重写它的方法，而是重新定义了一个方法。

③ 关于返回值类型

  • 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型必须是void。
  • 父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须与被重写的方法的返回值类型相同。

image.png

  • 父类被重写的方法的返回值类型是引用数据类型(比如类)，则子类重写的方法的返回值类型可以与被重写的方法的返回值类型相同 或 是被重写的方法的返回值类型的子类。
    • 子类返回值与父类一致（可以）

image.png

  • 子类重写的返回值为父类的子类（可以）

image.png

Student类是Person类的子类，左边的Person类要返回Person类型的值，右边的Student类返回的是Student类型的值，而Student类是Person类的子类，所以Student类相当于也是返回Person类型的值。（先这样理解，后边讲完多态之后就会更透彻)

  • 子类重写的返回值为父类的父类（不可以）

image.png

④方法体：没有要求。

但是子类重写的方法的方法体必然与父类被重写的方法的不同。

重写的目的就是要改方法体，子类重写父类的方法方法体肯定不一样，要不然没有意义。

⑤ （超纲）子类重写的方法抛出的异常类型可以与父类被重写的方法抛出的异常类型相同，或是父类被重写的方法抛出的异常类型的子类。

若不遵循规则，不能认为叫重写，说白了就是覆盖不了了。

在重写的时候，一般将父类的方法完全的声明全部粘贴到子类，在子类中专门写方法体即可。

若是连父类的方法也懒得赋值，可以直接在子类中敲方法名，比如sleep()，如下：

image.png

此时会弹出提示，直接点击弹出来的这个方法然后回车即可，就会自动获取这个方法：

@Override	//这个是注解，表示对父类中的某个方法做重写了
public void sleep() {
    super.sleep();	//super下一篇再说
}

🗃️补充：

@Override //这个是注解，表示对父类中的某个方法做重写了

它写没写跟是不是重写没有关系，删了这个也叫重写。

加上它的意义是做个校验。

比如，现在想重写sleep()方法，但是写错了，写成了sleap()。

这时候就会报错（此时你想重写，但是父类中没有这个方法，这里它相当于告诉你这个方法不是重写啦，相当于做个提示），如下：

image.png

（4）面试题

【面试题】区分方法的重载(overload)与重写(override / overwrite)

答：重载：“两同一不同”

重写：继承以后，子类覆盖父类中同名同参数的方法

image.png

【类比】相同类型的面试题

下面各组的区别（目前看看就好，这里只是列举相似的面试题）

throws / throw
final（关键字） / finally （关键字）/ finalize（方法名）
Collection / Collections
String / StringBuffer / StringBuilder
ArrayList / LinkedList
HashMap / LinkedHashMap / Hashtable
...

sleep() / wait()
== / equals()
同步 / 异步

四、方法的重写–练习题

继承：https://blog.csdn.net/m0_55746113/article/details/134135984

（1）练习1

🌋题目描述

修改继承内容的练习1中定义的类Kids，在Kids中重新定义employeed()方法，

覆盖父类ManKind中定义的employeed()方法，输出"Kids should study and no job."

【Mankind.java】

package yuyi10;

/**
 * ClassName: Mankind
 * Package: yuyi05
 * Description:
 * (1)定义一个ManKind类，包括
 *    成员变量int sex和int salary；
 * - 方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；
 *
 * - 方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
 * @Author 雨翼轻尘
 * @Create 2023/10/30 0030 10:32
 */
public class Mankind {
    //属性
    private int sex;
    private int salary;

    //方法

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public void manOrWoman(){
        if(sex==1){
            System.out.println("man");
        } else if (sex==0) {
            System.out.println("woman");
        }
    }

    public void employeed(){
        if(salary==0){
            System.out.println("no job");
        } else {
            System.out.println("job");
        }
    }

    //构造器

    public Mankind() {

    }

    public Mankind(int sex, int salary) {
        this.sex = sex;
        this.salary = salary;
    }
}

【Kids.java】

package yuyi10;

/**
 * ClassName: Kids
 * Package: yuyi05
 * Description:
 *   (2)定义类Kids继承ManKind，并包括
 * - 成员变量int yearsOld；
 * - 方法printAge()打印yearsOld的值。
 * @Author 雨翼轻尘
 * @Create 2023/10/30 0030 10:56
 */
public class Kids extends Mankind { //父类中声明的属性和方法都被继承到子类了，构造器就不提了。后边提super关键字的时候会提到，在子类当中调用父类中的构造器
    private int yearOld;

    public int getYearOld() {
        return yearOld;
    }

    public void setYearOld(int yearOld) {
        this.yearOld = yearOld;
    }

    public void printAge(){
        System.out.println("I am "+yearOld+" years old");
    }

    //构造器
    public Kids(){

    }

    public Kids(int yearOld){
        this.yearOld=yearOld;
    }

    //把父类中的属性也做一个赋值，包括自己的属性
    public Kids(int sex, int salary,int yearOld){
        this.yearOld=yearOld;
        //sex、salary两个 属性是父类继承过来的，怎么给他们赋值？
        setSex(sex);
        setSalary(salary);
    }
}

【KidsTest.java】

package yuyi10;

/**
 * ClassName: KidsTest
 * Package: yuyi05
 * Description:
 *(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。
 * @Author 雨翼轻尘
 * @Create 2023/10/30 0030 10:58
 */
public class KidsTest {
    public static void main(String[] args) {
        Kids someKid=new Kids();
        someKid.setSex(1);
        someKid.setSalary(100);
        someKid.setYearOld(12);

        //Kids类自己声明的方法
        someKid.printAge();

        //来自于父类中声明的方法
        someKid.manOrWoman();
        someKid.employeed();

    }
}

运行结果：

image.png

🤺代码

【 Kids.java】

package yuyi10;

public class Kids extends Mankind { //父类中声明的属性和方法都被继承到子类了，构造器就不提了。后边提super关键字的时候会提到，在子类当中调用父类中的构造器
   //...
    @Override
    public void employeed() {
        System.out.println("Kids should study and no job.");
    }
}

👻运行结果

image.png

（2）练习2

🌋题目描述

修改继承内容的练习中定义的类Cylinder，在Cylinder中重写父类方法findArea()，用于计算圆柱的表面积

【Circle.java】

package yuyi11;

/**
 * ClassName: Circle
 * Package: yuyi06
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/31 0031 10:07
 */
public class Circle {
    //属性
    private double radius;  //半径
    //方法
    public void setRadius(double radius){
        this.radius=radius;
    }
    public double getRadius(){
        return radius;
    }
    //求圆的面积
    public double findArea(){
        return Math.PI*radius*radius;
    }

    //构造器
    public Circle(){
        radius=1;
    }
}

【Cylinder.java】

package yuyi11;

/**
 * ClassName: Cylinder
 * Package: yuyi06
 * Description:
 *  圆柱类
 * @Author 雨翼轻尘
 * @Create 2023/10/31 0031 10:19
 */
public class Cylinder extends Circle {
    //属性
    private double length;  //高

    //方法
    public void setLength(double length){
        this.length=length;
    }
    public double getLength(){
        return length;
    }
    //求圆柱的体积
    public double findVolume(){
        //return Math.PI*getRadius()*getRadius()*getLength();
        return findArea()*getLength();
    }


    //构造器
    public Cylinder(){
        length=1;
    }
}

【CylinderTest.java】

package yuyi11;

/**
 * ClassName: CylinderTest
 * Package: yuyi06
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/31 0031 10:29
 */
public class CylinderTest {
    public static void main(String[] args) {
        Cylinder cy=new Cylinder();
        cy.setRadius(2.3);
        cy.setLength(1.4);
        System.out.println("圆柱的体积为： "+cy.findVolume());
        System.out.println("圆柱的底面积为： "+cy.findArea());
    }
}

运行结果：

image.png

🤺代码

【Cylinder.java】

package yuyi11;

public class Cylinder extends Circle {
    //属性
    private double length;  //高

    //...

    //求圆柱的体积
    public double findVolume(){
        return Math.PI*getRadius()*getRadius()*getLength();
        //return findArea()*getLength();	//错误
    }
    
    @Override
    public double findArea() {
        return Math.PI*getRadius()*getRadius()*2+
        2*Math.PI*getRadius()*getLength();
    }
}

👻运行结果

image.png

⚡注意

子类继承父类之后，若子类重写了父类中的方法，在子类中再次调用此方法是重写的方法，而不是父类中的方法。

若还想在子类中继续使用父类中的那个方法，下一节讲Super再说，不加就是重写的方法，加上了就是父类中的方法。

image.png

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

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

相关文章

shell基础篇：Bash特性和shell变量

shell基础篇：Bash特性和shell变量

shell基础篇 一、Bash特性bash基础特性关于历史记录的简单用法bash特性汇总 二、shell变量变量含义shell变量名规则定义shell变量变量替换/引⽤变量的作⽤域 一、Bash特性 bash基础特性 ● bash是一 个命令处理器，运行在文本窗口中，并能执行用户直接输…
阅读更多...
PCB设计入门基础

PCB设计入门基础

PCB设计入门基础 PCB基本结构 copper foil 铜箔laminate 层压(或粘合)材料inner layer core 内层堆芯 PCB基本结构是一个三明治的结构，它的上层是一个铜层，底层也是一个铜层，中间层脚FR-4，FR-4是一层不导电的物质，叫做…
阅读更多...
轻量封装WebGPU渲染系统示例＜11＞- WebGPU简单PBR效果(源码)

轻量封装WebGPU渲染系统示例＜11＞- WebGPU简单PBR效果(源码)

当前示例源码github地址: https://github.com/vilyLei/voxwebgpu/blob/main/src/voxgpu/sample/SimplePBRTest.ts 此示例渲染系统实现的特性: 1. 用户态与系统态隔离。 细节请见：引擎系统设计思路 - 用户态与系统态隔离-CSDN博客 2. 高频调用与低频调用隔离。 …
阅读更多...
爆肝整理，Fiddler+Charles+Chrome开发者工具弱网测试总结，一篇概全...

爆肝整理，Fiddler+Charles+Chrome开发者工具弱网测试总结，一篇概全...

目录：导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结（尾部小惊喜） 前言 1、Fiddler模拟弱…
阅读更多...
​国网、首钢集团、施耐德、吉利等出席2023中国企业绿电国际峰会​

​国网、首钢集团、施耐德、吉利等出席2023中国企业绿电国际峰会​

2023中国企业绿电国际峰会将通过邀请国家发展和改革委员会能源研究所、国网能源研究院、落基山研究所、首钢集团技术研究院、远景集团、施耐德电气、有色金属技术经济研究院有限责任公司、上海电气储能、博世、巴斯夫、晶科能源、吉利汽车等领域的企业高管，从绿色电…
阅读更多...
跨境电商五大运营模式都有哪些?有何特点?

跨境电商五大运营模式都有哪些?有何特点?

在跨境电商高速发展之下，跨境电商平台数量不断增加，各种跨境电商模式也不断逐渐暴露在人们的视野，下面小编就来为大家分析分析这些跨境电商都有哪些，它们的特点又是哪些，快来一起了解了解吧! 一、跨境电商五大运营模式…
阅读更多...
第二证券：43家上市券商三季报拆解

第二证券：43家上市券商三季报拆解

受生意、投行、自营三大业务“滑坡”影响，本年三季度，上市券商的运营成果略有“退让”。 根据Wind计算数据，本年第三季度，43家上市券商估计完结运营收入1127.37亿元，同比下降9.7%；归母净流润280.51亿元&am…
阅读更多...
办公必备神器：如何用AI快速生成年终总结PPT？

办公必备神器：如何用AI快速生成年终总结PPT？

2023年已经步入尾声，今年的销售业绩如何？用户同比增长率是否达到预期？部门年度API完成情况？新开发的项目进展如何？品牌全球计划在各区域市场的部署进展？…… 每年年底，不论是纵横全球的大企业&…
阅读更多...
【Linux基础IO篇】系统文件接口（1）

【Linux基础IO篇】系统文件接口（1）

【Linux基础IO篇】系统文件接口（1） 目录 【Linux基础IO篇】系统文件接口（1）回顾C语言的文件接口系统文件I/Oopen接口的介绍 open函数返回值文件描述符fd（小整数）文件描述符的分配规则 重定向dup2系统调用改…
阅读更多...
大模型训练时的内存泄漏与显存不足

大模型训练时的内存泄漏与显存不足

内存泄漏位置 位置1 FaceDetection 不可重复创建FaceDetection，该位置是内存泄漏的大头 mediapipe.solutions.face_detection.FaceDetection(model_selection1, min_detection_confidence0.5)位置2 tensorboardX 不可重复创建 tensorboardX.SummaryWriter Summ…
阅读更多...
2023年新疆电气年会-安科瑞 蒋静

2023年新疆电气年会-安科瑞 蒋静

2023年新疆电气年会于10月12-13日在五家渠市五家渠青湖御园酒店隆重召开。安科瑞电气股份有限公司受邀参会，为大会带来了主题演讲和产品现场展示！ 大会以“绿色低碳、智慧新疆”主题，分为专题学术报告、工程信息交流、论文颁奖、产品展示等环…
阅读更多...
基于Vite使用VitePress搭建静态站点博客

基于Vite使用VitePress搭建静态站点博客

使用VitePress搭建静态站点博客 官方文档什么是VitePress？一、初始化项目1.安装依赖包VitePress可以单独使用，也可以安装到现有的项目中。在这两种情况下，您都可以安装它: (也可以全局安装，建议：当前项目内安装) 2.初始…
阅读更多...
c语言思维框图

c语言思维框图

思维框图 文章目录 前言一、c语言思维框图总结 前言 附件为c语言思维框图。 一、c语言思维框图 后面可以增加更多框图，比如c/c学习路线图。 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单…
阅读更多...
Xilinx 产品制程工艺

Xilinx 产品制程工艺

A – 45nm 供货至2030年 Sparton6 xx 提供卓越的连接功能，例如高逻辑引脚比、小尺寸封装、MicroBlaze™ 软处理器，以及多种受支持的 I/O 协议。 B – 28nm 供货至2035年 spartan-7\artix-7 \kintex-7\virtex-7\Zynq™ 7000 SoC 工艺节点上的持续创新…
阅读更多...
Python-市场交易中的概率夏普比率 (PSR)

Python-市场交易中的概率夏普比率 (PSR)

“虽然偏度和峰度不会影响夏普比率的点估计，但它会极大地影响其置信带，从而影响其统计显着性”Bailey 和 Lpez de Prado 1 0. 简介 今天，我们将讨论备受推崇的夏普比率（SR），该指标几
阅读更多...
野火霸天虎 STM32F407 学习笔记_2 寄存器介绍

野火霸天虎 STM32F407 学习笔记_2 寄存器介绍

寄存器 虽然正式编程没有必要用寄存器编程，通常都是库函数或者 hal 库。但是还是有必要学一下原理的。 寄存器映射 芯片视图如下。 丝印：芯片上印的信息。型号，内核，生产批次等。 引脚：左上角是有小圆点的&#x…
阅读更多...
CH09_重新组织数据

CH09_重新组织数据

拆分变量（Split Variable） 曾用名：移除对参数的赋值（Remove Assignments to Parameters） 曾用名：分解临时变量（Split Temp） let temp 2 * (height width); console.log(temp); t…
阅读更多...
JVM——类的生命周期（加载阶段，连接阶段，初始化阶段）

JVM——类的生命周期（加载阶段，连接阶段，初始化阶段）

目录 1.加载阶段2.连接阶段1.验证2.准备3.解析 3.初始化阶段4.总结 类的生命周期 1.加载阶段 ⚫ 1、加载(Loading)阶段第一步是类加载器根据类的全限定名通过不同的渠道以二进制流的方式获取字节码信息。 程序员可以使用Java代码拓展的不同的渠道。 ⚫ 2、类加载器在加载完类…
阅读更多...
SAP 物料凭证在凭证流中显示归档

SAP 物料凭证在凭证流中显示归档

问题： 在交货单做过PGI/PGR之后，显示物料凭证已归档，但是实际上并不是人为归档 MIGO去显示物料凭证的时候显示不存在 VL09 无法冲销 如下图所示 原因：1.人为做了归档 2.在做PGI的时候出现了异常。导致出现了问题 解决…
阅读更多...
本章内容的重点是对各种电子式电动机保护器电路的原理分析和故障维修指导，对电子式电动机保护器以下简称为电动机保护器。

本章内容的重点是对各种电子式电动机保护器电路的原理分析和故障维修指导，对电子式电动机保护器以下简称为电动机保护器。

上世纪八十年代之前，电子技术的应用尚处于初级阶段，对电动机的保护任务多由热继电器承担，国内型号为为JR20-XX系列、JR36-XX系列等。其保护机理如下：热继电器由发热元件、双金属片、触点及一套传动和调整机构组成。发热元件是一段…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023