8.面向对象编程（高级部分）|Java学习笔记

news2024/11/28 2:45:02

文章目录

  • 类变量和类方法
    • 类变量
      • 类变量使用注意事项和细节
    • 类方法
      • 类方法使用注意事项和细节
  • 理解 main 方法语法
  • 代码块
    • 代码块使用注意事项和细节讨论
  • 单例设计模式
    • 单例模式应用实例
    • 饿汉式 VS 懒汉式
  • final 关键字
    • final 使用注意事项和细节
  • 抽象类
    • 抽象类的介绍
    • 抽象类使用的注意事项和细节
  • 抽象类最佳实践——模板设计模式
  • 接口
    • 一个接口的例子
    • 注意事项和细节
    • 实现接口 vs 继承类
    • 接口的多态特性
  • 内部类
    • 局部内部类
    • 匿名内部类
      • 匿名内部类的最佳实践
    • 成员内部类
    • 静态内部类

类变量和类方法

类变量

思考: 如果,设计一个 int count 表示总人数,我们在创建一个小孩时，就把 count 加 1,并且 count 是所有对象共享的就 ok 了！我们使用类变量来解决。

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。

// 定义语法
访问修饰符 static 数据类型 变量名;

// 访问类变量
类名.类变量名
或者 对象名.类变量名
推荐使用： 类名.类变量名
  1. static 变量是同一个类所有对象共享
  2. static 类变量，在类加载的时候就生成了

类变量使用注意事项和细节

  1. 什么时候需要用类变量？
    当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量):比如:定义学生类,统计所有学生共交多少钱。Student (name,staticfee)
  2. 类变量与实例变量(普通属性)区别：
    类变量是该类的所有对象共享的，而实例变量是每个对象独享的。
  3. 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
  4. 类变量可以通过类名.类变量名或者对象名.类变量名来访问，但java设计者推荐我们使用类名.类变量名方式访问。【前提是满足访问修饰符的访问权限和范围】
  5. 实例变量不能通过类名.类变量名方式访问。
  6. 类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了,就可以使用类变量了。
  7. 类变量的生命周期是随类的加载开始,随着类消亡而销毁。

类方法

// 定义
访问修饰符 static 数据返回类型 方法名(){}

// 调用
类名.类方法名

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率。

类方法使用注意事项和细节

  1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区:
    类方法中无this的参数
    普通方法中隐含着this的参数
  2. 类方法可以通过类名调用，也可以通过对象名调用。
  3. 普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调
    用。
  4. 类方法中不允许使用和对象有关的关键字，比如 this 和 super。普通方法(成员方法)可以。
  5. 类方法(静态方法)中只能访问静态变量或静态方法。
  6. 普通成员方法,既可以访问非静态成员，也可以访问静态成员。

小结：
静态方法，只能访问静态的成员。
非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)。

理解 main 方法语法

public static void main(String[] args) {
}
  1. main方法是虚拟机调用。
  2. java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public。
  3. java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static。
  4. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。
  5. java 执行的程序 参数1参数2参数3
  1. 在 main()方法中，我们可以直接调用 main 方法所在类的静态方法或静态属性。
  2. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

代码块

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过 { } 包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

[修饰符] {
	代码
}

说明注意：

  1. 修饰符可选,要写的话，也只能写static
  2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的,叫普通代码块/非静态代码块。
  3. 逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
  4. ;号可以写上,也可以省略。

代码块的好处：

  1. 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作。
  2. 场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性。

代码块使用注意事项和细节讨论

  1. static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
  2. 类什么时候被加载[重要背!]
    ①创建对象实例时(new)
    ②创建子类对象实例,父类也会被加载
    ③使用类的静态成员时(静态属性,静态方法)
  3. 普通的代码块，在创建对象实例时，会被隐式的调用。
    被创建一次，就会调用一次。
    如果只是使用类的静态成员时，普通代码块并不会执行。

小结:

  1. static 代码块是类加载时，执行,只会执行一次。
  2. 普通代码块是在创建对象时调用的，创建一次，调用一次。
  3. 类加载的3种情况，需要记住。
  4. 创建一个对象时，在一个类调用顺序是:(重点，难点)∶
    ①调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
    ②调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
    ③调用构造方法。
  5. 构造器的最前面其实隐含了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕。
class A {
	public A() { //构造器
		//这里有隐藏的执行要求
		// (1) super();
		// (2)调用普通代码块的
		System.out.println("ok");
	}
}
  1. 我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:
    ①父类的静态代码块和静态属性(优先级一样,按定义顺序执行)
    ②子类的静态代码块和静态属性(优先级一样,按定义顺序执行)
    ③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
    ④父类的构造方法
    ⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
    ⑥子类的构造方法
  2. 静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员。

单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱，免去我们自己再思考和摸索。

什么是单例模式？

  1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
  2. 单例模式有两种方式: 1) 饿汉式 2) 懒汉式

饿汉式：类加载时就会创建对象。
懒汉式：不使用就不会创建。

单例模式应用实例

  1. 构造器私有化=》防止直接new
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法。getInstance

饿汉式

public class SingleTon01 {
    public static void main(String[] args) {
        System.out.println(GirlFriend.n1);

        // GirlFriend instance = GirlFriend.getInstance();
        // System.out.println(instance);
        //
        // GirlFriend instance2 = GirlFriend.getInstance();
        // System.out.println(instance2);
    }
}

class GirlFriend {
    private String name;
    public static int n1= 10;

    private static GirlFriend gf = new GirlFriend("小红红");	// 类加载时就会创建对象

    private GirlFriend(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }

    public static GirlFriend getInstance() {
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式

public class SingleTon02 {
    public static void main(String[] args) {
        System.out.println(Cat.n1);

        Cat instance = Cat.getInstance();
        System.out.println(instance);
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);
    }
}

class Cat {
    private String name;
    public static int n1 = 999;

    private static Cat cat;

    private Cat(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }

    public static Cat getInstance() {
        if (cat == null) {		// 防止多次创建
            cat = new Cat("小可爱");		// 不使用就不会创建
        }

        return cat;
    }
}

饿汉式 VS 懒汉式

在这里插入图片描述

final 关键字

在这里插入图片描述

  1. 不希望类被继承
  2. 不希望父类的某个方法被子类覆盖/重写
  3. 不希望类的某个属性的值被修改
  4. 不希望某个局部变量被修改

final 使用注意事项和细节

  1. final修饰的属性又叫常量,一般用XX_ XX XX来命名
  2. final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】:
    ①定义时:如public final double TAX_RATE=0.08;
    ②在构造器中
    ③在代码块中。
  3. 如果final修饰的属性是静态的，则初始化的位置只能是①定义时②在静态代码块
    不能在构造器中赋值。
  4. final类不能继承,但是可以实例化对象。
  5. 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。
  6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
  7. final不能修饰构造方法(即构造器)
  8. final和static往往搭配使用，效率更高，不会导致类加载。底层编译器做了优化处理。
  9. 包装类(Integer,Double,Float,Boolean等都是final),String也是final类。
package com.fwedu.final_;

public class FinalExercise02 {
    public static void main(String[] args) {
        System.out.println(A.num);
    }
}

class A {
    public final static int num = 100;
    static {
        System.out.println("A代码块被执行");
    }
}

由于 final 和 static 的搭配使用，因此输出结果只会有 100。
如果删去 final ，那么输出结果会是：

A代码块被执行
100

抽象类

在这里插入图片描述

所谓抽象方法就是没有实现的方法
所谓没有实现就是指，没有方法体
当一个类中存在抽象方法时，需要将该类声明为 abstract 类

抽象类的介绍

在这里插入图片描述

抽象类使用的注意事项和细节

  1. 抽象类不能被实例化

  2. 抽象类不一定要包含 abstract 方法。也就是说，抽象类可以没有 abstract 方法。

  3. 一旦类包含了 abstract 方法，则这个类必须声明为 abstract

  4. abstract 只能修饰类和方法，不能修饰属性和其他

  5. 抽象类可以有任意成员【抽象类本质还是类】，比如：非抽象方法、构造器、静态属性等等。

  6. 抽象方法不能有主体，即不能实现。（不能有{}）
    在这里插入图片描述

  7. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为 abstract 类。

  8. 抽象方法不能使用 private 、final 和 static 来修饰，因为这些关键字都是和重写相违背的。

抽象类最佳实践——模板设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。

模板设计模式能解决的问题：

  1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
  2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.

抽象类 Template

package com.fwedu.abstract_;

public abstract class Template {
    /**
     * 计算工作时间
     */
    public abstract void job();

    public void calculateTime() {
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}

继承 Template ，实现了抽象方法 job() 的 Aa类

package com.fwedu.abstract_;

public class Aa extends Template{

    @Override
    public void job() {
        long num = 0;
        for (long i = 1; i <= 800000; i++) {
            num += i;
        }
        System.out.println(num);
    }
}

也就是继承了 Template 的都可以计算 job() 运行的时间，但是不同的子类执行的 job() 可以是不一样的。

接口

在这里插入图片描述
在这里插入图片描述

图中写的 抽象类里的方法可以有方法体指的是非抽象方法，抽象方法是不可以有方法体的。

一个接口的例子

定义了一个接口 UsbInterface

package com.fwedu.interface_;

public interface UsbInterface {
    /**
     * 开始
     */
    public void start();

    /**
     * 结束
     */
    public void stop();
}

定义了一个类 Camera 实现了接口 UsbInterface

package com.fwedu.interface_;

public class Camera implements UsbInterface{
    @Override
    public void start() {
        System.out.println("相机开始工作。。。");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作。。。");
    }
}

定义了一个类 Phone 实现了接口 UsbInterface

package com.fwedu.interface_;

public class Phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("手机开始工作。。。");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作。。。");
    }
}

定义了一个类 Computer，它可以调用接口 UsbInterface

package com.fwedu.interface_;

public class Computer {
    public void work(UsbInterface usbInterface) {
        usbInterface.start();
        usbInterface.stop();
    }
}

一个示例：
使用 Computer，既可以使用 phone 工作，也可以使用 camera 工作。

package com.fwedu.interface_;

public class Interface01 {
    public static void main(String[] args) {
        Camera camera = new Camera();
        Phone phone = new Phone();

        Computer computer = new Computer();

        computer.work(phone);
        System.out.println("=====");

        computer.work(camera);
        System.out.println("=====");
    }
}

注意事项和细节

  1. 接口不能被实例化

  2. 接口中所有的方法是 public方法，接口中抽象方法，可以不用abstract修饰
    图示:
    void aaa(); 实际上是abstract void aa);

  3. 一个普通类实现接口,就必须将该接口的所有方法都实现。

  4. 抽象类实现接口，可以不用实现接口的方法。

  5. 一个类同时可以实现多个接口

class Pig implements IB, IC {}
  1. 接口中的属性,只能是final的，而且是 public static final修饰符。比如：int a=1;实际上是 public static final int a=1;(必须初始化)
  2. 接口中属性的访问形式:接口名.属性名
  3. 接口不能继承其它的类,但是可以继承多个别的接口
interface A extends B,C {}
  1. 接口的修饰符只能是public 和默认，这点和类的修饰符是一样的。

实现接口 vs 继承类

当子类继承了父类，就自动的拥有父类的功能。
如果子类需要扩展功能，可以通过实现接口的方式扩展.。
可以理解 实现接口 是 对 java 单继承机制的一种补充。

在这里插入图片描述

接口的多态特性

多态参数、多态数组、多态传递。
在这里插入图片描述

class C extends B implements A {
	public void pX() {
		//System.out.println(x); //错误，原因不明确 x
		//可以明确的指定 x
		//访问接口的 x 就使用 A.x
		//访问父类的 x 就使用 super.x
		System.out.println(A.x + " " + super.x);
	}
}

//访问接口的 x 就使用 A.x
//访问父类的 x 就使用 super.x

内部类

如果定义类在局部位置(方法中/代码块) : (1) 局部内部类 (2) 匿名内部类
定义在成员位置 (1) 成员内部类 (2) 静态内部类

一个类的内部又完整的嵌套了另一个类结构。
被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。
是我们类的第五大成员【思考:类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]】，
内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系，

底层源码中，有大量的内部类。

基本语法：

class Outer {		// 外部类
	class Inner {	// 内部类
	}
}
class Other {		// 外部其他类
}

内部类的分类

在这里插入图片描述
如果定义类在局部位置(方法中/代码块) :
(1) 局部内部类（有类名）
(2) 匿名内部类（没有类名）
定义在成员位置上：
(1) 成员内部类（没有static修饰）
(2) 静态内部类（使用static修饰）

局部内部类

在这里插入图片描述
说明:局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

  1. 可以直接访问外部类的所有成员，包含私有的。
  2. 不能添加访问修饰符,因为它的地位就是一个局部变量，局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final。
  3. 作用域 :仅仅在定义它的方法或代码块中。
  4. 局部内部类-访向----> 外部类的成员[访问方式:直接访问]
  5. 外部类—访向—>局部内部类的成员。
    访问方式:创建对象，再访问(注意:必须在作用域内)
    记住:
    (1) 局部内部类定义在方法中/代码块
    (2) 作用域在方法体或者代码块中
    (3) 本质仍然是一个类
  6. 外部其他类–不能访问---->局部内部类(因为局部内部类地位是一一个局部变量)。
  7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问。

匿名内部类

  1. 本质还是类
  2. 内部类
  3. 该类没有名字
  4. 同时还是一个对象

在这里插入图片描述

  1. 匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
  2. 可以直接访问外部类的所有成员，包含私有的。
  3. 不能添加访问修饰符,因为它的地位就是一个局部变量。
  4. 作用域：仅仅在定义它的方法或代码块中。
  5. 匿名内部类—访问—>外部类成员[访问方式:直接访问]
  6. 外部其他类–不能访问-----匿名内部类(因为匿名内部类地位是一个局部变量)
  7. 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问。

匿名内部类的最佳实践

package com.fwedu.innerclass;

public class InnerClassExercise01 {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}

class Outer05 {
    private int n1 =99;

    public void f1() {
        Person p = new Person() {
            private int n1 = 98;

            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi 方法" + n1 +
                        " 外部类的n1 = " + Outer05.this.n1);
            }
        };
        p.hi();

        // 可以直接调用
        new Person() {
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi 方法 hhh");
            }

            @Override
            public void ok(String str) {
                super.ok(str);
            }
        }.ok("jack");
    }
}

class Person {
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {
        System.out.println("Person ok() " + str);
    }
}

输出是：

匿名内部类重写了 hi 方法98 外部类的n1 = 99
Person ok() jack

成员内部类

在这里插入图片描述

外部其他类 访问 成员内部类：

// 第一种方式
// outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
// 这就是一个语法， 不要特别的纠结.
Outer08.Inner08 inner08 = outer08.new Inner08();
inner08.say();
// 第二方式 在外部类中， 编写一个方法， 可以返回 Inner08 对象
Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
inner08Instance.say();

静态内部类

在这里插入图片描述

外部内部类 访问 静态内部类

//方式 1
//因为静态内部类， 是可以通过类名直接访问(前提是满足访问权限)
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式 2
//编写一个方法， 可以返回静态内部类的对象实例.
Outer10.Inner10 inner101 = outer10.getInner10();
System.out.println("============");
inner101.say();
Outer10.Inner10 inner10_ = Outer10.getInner10_();
System.out.println("************");
inner10_.say();

因为静态属性和静态方法都从属于类，是类属性，类方法，可以通过类名.的方式来直接访问。

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

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

相关文章

软件测试|测试金字塔是什么，它的目的是什么，以及它包含哪些层次？

软件测试|测试金字塔是什么，它的目的是什么，以及它包含哪些层次？

一、测试金字塔的概念&#xff1a; 测试金字塔是2009年Mike Cohn在他的著作《Succeeding with Agile》一书正式提出的。他是一个类比的概念&#xff0c;形容每一层&#xff0c;或者说不同集成阶段测试覆盖率和知行效率之间的一个相对关系。 测试金字塔最初的原型分三层&#…
阅读更多...
chatgpt赋能python：Python循环间隔-了解如何在循环中增加延时

chatgpt赋能python：Python循环间隔-了解如何在循环中增加延时

Python循环间隔 - 了解如何在循环中增加延时 在Python编程中&#xff0c;循环是非常常见且重要的控制语句。 它使我们可以多次执行代码块。 但是&#xff0c;在有些情况下&#xff0c;您可能需要在循环之间增加一定的延时时间。 这就是Python循环间隔的概念。 在本文中&#x…
阅读更多...
初次使用PPYOLOE-R

初次使用PPYOLOE-R

目的&#xff1a;优化基于yolov5-obb旋转目标检测算法的证件区域检测&#xff0c;之前的方法是基于anchor&#xff0c;每次使用都要调试anchor&#xff1b;而ppyoloe-r是free anchor的算法&#xff1b; 源码位置&#xff1a;https://github.com/PaddlePaddle/PaddleDetection/…
阅读更多...
学成在线----day2

学成在线----day2

1、mybatis-plus分页 pom: <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.ap…
阅读更多...
【大数据之Hive】九、Hive之DDL（Data Definition Language）数据定义语言

【大数据之Hive】九、Hive之DDL（Data Definition Language）数据定义语言

1 数据库 [ ] 里的都是可选的操作。 1.1 创建数据库 语法&#xff1a; create database [if not exists] database_name [comment database_comment(注释)] [location hdfs_path] [with dbproperties (property_name-propertyproperty_value,...)]; 如&#xff1a; creat…
阅读更多...
真实性能测试案例之性能分析与报告

真实性能测试案例之性能分析与报告

今天主要跟大家分享一个曾经所做的真实性能测试的案例&#xff0c;主要为其中性能测试分析报告过程部分&#xff0c;希望能对你以后怎么做性能分析和报告有所帮助。这个案例的测试目的为&#xff1a;在线考试为“XX平台”中的一个重要模块&#xff0c;根据目前业务的需要&#…
阅读更多...
ChatGPT实用使用指南 让它解你所问

ChatGPT实用使用指南 让它解你所问

Chatgpt无疑是这几年来影响力最大的AI技术之一&#xff0c;生成式的AI模型正在促进各个行业的效率和自动化发展&#xff0c;Chatgpt对于个人、企业和各个行业都有着一定的影响 在我刚接触的时候&#xff0c;发现对Chatgpt的认知太肤浅了&#xff0c;一个最强的ai聊天机器人摆在…
阅读更多...
实时检测Aruco标签坐标及位姿opencv-python4.6和4.7版本

实时检测Aruco标签坐标及位姿opencv-python4.6和4.7版本

先说opencv-contrib-python4.7.0.72时&#xff0c;aruco下面带曲线&#xff0c;但是程序也能跑&#xff0c;可以跑检测的&#xff0c;对比4.6版本需要改三个函数 4.6装opencv-contrib-python 4.7装opencv-contrib-python 1 cv2.aruco.Dictionary_get() cv2.aruco.getPredef…
阅读更多...
Smali的使用技巧：快速定位Android应用程序中的关键代码

Smali的使用技巧：快速定位Android应用程序中的关键代码

简述 Smali是一种Android应用程序的Dalvik虚拟机指令集汇编语言&#xff0c;用于编写和修改应用程序的DEX文件。通过编写和修改Smali代码&#xff0c;可以实现对Android应用程序的定制化和逆向分析。Smali语言类似于汇编语言&#xff0c;直接操作Dalvik虚拟机指令集。 Smali代…
阅读更多...
2023最火的软件测试面试宝典，你刷过没？

2023最火的软件测试面试宝典，你刷过没？

这是一份最近疯传的软件测试面试宝典&#xff0c;你有刷过吗&#xff1f; 面试宝典一共400页&#xff0c;包括了测试基础102页&#xff0c;Linux基础38页&#xff0c;MySQL63页&#xff0c;web测试21页&#xff0c;app测试38页&#xff0c;selenium相关50页&#xff0c;性能测试…
阅读更多...
02.引擎架构分类

02.引擎架构分类

简介 1.工具层 2.功能层&#xff1a;绘制、渲染、让世界里面的东西能看见、动起来 3.资源层&#xff1a;负责加载大量的数据和文件 4.核心层&#xff1a;游戏引擎的瑞士军刀&#xff0c;各种功能处理的内核 5.平台层&#xff1a;用于适配游戏不同的发行平台 第三方中间插…
阅读更多...
3d渲染时预览和出图不一样怎么办？

3d渲染时预览和出图不一样怎么办？

在使用3dmax渲染时有时会遇到看到的图和渲染出来的图不一样的情况&#xff0c;这是为什么呢&#xff1f;有以下几方面的原因。 一、伽马 3dmax的伽马有很多&#xff0c;主要有显示伽马、输入伽马和输出伽马&#xff0c;其中预览图亮度由显示伽马决定&#xff0c;而图片亮度由输…
阅读更多...
VUE.js中文官方文档

VUE.js中文官方文档

目录 创建一个 Vue 应用# 应用实例# 根组件# 挂载应用# DOM 中的根组件模板# 应用配置# 多个应用实例# 模板语法# 文本插值# 原始 HTML# Attribute 绑定# 简写# 布尔型 Attribute# 动态绑定多个值# 使用 JavaScript 表达式# 仅支持表达式# 调用函数# 受限的全…
阅读更多...
隐私计算简介

隐私计算简介

随着数据规模的不断扩大和网络技术的快速发展&#xff0c;数据安全和隐私保护成为了热门的话题。隐私计算作为一种新兴的数据安全和隐私保护技术&#xff0c;为数据安全和隐私泄露问题提供了新的思路和方法。 2020年10月19日&#xff0c;Gartner发布2021年前沿战略科技趋势&am…
阅读更多...
Blender3.2使用python脚本命令的三种方式, 以及后台渲染调用源码示例及说明

Blender3.2使用python脚本命令的三种方式, 以及后台渲染调用源码示例及说明

本文环境系统OS(Win10) 方式一&#xff0c;在Script(脚本)功能里面的Console(控制台输入python代码)。 如下图: 对应的三句代码是&#xff1a; print("Hi, blender.")import bpybpy.ops.mesh.primitive_cube_add(enter_editmodeFalse, alignWORLD, location(0,0, …
阅读更多...
Vue3.0性能提升主要是通过哪几方面体现的(了解)

Vue3.0性能提升主要是通过哪几方面体现的(了解)

文章目录 一、编译阶段diff算法优化静态提升事件监听缓存SSR优化二、源码体积响应式系统 一、编译阶段 回顾Vue2&#xff0c;我们知道每个组件实例都对应一个 watcher 实例&#xff0c;它会在组件渲染的过程中把用到的数据property记录为依赖&#xff0c;当依赖发生改变&#…
阅读更多...
【ICML 2023】Hiera详解：一个简单且高效的分层视觉转换器

【ICML 2023】Hiera详解：一个简单且高效的分层视觉转换器

【ICML 2023】Hiera详解&#xff1a;一个简单且高效的分层视觉转换器 0. 引言1. 模型介绍2. Hiera介绍2.1 为什么提出Hiera&#xff1f;2.2 Hiera 中的 Mask2.3 空间结构的分离和填充到底如何操作2.4 为什么使用Mask Unit Attn 3. 简化版理解4. 总结 0. 引言 虽然现在各种各样…
阅读更多...
Docker 安装Tomcat、实现Tomcat集群

Docker 安装Tomcat、实现Tomcat集群

文章目录 1、寻找Tomcat镜像2、下载tomcat镜像&#xff08;下载最近版本&#xff09;(1) docker pull tomcat 下载(2) 查看镜像是否安装成功 3、启动容器&#xff08;跟安装Nginx一样&#xff09;4、 测试tomcat&#xff08;报错解决&#xff09;5、 搭建Tomcat集群 1、寻找Tom…
阅读更多...
访问修饰符private，default，protected，public访问等级区别

访问修饰符private，default，protected，public访问等级区别

private&#xff1a;private是最严格的访问修饰符&#xff0c;它将成员声明为私有的。私有成员只能在声明它们的类内部访问&#xff0c;其他类无法直接访问私有成员。这样可以确保数据的封装性和安全性。 default&#xff08;默认&#xff09;&#xff1a;如果没有明确指定访问…
阅读更多...
Pytest 分组测试

Pytest 分组测试

有时候需要针对不同的测试环境跑不同的测试用例&#xff0c;如&#xff1a;冒烟测试、sit、uat、prd&#xff0c;所以给自动化测试用例做标记分组是很有必要的&#xff0c;pytest.mark 可以轻松实现这个功能。首先需要注册自定义标记。 注册marks 有3中方法注册marks&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023