Java入门基础11：面向对象高级一（static、extends继承）

news2024/11/16 11:37:16

Java面向对象高级特性有以下几个：继承，多态，封装，抽象，接口，匿名内部类，静态成员，final关键字，异常处理等。

我会将它分为三章详细讲，本章主要讲静态和继承

static

static叫静态，可以修饰成员变量、成员方法。

类变量(静态成员变量)：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。

实例变量（对象变量）:无static修饰，属于每个对象的。

package itchinajie.d1_static_demo;

public class Test {
    public static void main(String[] args) {
        //目标：掌握有无static修饰成员变量的用法，特点
        //1、类变量的用法
        //类名.类变量（推荐）
        Student.name = "张三";

        //对象.类变量（不推荐）
        Student s1 = new Student();
        s1.name = "马冬梅";

        Student s2 = new Student();
        s2.name = "秋雅";

        System.out.println(s1.name);//秋雅
        System.out.println(Student.name);//秋雅

        //2、实例变量的用法，属于每个对象的变量
        //对象.实例变量
        s1.age = 23;
        s2.age = 18;
        System.out.println(s1.age);
        System.out.println(s2.age);
        //System.out.println(Student.age);
    }
}

package itchinajie.d1_static_demo;

public class Student {
    //类变量（静态修饰变量）
    static String name;
    //实例变量（对象变量）
    int age;
}

 类变量的应用场景：

在开发中，如果某个数据只需要一份，且希望能够被共享(访问、修改)，则该数据可以定义成类变量来记住。

系统启动后，要求用户类可以记住自己创建了多少个用户对象了。

package itchinajie.d1_static_demo;

public class User {
    //类变量
    public static int number;

    public User(){
        //User.number ++;
        //注意：在同一个类中，访问自己的类的类变量，才可以省略类名不写
        number++;
    }
}

package itchinajie.d1_static_demo;

public class Test2 {
    public static void main(String[] args) {
        //目标：通过案例来解释类变量的应用场景
        User u1 = new User();
        User u2 = new User();
        User u3 = new User();
        User u4 = new User();

        System.out.println(User.number);
    }
}

 类变量只需要一份，且需要时被共享（访问或修改）

实例变量是每个对象都要有一份，数据各不同（如：name、sorce、age）

static修饰成员方法

类方法（static修饰成员方法）：

类方法是指属于类本身而不是类的实例的方法。在Java中，类方法通常使用关键字`static`进行修饰，可以直接通过类名来调用，而不需要实例化该类的对象。类方法被称为静态方法，因为它们在内存中只有一份副本，而不是每个实例都有自己的副本。类方法通常用于执行与整个类相关的操作，例如工具类中的常用方法或者程序的入口方法main。

实例方法（无static修饰成员方法）：

实例方法是指属于类的实例（对象）而不是类本身的方法。在Java中，实例方法不使用`static`关键字修饰，必须通过类的实例来调用。每个类的实例都有自己的实例方法，它们可以访问和操作实例的属性，并且可以调用其他实例方法。实例方法通常用于描述对象的行为和操作，并且会随着每个对象的创建而存在不同的副本。

package itchinajie.d2_static_method;

public class Student {
    double score;
    //类方法
    public static void printHelloWorld(){
        System.out.println("Hello World");
        System.out.println("Hello World");
    }
    //实例方法（对象方法）
    public void printPass(){
        System.out.println("成绩：" +
                (score >= 60 ? "及格" : "不及格"));
    }
}


package itchinajie.d2_static_method;

public class Test {
    public static void main(String[] args) {
        //目标：掌握用static修饰方法的用法
        //1、类方法的用法
        //类名.类方法（推荐）
        Student.printHelloWorld();

        //对象.类方法（不推荐）
        Student s = new Student();
        s.printHelloWorld();

        //2、实例方法的用法
        //对象.实例方法
        s.printPass();
        //Student.printPass();//报错
    }
}

 在这里不得不提一嘴，main方法，我们之前常用的main方法能直接执行其他方法，到底为啥呢？

main方法能直接执行是因为在Java虚拟机(JVM)中，程序在运行时会自动查找并调用名为main的方法作为程序的入口点。当你运行一个Java程序时，JVM会寻找包含main方法的类并执行该方法。因此，main方法就成为了程序的入口，用户可以通过调用这个方法来启动整个程序的执行。

main方法是Java程序的入口方法，是程序执行的起点。在Java程序中，main方法是一个特殊的静态方法，格式为： ```java public static void main(String[] args) ```

类方法和实例方法的区别：

Java中的类方法和实例方法是面向对象编程中的两种基本方法类型，它们在方法和对象的关系、调用方式、访问权限等方面存在差异。

1. **定义和归属**：

- **类方法**（静态方法）：使用`static`关键字修饰的方法。类方法属于类本身，而不是类的某个对象。即使没有创建类的对象，类方法也可以直接通过类名调用。

- **实例方法**：没有使用`static`关键字修饰的方法。实例方法属于类的对象，只能通过类的对象来调用。

2. **调用方式**：

- **类方法**：可以直接通过类名调用，也可以通过类的对象调用。

- **实例方法**：必须通过类的对象来调用。

3. **访问权限**：

- **类方法**：由于类方法属于类本身，因此它们可以访问类的静态成员变量和方法。

- **实例方法**：可以访问类的实例成员变量和方法，也可以访问类的静态成员变量和方法。

4. **对实例变量和类变量的访问**：

- **类方法**：由于类方法不属于任何对象，它们不能直接访问实例变量。但可以访问类变量（变量）。

- **实例方法**：可以访问类的实例变量和类变量。

5. **使用`super`和`this`关键字**：

- **类方法**：由于类方法不依赖于类的任何对象，所以它们不能使用`super`和`this`关键字，因为这些关键字分别用于引用父类和当前类的对象。

- **实例方法**：可以使用`super`和`this`关键字。

6. **内存分配和多态性**：

- **类方法**：类的所有对象共享类方法的方法体，因此类方法在程序运行期间只被加载一次，并且其方法体不会因为创建多个对象而重复执行。

- **实例方法**：每个对象都有自己的方法体副本，因此实例方法可以独立于其他对象进行操作。 这些区别体现了Java在方法设计上的灵活性和面向对象编程的原则。在实际开发中，应根据需要选择使用类方法还是实例方法。

static的注意事项 

package itchinajie.d4_static_attention;

public class Student {
    static String schoolName;//类变量
    double score;//实例变量

    //1、类方法中可以直接访问类的成员，不可以直接访问实例成员
    public static void printHelloWorld(){
        //注意：同一个类中，访问类成员，可以直接省略类名不写
        schoolName = "黑马";
        printHelloWorld2();

        //printPass();//报错
        // System.out.println(score);//报错
    }
    //类方法
    public static void printHelloWorld2(){

    }
    //2、实例方法中既可以访问类成员也可以直接访问实例成员
    //实例方法
    //3、实例方法中可以出现this关键字，类方法中不能出现
    public void printPass(){
        schoolName = "黑马";
        printHelloWorld2();

        System.out.println(score);
        printPass();

        System.out.println(this);
    }
    //实例方法
    public void printPass2(){

    }
}

1、类方法中可以直接访问类的成员，不可以直接访问实例成员。

2、实例方法中既可以访问类成员也可以直接访问实例成员。

3、实例方法中可以出现this关键字，类方法中不可以出现this关键字。

static的应用知识：代码块(源码用的，认识即可)

package itchinajie.d5_block;

public class Student {
    static int number = 80;
    static String schoolName = "黑马";
    //静态代码块
    static{
        System.out.println("静态代码块执行了~~");
        //schoolName = "黑马";
    }
    int age = 18;
    //实例代码块
    {
        System.out.println("实例代码块执行了~~");
        //age = 18;
        System.out.println("有人创建了对象" + this);
    }

    public Student(){
        System.out.println("无参数构造器执行了~~");
    }

    public Student(String name){
        System.out.println("有参数构造器执行了~~");
    }
}

package itchinajie.d5_block;

public class Test {
    public static void main(String[] args) {
        //目标：认识两种代码块，了解他们的特点和基本作用(认识就行)
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);

        System.out.println(Student.schoolName);//黑马

        System.out.println("-----------------------------------");
        Student s1 = new Student();
        Student s2 = new Student("张三");
        System.out.println(s1.age);
        System.out.println(s2.age);
    }
}

static的应用知识：单例设计模式

什么是设计模式？

1、一个问题通常有种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。

2、设计模式有20多种，对应20多种软件开发中会遇到的问题。

饿汉式单例设计模式

把类的构造器私有；定义一个类变量存储类的一个对象；提供一个类方法返回对象。

package itchinajie.d6_singleIstance;

public class A {
    //2、定义一个类变量记住类的一个对象
    private static A a = new A();

    //1、必须私有类的构造器
    private A(){
        System.out.println("牛逼");
    }
    //3、定义一个类方法返回类的对象
    public static A getObject(){
        return a;
    }

}

 饿汉式单例设计模式的一个特点就是在获取类的对象时，对象已经创建好了。

package itchinajie.d6_singleIstance;

public class Test {
    public static void main(String[] args) {
        //目标：掌握饿汉式单例设计模式的写法
        A a1 = A.getObject();
        A a2 = A.getObject();
        System.out.println(a1);
        System.out.println(a2);
    }
}

饿汉式单例设计模式的一个特点就是在获取类的对象时，对象已经创建好了。

他适合做任务管理器对象、获取运行时对象。在这些业务场景下，使用单例模式，可以避免浪费内存。

而懒汉式单利设计模式是拿对象时，才开始创建对象。

懒汉式单利设计模式

package itchinajie.d6_singleIstance;

public class B {
    //2、定义一个类变量，用于存储这个类的一个对象
    private static B b;
    //1、把类的构造器私有
    private B(){
    }
    //3、定义一个类方法，这个方法要保证第一次调用时才创建一个对象，后面调用时都会用这同一个对象返回
    public static B getInstance(){
        if (b == null) {
            System.out.println("第一次创建对象~");
            b = new B();
        }
        return b;
    }
}


package itchinajie.d6_singleIstance;

public class Test2 {
    /*掌握懒汉式单例的写法*/
    public static void main(String[] args) {
        B b1 = B.getInstance();//第一次创建对象
        B b2 = B.getInstance();
        System.out.println(b1 == b2);
    }
}

继承

继承：Java中提供了一个关键字extends,用这个关键字，可以让一个类和另一个类建立起父子关系。

继承的特点：子类能继承父类的非私有成员(成员变量、成员方法)

继承后对象的创建：子类的对象是由子类、父类共同完成的。

class 子类 extends 父类 {}

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

子类又被称为派生类； 父类又被称为超类（Super Class）。

关于继承的详细内容请转一下文章：
java继承实现原理，快来get！_extends inheritance-CSDN博客

继承相关注意事项

权限修饰符

就是是用来限制类中的成员(成员变量、成员方法、构造器、代码块。)能够被访问的范围。

package itchinajie.d9_modifer;

public class Demo {
    public static void main(String[] args) {
        //目标：掌握不同权限修饰符的作用
        Fu f = new Fu();
        //f.privateMethod();
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

package itchinajie.d9_modifer;

public class Fu {
    //1、私有：只能在本类中访问
    private void privateMethod(){
        System.out.println("==private==");
    }

    //2、缺省：本类，同一个包下的类
    void method(){
        System.out.println("==缺省==");
    }

    //3、protected：本类，同一个包下的类，任意包下的子类
    protected void protectedMethod(){
        System.out.println("==protected==");
    }

    //4、public：本类，同一个包下的类，任意包下的子类，在任意包下的任意类
    public void publicMethod(){
        System.out.println("==public==");
    }
    public void test(){
        privateMethod();
        method();
        protectedMethod();
        publicMethod();
    }
}

单继承、Object类

Java是单继承的，Java中的类不支持多继承，但是支持多层继承。

一图便知为何不支持多继承:

object类是java所有类的祖宗类。我们写的任何一个类，其实都是object的子类或子孙类。

我们先创建3个类，最后让他们互相继承试验一下：

package itchinajie.d11_extends_feature;

public class Test {
    public static void main(String[] args) {
        //目标：掌握继承的两个注意事项
        //1、Java是单继承的：一个类只能继承一个父类，Java中的类不支持多继承，但支持多层继承
        //2、Object类是Java类中所有类的祖宗
    }
    class A{}//extends Object{}
    class B extends A{}
    //class C extends B , A{}//报错
    class D extends B{}
}

方法重写

什么是方法重写？

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、
参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意：重写后，方法的访问，Java会遵循就近原则。

直接上案例感受：

package itchinajie.d12_extends_override;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //目标：认识方法重写，掌握方法重写的常见应用场景
        B b = new B();
        b.print1();
        b.print2(2,3);

        System.out.println("--------------------");
        Student s = new Student("播妞",19);
        System.out.println(s.toString());//重写方法后 可使用
        System.out.println(s);

        ArrayList list = new ArrayList();
        list.add("Java");
        System.out.println(list);
    }
}

package itchinajie.d12_extends_override;

public class A {
    public void print1(){
        System.out.println("111");
    }
    public void print2(int a,int b){
        System.out.println("1111111");
    }
}

package itchinajie.d12_extends_override;

public class B extends A{
    //方法重写
    @Override//安全，可读性好
    public void print1(){
        System.out.println("666");
    }
//申明不变，重新实现
    //方法重写
    @Override
    public void print2(int a,int b){
        System.out.println("6666666");
    }
}

package itchinajie.d12_extends_override;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

 方法重写的其它注意事项：
重写小技巧：

1、使用Override注解，他可以指定java编译器，检查我们方法重写的格式是否正确，代码可读性也会更好
2、子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限(public>protected>缺省)。
3、重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
私有方法、静态方法不能被重写，如果重写会报错的。

子类中访问其他成员的特点

1、在子类方法中访问其他成员(成员变量、成员方法)，是依照就近原则的。

先子类局部范围找。
然后子类成员范围找。
然后父类成员范围找，如果父类范围还没有找到则报错。

2、如果子父类中，出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类的怎么办？

可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

package itchinajie.d13_extends_visit;

public class Test {
    public static void main(String[] args) {
        //目标：掌握子类中访问其他成员的特点，就近原则
        Z z = new Z();
        z.showName();
    }
}


package itchinajie.d13_extends_visit;

public class F {
    String name = "父类名字";

    public void print(){
        System.out.println("==父类的print方法执行==");
    }
}

package itchinajie.d13_extends_visit;

public class Z extends F{
    String name = "子类名称";

    public void showName(){
        String name = "局部名称";
        System.out.println("name");//局部名称
        System.out.println(this.name);//子类成员变量
        System.out.println(super.name);//父类成员变量
    }

}

子类构造器的特点

子类的全部构造器，都会先调用父类的构造器，再执行自己。

子类构造器为什么要调用父类的构造器，有啥应用场景？

子类构造器可以通过调用父类构造器，把对象中包含父类这部分的数据先初始化赋值，再回来把对象里包含子类这部分的数据也进行初始化赋值。

package itchinajie.d14_extends_constructor;

public class Test2 {
    public static void main(String[] args) {
        //目标：搞清楚子类构造器为什么要调用父类的构造器，有啥应用场景
        Teacher t = new Teacher("张三",36,"Java");
        System.out.println(t.getName());
        System.out.println(t.getAge());
        System.out.println(t.getSkill());
    }
}
class Teacher extends People{
    private String skill;
    public Teacher(String name,int age,String skill){
        super(name,age);
        this.skill = skill;
    }
    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}

class People{
    private String name;
    private int age;

    public People() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

补充：this(…)调用兄弟构造器

任意类的构造器中，是可以通过this(.....)去调用该类的其他构造器的。

this(.…)和super(.…)使用时的注意事项：

this(…)、super((.…)都只能放在构造器的第一行，因此，有了this(.…)就不能写super(.…)了，反之亦然。

(本章图片均来自于黑马程序员视频)

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

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

相关文章

Java——方法详细介绍

Java——方法详细介绍

一、方法调用机制 1、方法调用机制详细介绍 下面对方法调用在内存中的情况进行分析，以下面的代码为例： public class Test {public static void main(String[] args) {Person person new Person();person.name "张三";person.age 18;int…
阅读更多...
GUI编程02-布局管理器

GUI编程02-布局管理器

流式布局 FlowLayout 东西南北中 BorderLayout 表格布局 GridLayout 流式布局 package YMP.GUI; ​ import java.awt.*; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; ​ public class TestFlowLayout {public static void main(String[] args…
阅读更多...
oracle 12.1 rac to rac adg（maa）搭建保姆级教程

oracle 12.1 rac to rac adg（maa）搭建保姆级教程

目录 资源配置 一、主库集群操作 1.主库增加standbylog 2.主库开启force logging及归档 3.主库配置参数 4.生成参数文件并将参数文件、密码文件拷贝至备库 4.1参数文件处理 4.2密码文件处理 二、备库操作 1.备库修改参数文件 1.1创建adump目录并在参数文件修改&#…
阅读更多...
Mysql基础 - 事务

Mysql基础 - 事务

Mysql基础 - 事务 文章目录 Mysql基础 - 事务1 事务简介2 事务操作2.1 控制事务一2.2 控制事务二 3 事务四大特性4 并发事务问题5 事务隔离级别 1 事务简介 事务是一组操作的集合，他是一个不可分割的工作单位，事务会把所有操作作为一个整体一起向系统提…
阅读更多...
Word中插入Mathtype右编号，调整公式与编号的位置

Word中插入Mathtype右编号，调整公式与编号的位置

当你已经将mathtype内置于word后，可以使用右编号快速插入公式 但是往往会出现公式和编号出现的位置或之间的距离不合适 比如我在双栏下插入公式，会发现插入的公式与编号是适用于单栏的 解决办法： 开始->样式->MTDisplayLquation -&g…
阅读更多...
力扣刷题--728. 自除数【简单】

力扣刷题--728. 自除数【简单】

题目描述 自除数 是指可以被它包含的每一位数整除的数。 例如，128 是一个 自除数 ，因为 128 % 1 0，128 % 2 0，128 % 8 0。 自除数 不允许包含 0 。 给定两个整数 left 和 right ，返回一个列表，列表的…
阅读更多...
MySQL之查询性能优化(七)

MySQL之查询性能优化(七)

查询性能优化 排序优化 无论如何排序都是一个成本很高的操作，所以从性能角度考虑，应尽可能避免排序或者尽可能避免对大量数据进行排序。前面已经提到了，当不能使用索引生成排序结果的时候，MySQL需要自己进行排序，如果…
阅读更多...
02-JAVA面向对象编程

02-JAVA面向对象编程

一、面向对象编程 1、面向过程编程思想（Process Oritented Programming） 将实现一个功能的一组指令组合在一起，成为一个函数。这个函数就能实现这一个功能，是对功能实现的一种抽象。通过这种抽象方式，将代码实现复用。…
阅读更多...
Jmeter分布式、测试报告、并发数计算、插件添加方式、常用图表

Jmeter分布式、测试报告、并发数计算、插件添加方式、常用图表

Jmeter分布式 应用场景 当单个测试机无法模拟用户要求的业务场景时，可以使用多台测试机进行模拟，就是Jmeter的分布 式测试。 Jmeter分布式执行原理 Jmeter分布测试时，选择其中一台作为控制机（Controller）&#xff0c…
阅读更多...
Python框架scrapy有什么天赋异禀

Python框架scrapy有什么天赋异禀

Scrapy框架与一般的爬虫代码之间有几个显著的区别，这些差异主要体现在设计模式、代码结构、执行效率以及可扩展性等方面。下面是一些关键的不同点： 结构化与模块化： Scrapy：提供了高度结构化的框架，包括定义好的Spider…
阅读更多...
【InternLM实战营第二期笔记】07：OpenCompass ：是骡子是马，拉出来溜溜

【InternLM实战营第二期笔记】07：OpenCompass ：是骡子是马，拉出来溜溜

文章目录 课程实操 课程 评测的意义是什么呢？我最近也在想。看到这节开头的内容后忽然有个顿悟：如果大模型最终也会变成一种基础工具（类比软件），稳定或可预期的效果需要先于用户感知构建出来，评测 case 就…
阅读更多...
jquery.datetimepicker无法添加清除按钮的问题

jquery.datetimepicker无法添加清除按钮的问题

项目场景： 自从决定用现有新技术实现CRM老项目起，就开始了我的折腾之路，最近一直在折腾前端页面，不像后端Java，写的有问题运行会报错，大多数报错一搜就能找到解决方案，前端这个倒好&#xff0c…
阅读更多...
《TCP/IP网络编程》（第十四章）多播与广播

《TCP/IP网络编程》（第十四章）多播与广播

当需要向多个用户发送多媒体信息时，如果使用TCP套接字，则需要维护与用户数量相等的套接字；如果使用之前学习的UDP，传输次数也需要和用户数量相同。 所以为了解决这些问题，可以采用多播和广播技术，这样只需要…
阅读更多...
storage存储模块-vuex持久化处理

storage存储模块-vuex持久化处理

1：存储登录用户信息到vuex中 在store文件夹下面，创建modules文件夹在文件夹下创建user.js文件 user.js文件 const state {userInfo: {userId: ,token: } } const mutations {setUserInfo (state, obj) {console.info(obj)state.userInfo.userId obj…
阅读更多...
字符串常量简单介绍

字符串常量简单介绍

C/C内存四区介绍 如前文所示，字符串常量存储在静态存储区的字符串常量区，这样做的好处是 当程序使用到多个相同的字符串常量时，实际上都是使用的同一份，这样就可以减小程序的体积。注意字符串常量是只读的不能被修改。 如图所示&…
阅读更多...
通用信息提取数据预处理

通用信息提取数据预处理

train_data./datasets/duuie output_folder./datasets/duuie_pre ignore_datasets["DUEE", "DUEE_FIN_LITE"] schema_folder./datasets/seen_schema # 对CCKS2022 竞赛数据进行预处理 import shutil # shutil.copytree(train_data,output_folder) impor…
阅读更多...
「网络原理」三次握手四次挥手

「网络原理」三次握手四次挥手

🎇个人主页：Ice_Sugar_7 🎇所属专栏：计网 🎇欢迎点赞收藏加关注哦！ 三次握手&四次挥手 🍉连接管理🍌三次握手🍌意义🍌四次挥手🍌TCP 状态转换…
阅读更多...
电路防护-贴片陶瓷气体放电管

电路防护-贴片陶瓷气体放电管

贴片陶瓷气体放电管 GDT工作原理GDT主要特性参数典型电路压敏电阻与 TVS 管的区别 GDT工作原理 陶瓷气体放电管是一种电子器件，其工作原理基于气体放电现象。这种管子的内部填充了一种特定的气体，通常是氖气或氩气。当管子两端施加足够的电压时&#xf…
阅读更多...
vue3-使用富文本编辑器-wangEditor-文章发表1

vue3-使用富文本编辑器-wangEditor-文章发表1

最近在搞项目:我们组内几位成员正在搞一个网站搭建,以后更新会比较缓慢 引言:如果要网站要用的富文本编辑器的话,这边推荐用wangEditor 官网地址传送 : wangEditorhttps://www.wangeditor.com/ 我现在还在扩展我的写文章用的富文本编辑器 现在我将简单介绍一下其基本使用方…
阅读更多...
Python的return和yield，哪个是你的菜？

Python的return和yield，哪个是你的菜？

目录 1、return基础介绍 📚 1.1 return用途：数据返回 1.2 return执行：函数终止 1.3 return深入：无返回值情况 2、yield核心概念 🍇 2.1 yield与迭代器 2.2 生成器函数构建 2.3 yield的暂停与续行特性 3、retur…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023