Java基础教程 - 7 面向对象-1

news2024/11/24 12:55:29

更好的阅读体验:点这里 ( www.doubibiji.com
更好的阅读体验:点这里 ( www.doubibiji.com
更好的阅读体验:点这里 ( www.doubibiji.com

7 面向对象

面向对象,首先涉及到的两个概念就是:对象

什么是类?

类就是对现实事物的抽象设计。

例如设计学生的类,可能包括属性:学号,姓名、年龄、性别等。

设计狗的类,可能包括属性:名字、年龄、品种。

类表示的是对一个事物的抽象,不是具体的某个事物。

什么是对象?

对象就是一个具体的实例,这个实例是从类派生出来的。

我们将类的属性赋值,就产生了一个个实例,也就是对象。

例如通过学生的类,我们赋值:学号=001,姓名=张三,年龄=16,性别=男,班级=三年二班,产生了就是一个名字叫张三的具体的学生,这样我们通过给类可以派生出一个个不同属性值的对象,李四、王五、赵六…。

所以是先设计类,然后根据类来生成一个个对象。

7.1 类和对象

1 类的定义

类中可以定义属性和行为,属性也就是成员变量,表示这个类有哪些数据信息,行为也叫成员方法,表示这个类能干什么。

例如,对于学生类而言,学号、姓名、年级就是属性,学习这个行为,可以定义为方法。

那么我们可以定义以下学生类:

/**
 *定义类使用class关键字,后面跟类名
 */
class Student {
    public String sid;
    public String name;
    public int age;

    public void study() {
        System.out.println("我是" + name + ", 我在学习");
    }
}

上面的类定义了三个成员变量(sid、name、age),public 表示访问修饰符,用来限制属性的访问权限,后面再讲,现在使用 public。后面是变量类型和变量的名称。

还定义了一个成员方法 study(),定义成员方法和之前定义静态方法是一样的,只是没有 static 关键字。

2 类的使用

上面我们定义好类了,现在可以使用类来创建对象了。

/**
 * 定义学生类
 */
class Student {
    public String sid;
    public String name;
    public int age;

    public void study() {
        System.out.println("我是" + name + ", 我在学习");
    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Student stu = new Student();   // 创建对象

        stu.sid = "001";        // 为对象的sid属性赋值
        stu.name = "张三";       // 为对象的name属性赋值,现在学生是张三了
        stu.age = 18;

        System.out.println(stu.name);   // 打印名称
        stu.study();       // 使用对象调用方法
    }
}

因为 Java 中所有的代码都要放到类中,这里将测试的 main 方法放到了另一个类中,当然 main 方法放到 Student 中也是可以的,这里为了结构清晰。

首先通过 new Student() 可以创建一个 Student 对象,赋值给 Student 类型的变量 stu

创建对象后,我们可以通过 对象.属性 来访问变量,也可以通过 对象.属性=值 来给属性赋值。

使用 对象.方法() 可以调用方法。

执行结果:

张三
我是张三, 我在学习

面向对象编程就是先设计类,然后通过类创建对象,由对象做具体的工作。

3 默认构造方法

在上面创建对象后,使用 对象.属性=值 来给属性赋值,有点麻烦,我们可以在创建对象的时候,直接传递参数,给属性赋值。

这里就需要用到 构造方法。构造方法会在创建对象的时候自动执行,通过传递的属性值,给属性进行初始化。

举个栗子:

构造方法的名称和类的名称是一致的,没有返回值类型。

/**
 * 定义类
 */
class Student {
    public String sid;
    public String name;
    public int age;

    /**
     * 构造方法
     */
    public Student(String sid, String name, int age) {
        this.sid = sid;			// this.sid 访问的是属性,sid 是方法的形参
        this.name = name;
        this.age = age;
    }

    public void study() {
        System.out.println("我是" + name + ", 我在学习");
    }
}

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args) {
        // 创建张三
        Student stu1 = new Student("001", "张三", 18);
        stu1.study();

        // 创建李四
        Student stu2 = new Student("002", "李四", 19);
        stu2.study();
    }
}

在上面的代码中,定义了构造方法,接收三个参数 (String sid, String name, int age),在构造方法中,分别将三个参数赋值给类中的成员变量。

因为构造方法的参数和类中的成员变量名称相同了(也可以不同),所以如果在构造方法中直接使用变量名,访问的将是构造方法的参数,访问不到成员变量,如果要访问成员,需要使用 this 关键字。

当然在 study() 方法中,没有参数和成员变量 name 同名,所以 name 访问到的就是成员变量,可以不用 this (当然使用也没毛病)。

在创建对象的时候,就可以传递参数为对象的属性赋值: new Student("001", "张三", 18)每次 new 就会创建新的对象,每个对象是独立的,所以上面张三和李四对象是独立的两个对象,修改其中一个对象的值,不会影响另一个对象。

执行结果:

我是张三, 我在学习
我是李四, 我在学习

4 this的作用

在上面的代码中用到了 this,因为上面我们写构造方法的时候,形参和类的属性名相同(当然也可以不同),导致在构造方法中,使用 sid/name/age 无法访问到类的属性,使用this,就表示访问的是属性 。

其实 this 表示的是调用当前方法的对象。如何理解?

举个栗子:

下面的代码,我们定义了学生类,创建了两个学生的对象。

/**
 * 定义类
 */
class Student {
    public String sid;
    public String name;
    public int age;

    /**
     * 构造方法
     */
    public Student(String sid, String name, int age) {
        this.sid = sid;			// this.sid 访问的是属性,sid 是方法的形参
        this.name = name;
        this.age = age;
    }

    public void study() {
        System.out.println("我是" + this.name + "我" + age +"岁了" + ", 我在学习");
    }
}

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args) {
        // 创建张三
        Student stu1 = new Student("001", "张三", 18);
        stu1.study();

        // 创建李四
        Student stu2 = new Student("002", "李四", 19);
        stu2.study();
    }
}

执行结果:

我是张三, 我18岁了, 我在学习
我是李四, 我19岁了, 我在学习

当我们使用 stu1 调用 study() 方法的时候,this 就是指 张三 (stu1)这个对象,那么 this.name 的值就是张三;当我们使用 stu2 调用 study() 方法的时候,this 就是指 李四 (stu2) 这个对象,那么 this.name 的值就是李四。this 就是调用当前方法的对象。

5 对象内存解析

先查看下面的代码:

Student stu1 = new Student();   // 创建张三对象
stu1.sid = "001";        
stu1.name = "张三";
stu1.age = 18;

Student stu2 = new Student();   // 创建李四对象
stu2.sid = "002";        
stu2.name = "李四";
stu2.age = 19;

Student stu3 = stu1;
stu3.name = "王五";        

System.out.println(stu1.name);   // 王五
System.out.println(stu2.name);   // 李四
System.out.println(stu3.name);   // 王五

在上面的代码中,首先创建了两个对象赋值给了 stu1 和 stu2,并对属性进行赋值,然后定义了一个 stu3 的变量,将 stu1 赋值给了 stu3,我们前面说过 stu1 和 stu2 是独立的两个对象,那么 stu1 和 stu3 是独立的两个对象吗?两个是同一个对象。下面画一下内存示意图:

创建完 stu1 并赋值后,内存结构如下(其实字符串是不保存在堆或栈中的,这里简化了):

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

创建完 stu2 并赋值后,内存结构如下:

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

Student stu3 = stu1 执行完,内存结构如下:

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

stu3.name = "王五"; 执行完成,内存结构如下:

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

所以只在 new 的时候才会创建新的对象,stu3 = stu1 只是将 stu1 执行的对象的引用赋值给了 stu3 。

6 静态变量

上面我们定义的属性和方法,是实例变量和实例方法,也叫成员变量和成员方法。

实例变量对于每个实例而言,是独立的数据,每个对象之间相互不会影响。创建一个对象,就会开辟独立的内存空间保存对象的实例变量数据。但是无论创建多少对象,实例方法只有一份,所有对象共享,通过 this,来确定是哪个对象调用了实例方法。

在类中还可以定义各个对象共享的数据,也就是静态变量。

打个比方,我们定义了一个 Student 类,然后通过 Student 类来创建对象,我们想知道一共创建了多少个 Student 对象,应该如何操作呢?

我们可以通过定义 静态变量 来实现,静态变量和成员变量的区别就是:前面通过 static 关键字来修饰。

/**
 * 定义类
 */
class Student {
    public static int stuCount = 0;		// 定义一个静态变量,用于记录创建的对象个数
    public String sid;
    public String name;
    public int age;

    /**
     * 构造方法
     */
    public Student(String sid, String name, int age) {
        stuCount++;				  // 创建对象会调用构造方法,调用一次就+1

        this.sid = sid;			// this.sid 访问的是属性,sid 是方法的形参
        this.name = name;
        this.age = age;
    }
}

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args) {
        Student stu1 = new Student("001", "张三", 18);
        Student stu2 = new Student("002", "李四", 19);
        Student stu3 = new Student("003", "王五", 20);

        // 通过类名访问
        System.out.println(Student.stuCount);		// 输出: 3
      
       	// 通过对象也可以访问
      	System.out.println(stu1.stuCount);		// 输出: 3
        System.out.println(stu2.stuCount);		// 输出: 3
        System.out.println(stu3.stuCount);		// 输出: 3
    }
}

在上面的代码中,我们定义了一个类,然后在类中定义了一个 stuCount 静态变量。当创建对象的时候,会调用构造方法,我们在构造方法中将 stuCount++,这样就可以记录调用构造方法的次数。

静态变量用来定义那些所有对象共享的数据。

**静态变量是属于类的,而不是属于类的实例。在类的方法中,如果没有局部变量和静态变量重名,那么可以直接使用静态变量,就像上面在构造方法中一样,如果有局部变量和静态变量重名,可以使用 类名.静态变量 来访问。 **

在类外,像上面在 Test 类中访问 Student 类中的静态变量,那么可以通过 类名.静态变量 来赋值和访问,也可以通过 对象.静态变量 来访问,但是推荐使用 类名.静态变量

7 静态方法

除了静态变量,还有静态方法。静态变量也是属于类的,而不是属于类的实例。

静态方法通过 static 关键字来修饰的方法,之前在学习方法的时候,我们定义的全是静态方法。

/**
 * 定义类
 */
class Student {
    public static int stuCount = 0;		// 定义一个静态变量,用于记录创建的对象个数
    public String sid;
    public String name;
    public int age;

    /**
     * 构造方法
     */
    public Student(String sid, String name, int age) {
        stuCount++;				// 创建对象会调用构造方法,调用一次就+1

        this.sid = sid;			// this.sid 访问的是属性,sid 是方法的形参
        this.name = name;
        this.age = age;
    }

    public void study() {
        System.out.println("我正在学习");
    }


    /**
     * 定义静态方法
     */
    public static void getStuCount() {
        System.out.println("一共创建了" + stuCount + "个学生");

        // System.out.println(name);   // 静态方法中无法访问成员变量
        // study();  // 静态方法中无法调用成员方法
    }
}

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args) {
        // 创建张三
        new Student("001", "张三", 18);
        // 创建李四
        new Student("002", "李四", 19);
        // 创建王五
        new Student("003", "王五", 20);

        Student.getStuCount();		// 输出: 一共创建了3个学生
    }
}

在静态方法不能访问成员变量和成员方法,因为静态方法是通过 类.静态方法() 调用的,不是通过对象实例来调用的,所以如果在静态方法中调用的成员变量没法确定是哪个实例的变量。但是在成员方法中是可以访问静态变量和静态方法的。


静态方法一般用来定义一些工具类,例如定义一个字符串的工具类:

public class StringUtils {
    /**
     * 判断字符串是否为空
     */
    public static boolean isEmpty(String arg) {
        // trim()方法是去掉字符串的前后空格
        return (null == arg || arg.trim().length() < 1);
    }

    /**
     * 判断字符串是否不为空
     */
    public static boolean isNotEmpty(String arg) {
        return !isEmpty(arg);
    }
    
    // ...定义其他的工具方法
}

定义完工具类,我就可以在其他的类中,通过 StringUtils.isEmpty("字符串") 来调用这个工具类中的方法了。

8 局部变量和全局变量

变量的作用域也就是在哪里可以访问到这个变量。按照作用域的不同,变量可分为 局部变量全局变量

什么是局部变量?

局部变量就是在方法中(包括方法的参数)或代码块中(例如for循环中定义的变量)定义的变量,这些变量只能在该方法中进行访问,其他方法中无法访问。

什么是全局变量?

全局变量就是类的属性,这些变量可以在多个方法中进行访问。


局部变量和全局变量除了作用域不同,还有一些地方也不同:

  • 权限修饰符:全局变量是类的属性,可以添加权限修饰符,我们目前只使用了 public,局部变量没有权限修饰符,关于权限修饰符后面再讲解;
  • 初始化:全局变量有初始化值,而局部变量在使用前,需要自己进行初始化,否则无法使用;
  • 内存中的位置:全局变量是保存在堆中的,而局部变量(非static,static是保存在虚拟机的方法区中的)是保存在栈中的。

关于全局变量的初始化值,在这里举个栗子:

/**
 * 定义类
 */
class DataClass {
    public byte byteValue;
    public short shortValue;
    public int intValue;
    public long longValue;
    public float floatValue;
    public double doubleValue;
    public boolean booleanValue;
    public char charValue;
    public String stringValue;
}

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args) {
        DataClass data = new DataClass();
        System.out.println(data.byteValue);     // 0
        System.out.println(data.shortValue);    // 0
        System.out.println(data.intValue);      // 0
        System.out.println(data.longValue);     // 0
        System.out.println(data.floatValue);    // 0.0
        System.out.println(data.doubleValue);   // 0.0
        System.out.println(data.booleanValue);  // false
        char c = 0;
        System.out.println(data.charValue == c);// true
        System.out.println(data.stringValue);   // null
    }
}

在上面的代码中,我们并没有对类的属性进行初始化,但是类中的属性会默认有初始化值。

byte、short、int、long、char默认初始化值为 0float、double 默认初始化值为 0.0boolean 默认初始化值为 false引用类型的默认初始化值为 null

9 构造方法的重载

如果一个类中,没有显式的构造方法,那么会有一个隐式的无参构造方法。

class Student {
    public String sid;
    public String name;
    public int age;
}

public class ObjectTest {
    public static void main(String[] args) {
        // 这里的Student()调用的就是默认隐式的构造方法
        Student stu = new Student();
    }
}

此时创建 Student 类对象,就是调用的隐式无参构造方法。当然,我们也可以手动写一个无参构造方法。

class Student {
    public String sid;
    public String name;
    public int age;

    public Student() {
        System.out.println("无参构造方法");
    }
}

public class ObjectTest {
    public static void main(String[] args) {
        Student stu = new Student();	// 打印:无参构造方法
    }
}

当我们手动写了显式的无参构造方法,那么就会调用这个显式的无参构造方法了。

如果我们显式的写了有参的构造方法,那么隐式的无参构造方法就没有了,所以在创建对象的时候,就必须传递参数。

举个栗子:

class Student {
    public String sid;
    public String name;
    public int age;

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

public class ObjectTest {
    public static void main(String[] args) {
        // Student stu = new Student();  // 报错,没有无参构造方法了
        Student stu = new Student("001", "ZhangSan", 18);
    }
}

当然构造方法也是可以重载的,我们可以定义多个构造方法。

class Student {
    public String sid;
    public String name;
    public int age;

    public Student() {
        System.out.println("无参构造方法");
    }

    public Student(String sid, String name) {
        System.out.println("有参构造方法: sid, name");
        this.sid = sid;
        this.name = name;
    }

    public Student(String sid, String name, int age) {
        System.out.println("有参构造方法: sid, name, age");

        this.sid = sid;
        this.name = name;
        this.age = age;
    }
}

public class ObjectTest {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student("001", "ZhangSan");
        Student stu3 = new Student("001", "ZhangSan", 18);
    }
}

执行结果:

无参构造方法
有参构造方法: sid, name
有参构造方法: sid, name, age


那么如何在一个构造方法中调用另一个构造方法呢?

使用 this([参数]) 来调用,举个栗子:

class Student {
    public String sid;
    public String name;
    public int age;

    public Student() {
        System.out.println("无参构造方法");
    }

    public Student(String sid, String name) {
        this();	// 调用无参构造方法
        System.out.println("有参构造方法: sid, name");
        this.sid = sid;
        this.name = name;
    }

    public Student(String sid, String name, int age) {
        this(sid, name);	// 调用其他的构造方法
        System.out.println("有参构造方法: sid, name, age");
        this.sid = sid;
        this.name = name;
        this.age = age;
    }
}

public class ObjectTest {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student("001", "ZhangSan");
        Student stu3 = new Student("001", "ZhangSan", 18);
    }
}

需要注意,使用 this([参数]) 调用其他的构造方法,这句代码必须放在构造方法的第一句。

执行结果:

无参构造方法
无参构造方法
有参构造方法: sid, name
无参构造方法
有参构造方法: sid, name
有参构造方法: sid, name, age

10 代码块

在类中还有代码块,代码块的主要作用也是进行一些初始化的工作。

代码块有静态代码块和非静态代码块。

静态代码块主要用于 初始化类的静态变量 或执行只需在类加载时运行一次的代码。

非静态代码块主要是对成员变量进行初始化工作。

举个栗子:

class Student {
    // 静态变量
    public static int staticValue;
    // 成员变量
    public int value;


    // 静态代码块
    static {
        staticValue = 10;
        System.out.println("执行静态代码块");
    }

    // 非静态代码块
    {
        value = 20;
        System.out.println("执行非静态代码块");
    }

    // 构造方法
    public Student() {
        System.out.println("执行构造方法");
    }
}

/**
 * 测试类
 */
public class ObjectTest {
    public static void main(String[] args) {
        new Student();
        new Student();
    }
}

执行结果:

执行静态代码块
执行非静态代码块
执行构造方法
执行非静态代码块
执行构造方法

从执行结果可以看出,静态代码块只会在类加载的时候执行一次,后面不会再执行了。静态代码块在每次创建对象的时候都会执行,而且会在构造方法之前执行。在代码块中也是可以调用类中的方法的,当然静态代码块只能调用静态方法。

静态代码块可以在需要进行一些逻辑处理后,再初始化静态变量的时候会用到,非静态代码块用的不多,一般使用构造方法就可以完成相同的功能。


需要注意,代码块和属性的显式赋值是同级的。谁写在后面,谁后生效。

举个栗子:

class Student {
    // 静态变量
    public static int staticValue = 20;

    // 静态代码块
    static {
        staticValue = 10;
    }
}

class Teacher {
    // 静态代码块
    static {
        staticValue = 10;
    }

    // 静态变量
    public static int staticValue = 20;
}

/**
 * 测试类
 */
public class ObjectTest {
    public static void main(String[] args) {
        System.out.println(Student.staticValue);    // 10
        System.out.println(Teacher.staticValue);    // 20
    }
}

上面的 Student 和 Teacher 两个类中的静态变量,分别使用了显式赋值和静态代码块赋值,可以看到它们是同级的,谁在后面谁后执行,覆盖前面的初始化值。

11 属性的初始化顺序

类中的属性,有静态变量和成员变量,我们可以不初始化,会有默认值,也可以显式的进行初始化,也可以在静态代码块中对静态变量进行初始化,也可以构造方法中进行初始化。

这么多地方可以对属性进行初始化,那么初始化顺序是怎么样的呢?

  1. 静态变量默认初始化;
  2. 静态变量显式初始化;
  3. 静态代码块初始化;
  4. 成员变量默认初始化;
  5. 成员变量显式初始化;
  6. 构造方法中初始化;

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

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

相关文章

神经网络复习--循环神经网络

文章目录 RNNLSTM神经网络GAN神经网络 RNN 有些任务人工神经网络&#xff0c;CNN解决不了&#xff0c;自然语言处理中&#xff0c;输入和输出之间不独立&#xff0c;而传统神经网络中&#xff0c;输入和输出都是相互独立的&#xff0c;因此需要一种神经网络让输出和之前的输入…

Go微服务: 接入Prometheus性能监控平台与Grafana平台

接入Prometheus 在 go-micro 生成的模板中, 我们一如既往的完成基础工作之后 进入main.go工作的代码编写&#xff0c;main.go package mainimport ("fmt""log""strconv""github.com/go-micro/plugins/v4/registry/consul"opentracing…

[更改挂载点]重新挂载硬盘

显示磁盘空间使用情况 df -hdf -h 命令的输出显示了文件系统的磁盘空间使用情况。 这里 /dev/nvme0n1p1 设备&#xff08;大小为 880GB&#xff09;已经被挂载到 /media/nvidia/SSD 目录下&#xff0c;并且使用了 304GB&#xff0c;剩余 532GB&#xff0c;使用率为 37%。这意…

Django视图Views

Views视图 HttpRequest 和HttpResponse Django中的视图主要用来接受web请求&#xff0c;并做出响应。视图的本质就是一个Python中的函数视图的响应分为两大类 1)以Json数据形式返回(JsonResponse) 2)以网页的形式返回 2.1)重定向到另一个网页 (HttpRe…

JAVA云his医院管理系统源码 SaaS模式+融合B/S版电子病历 基于云计算技术开发的云his医院管理系统

JAVA云his医院管理系统源码 SaaS模式融合B/S版电子病历 基于云计算技术开发的云his医院管理系统 定义 美国著名教授Morris.Collen于1988年曾著文为医院信息系统下了如下定义&#xff1a;利用电子计算机和通讯设备&#xff0c;为医院所属各部门提供病人诊疗信息和行政管理信息…

OFDM 802.11a的FPGA实现(十六)长训练序列:LTS(含Matlab和verilog代码)

目录 1.前言2.原理3.Matlab生成长训练序列4.硬件实现5.ModelSim仿真6.和Matlab仿真结果对比 原文链接&#xff08;相关文章合集&#xff09;&#xff1a; OFDM 802.11a的xilinx FPGA实现 1.前言 在之前已经完成了data域数据的处理&#xff0c;在构建整个802.11a OFDM数据帧的时…

QT基础 获取颜色

比如我们要获取图片上某个点的颜色&#xff0c;要怎么处理呢&#xff1f; 1.获取鼠标坐标 2.截图并将坐标代入途中获取RGB&#xff08;这里要考虑坐标不在范围&#xff09; 假如是通过mousePressEvent获取到鼠标坐标 void mousePressEvent(QMouseEvent* e) {QPoint orgPoint…

vue2 配置运行环境

vue2 配置运行环境 在 vue2 项目中配置运行环境 在项目中新建 .env.development 文件 和 .env.production 文件 .env.development NODE_ENV development //指定当前环境模式 VUE_APP_MODE development VUE_APP_BASE_URL "/dev-api".env.production NODE_ENV &q…

粒子系统技术在AI去衣应用中的创新探索

引言&#xff1a; 随着计算机视觉和人工智能技术的飞速发展&#xff0c;AI去衣技术逐渐走进公众视野。这一技术以其独特的应用前景和技术挑战引起了广泛的关注。在实现衣物去除的同时保持图像质量的关键技术之一&#xff0c;便是粒子系统技术。本文将深入探讨粒子系统技术在AI去…

文件系统,磁盘的物理存储结构和逻辑存储结构

问题导入 在计算机中不是所有的文件都是被打开的&#xff0c;只有我们要用的文件的被打开&#xff0c;大部分文件&#xff08;当前不需要访问的文件&#xff09;&#xff0c;都在磁盘中保存着。问题是没有被打开的文件是否需要管理&#xff1f; 这就好比我有十套衣服&#xff…

LBSS138LT1G 丝印J1 SOT-23 N沟道 50V/200mA 贴片MOSFET

LBSS138LT1G的应用领域广泛&#xff0c;主要因为它是一种N沟道金属氧化物半导体场效应晶体管&#xff08;MOSFET&#xff09;&#xff0c;具有低电荷、快速开关速度和高阻断特性。以下是一些典型的应用领域&#xff1a; 1. 消费电子产品&#xff1a;LBSS138LT1G常用于电视、音响…

【UE5.1 角色练习】01-使用小白人蓝图控制商城角色移动

目录 效果 步骤 一、导入资源 二、控制角色移动 三、更换角色移动动作 效果 步骤 一、导入资源 新建一个工程&#xff0c;然后在虚幻商城中将角色动画的相关资源加入工程&#xff0c;这里使用的是“动画初学者内容包”和“MCO Mocap Basics” 将我们要控制的角色添加进…

洗地机怎么挑?洗地机选购指南,2024洗地机测评选购攻略

在快节奏的生活中&#xff0c;繁琐的清洁工作往往令人头疼&#xff0c;随着洗地机的诞生&#xff0c;极大地简化了清洁的过程&#xff0c;洗地机凭借着它吸拖洗为一体的高效清洁特点&#xff0c;受到家庭和商业场所的广泛欢迎。那么&#xff0c;洗地机怎么挑&#xff0c;要注意…

什么是Zoho CRM客户关系系统管理?

以客户为中心的商业时代&#xff0c;卓越的客户体验已成为企业持续增长与成功的关键,为了在这场激烈的市场竞争中脱颖而出&#xff0c;企业需要一套强大、灵活且智能的客户关系管理系统——Zoho CRM应运而生&#xff0c;它不仅是管理客户信息的工具箱&#xff0c;更是驱动业务增…

数据结构篇3—《龙门客“栈”》

文章目录 &#x1f6a9;前言1、栈的概念2、栈的实现框架3、栈的代码实现3.1、栈的初始化和销毁3.2、入栈\出栈\返回栈顶元素\元素个数\判空3.3、栈定义注意事项 4、栈的应用实例——《括号匹配问题》 &#x1f6a9;前言 前面记录了关于顺序表和链表的数据结构&#xff0c;这一篇…

2.1.2 C++程序设计——程序基本概念

文章目录 展示大纲1、程序基本概念2、基本数据类型3、程序基本语句4、基本运算5、数学库常用函数6、结构化程序设计展示大纲 1、程序基本概念

数据结构初阶 顺序表的补充

一. 题目的要求 写出三种链表的接口函数 它们的功能分别是 1 查找数的位置 2 在pos位置插入值 3 在pos位置删除值 二. 实现pos 这个其实很简单 找到一步步遍历 找到这个数字就返回 找不到就提示用户下 这个数字不存在 int SLFind(SL* ps,SLDateType x) {assert(ps);int…

C# WinForm —— 21 RichTextBox 使用

1. 加载文件到控件中 加载文件时&#xff0c;要设置文件的路径和类型RichTextBoxStreamType&#xff0c;文件类型包含&#xff1a; RichText 0&#xff1a;富文本格式&#xff08;RTF&#xff09;流PlainText 1&#xff1a;纯文本流对象链接和嵌入&#xff08;OLE&#xff…

根据参考风格进行矢量图绘制

摘要 利用机器学习根据给定的文本描述生成图像的技术已经取得了显著的进步&#xff0c;例如CLIP图像-文本编码器模型的发布&#xff1b;然而&#xff0c;当前的方法缺乏对生成图像风格的艺术控制。我们提出了一种方法&#xff0c;用于为给定的文本描述生成指定风格的绘图&…