面向对象1

最新推荐文章于 2024-06-12 11:59:04 发布
最新推荐文章于 2024-06-12 11:59:04 发布
阅读量60 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51539416/article/details/120402643
版权

面向对象1

1.Java方法（函数）

概念

方法也叫函数，其实就是具有一定特殊功能的一段代码，将需要的在多个位置重复使用的一组代码，定义在方法内部。

意义：

1.避免重复的代码 2.增强了程序的扩展性能。

定义方法

用法：方法的定义（声明）

	public static void main(String[] args)

语法格式：

    [修饰符1，修饰符2....] 返回值/void 方法名(参数列表){
		......
		return
    }

示例：

public class Demo1_method {
     /*
     [修饰符1，修饰符2....] 返回值/void 方法名(参数列表){
		......
        return
     }
    */
    //定义方法
    //1.定义没有返回值的方法
    //方法名：标识符，尽量见名知意,驼峰命名
    public static void getSum() {
        System.out.println("你好");
        int he = 0;
        for (int i = 0;i<=15;i++){
            he += i;
        }
        System.out.println(he);
    }

    //2.定义有返回值的方法
    public static int getSum2(){
        int he = 0;
        for (int i = 0;i<=15;i++){
            he += i;
        }
        return he;
    }

    //3.定义有返回值有参数的方法
    public static int getSum3(int num){
        int he = 0;
        for (int i = 0;i<=num;i++){
            he += i;
        }
        return he; //1.结束方法的执行。2.将返回值返回给方法的调用处
    }

    public static void main(String[] args) {
        //定义:是具有一段特殊功能的代码
        //求：1—10之间的和
        int sum = 0;
        for(int i=1;i<=10;i++){
           sum += i;
        }
        System.out.println("1-10之间的和："+ sum);
        System.out.println("hello,world!");
        System.out.println("hello,world!!!");
        //方法的调用
        //1.没有返回值的方法： 方法名(); 注意：在同一个类中调用它的静态方法可以直接调用静态方法
        getSum();
        //注意：如果调用的是其他类中的静态方法 必须是: 类名.静态方法();
        Demo1_method.getSum();
        System.out.println("-------------");
        //2.有返回值的方法： 数据类型 变量 = 方法名();
        int result = getSum2();
        System.out.println("有返回值的方法:"+result);
        //3.有返回值有参数的方法的调用：
        int result2 = getSum3(3);
        int result3 = getSum3(4);
        System.out.println("1到3的和："+ result2);
        System.out.println("1到4的和："+ result3);
    }
}

调用方法

方法的调用(如果一个方法只有定义，那么方法中代码并没有被执行，只是被调用了才会执行方法，只有被调用了才会执行方法中的代码)

通过方法的名字进行调用。

static的方法 ：静态方法
	类名.方法名();  //本类中类名可以省略。
非static的方法 ：非静态方法
	创建该类的对象，通过对象调用方法。
	类名 对象名 = new 类名();
	对象名.方法名();

示例：

public class Demo2_method {

    public static  void print1(){
       for(int i = 0;i < 5;i++){
           System.out.println("hello,world!"+i);
       }
    }

    public void print2(){
        for(int i = 0;i < 6;i++){
            System.out.println("hello,world!"+i);
        }
    }
    public static void main(String[] args) {
        //static方法的调用：直接调用方法名
        print1();
        //如果调用其它类的static方法，需要: 类名.方法名();
        Demo2_method.print2();
        System.out.println("----------------");
        //非static方法调用：1.先创建对象， 2.对象名.方法();
        Demo2_method demo2_method = new Demo2_method();
        demo2_method.print2();

    }
}

public class Demo5_method {
    /**
     * 方法的调用
     */
    public static void test1(){
        System.out.println("test1--------------------");
    }
    public static void test2(){
        test1();
        System.out.println("test2------------------");
    }
    public static void test3(){
        test1();
        System.out.println("test3-----------");
    }
    public static void main(String[] args) {
        test1();
        System.out.println("-----------");
        test2();
        System.out.println("-----------");
        test3();
    }
}

方法返回值

如果一个方法调用之后，需要返回给调用处结果，那么表示这个方法有返回值，在方法中需要使用return语句把结果返回给调用出。

//方法定义
public static 返回值类型 方法名(){
	//......
	return 结果;
}

//方法调用处
变量 = 方法名(); //变量 = 结果

如果一个方法，没有返回值，那么写void即可。

return语句：

​ A：把方法中的返回值，返回给方法的调用处；

​ B：同时结束了这个方法的执行。

public class Demo3_return {
    //如果声明了有返回值就必须使用return
    public static int getSum(){
        return 3;
    }
    public static void main(String[] args) {
        int sum =  getSum();
        System.out.println(sum);
    }
}

注意点：

​ 1.如果一个方法声明了有返回值(非void)，那么方法中一定要使用return语句返回结果。

​ 2.定义方法的时候，声明返回值的类型，一定要和return后实际上返回的数值类型一致。

​ 3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行那个分支，都要有return可以被执行到。

​ 4.如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执行。

public class Demo4_return {
    //return要注意的点
    /**
     * 1.如果声明了有返回值，那么必须声明有return
     * @return
     */
    public static double getNum(){
        return 5; //兼容的数据类型，会发生隐式类型转换
    }

    /**
     * 2.定义方法的时候，声明的返回值类型，一定要和return后实际上返回值类型一致
     * @return
     */
    public static long getNum2(){
        byte b = 34; //声明一个byte类型的变量
        return b;
    }

    /**
     * 3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行那个分支，都要有return可以被执行到。
     * @return
     */
    public static int getNum3(){
        int num = 45;
        if(num > 0){
            return num;
        }else{
            System.out.println("num:"+num);
            return 0;
        }
    }

    /**
     * 4.如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执行。
     */
    public static void getNum4(){
        int a = 12;
        if (a > 10){ //如果符合条件，那么就会进入分支结构，然后执行return,结束方法的执行
            return;
        }
        System.out.println("hello,a:"+a);
    }

    public static void main(String[] args) {
        double num = getNum();
        System.out.println(num);
        long num2 = getNum2();
        System.out.println(num2);
        int num3 = getNum3();
        System.out.println(num3);
        getNum4();
    }
}

方法参数

一个方法中，有些数据的数值不确定，我们定义为参数，由掉用处调用方法的时候，传入具体的数据。

形式参数：形参

定义方式：声明的参数，用于接收调用处传来的数据。

实际参数：实参 调用方法时，实际赋值给形参的数据。

示例：

public class Demo6_method_param {
    /**
     * 方法的参数（param）
     */
    //打印一个直角三角形
    public static void printShape(){ //无参数
        for(int i = 1; i <= 5; i++){
            for(int j = 1; j <=i; j++){
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }

    //打印一个直角三角形
    public static void printShape(int n){ //有参数
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <=i; j++){
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }

    public static void main(String[] args) {
        printShape();
        printShape(10); //实参形参要一一对应，参数的个数，类型，顺序都要一一对应
    }
}

实参一定要严格匹配形参，一一对应，包括顺序，个数，类型。

方法分类：

​ 有返回值：

​ 有参有返回值：public static 返回值类型 方法名(形参列表){}

​ 无参有返回值：public static 返回值类型 方法名(){}

​ 无返回值：

​ 有参无返回值：public static void 方法名(形参列表){}

​ 无参无返回值：public static void 方法名()

方法重载

概念：一个方法的多种形式。

同一个类中

方法名相同

参数列表必须不同(顺序，个数，类型)

与static，返回值，其他的修饰符。。。这些无关

示例：

public class Demo7_overload {
    // 方法的重载：在同一个类中，方法名相同，参数列表不同（个数，顺序，类型）
    public static int getSum(int a,int b){
        return a+b;
    }

    public static int getSum(int a,int b, int c){
        return a+b+c;
    }

    public static double getSum(double a,double b){
        return a+b;
    }

    public static void main(String[] args) {
        int getSum1 = getSum(3,5);
        System.out.println("getSum1:"+getSum1);
        double getSum2 = getSum(3.1,4.4);
        System.out.println("getSum2:"+getSum2);
        int getSum3 = getSum(1,2,3);
        System.out.println("getSum3:"+getSum3);
    }
}

递归

方法中调用方法本身，就叫做递归方法。

递归方法一定要有出口的，逐层的像出口靠近。

示例：

public class Demo8_recursion {
    //递归
    //没有返回值的递归
    public static void test1(int n){
        System.out.println("test1----------"+ n);
        if(n==1){
            return; //方法的出口
        }
        test1(n-1); //递归自己调用自己 但是 递归一定要有出口。
    }

    //有返回值的递归 （递归方式求1-5的和）
    public static int getSum(int n){
       if(n==1){
           return 1; //方法的出口
       }
        return getSum(n-1)+n;
    }

    public static void main(String[] args) {
        test1(5);
        //调用递归的方式来求1-5的和
        int sum = getSum(5);
        System.out.println(sum);
    }
}

2.封装

面向对象思想概述

面向对象编程（OOP） 是一种编程思想

面向过程：关注过程。 面向对象：关注的是对象

类和对象

什么是类：

类：是一组相关属性和行为得到集合，可以看成是一类事务的模板，现实生活中的，描述一类事物。

属性：该事物的状态信息。

行为：就是该事物能干什么。

什么是对象：

对象：一类事物的一个实例：一只小猫

举例：一只小猫

属性：Tom，5kg，2years，yellow。行为：喵喵叫。

类和对象的关系：

​ 类是对一类事物的描述，是抽象的。

​ 对象是一类事物的实例，是具体的。

​ 类是对象的模板，对象是类的实体。

类的定义

构建一个类：

[修饰符] class 类名{
	//1.属性字段：Field
	成员变量
	//2.成员方法：Method
	行为功能
	//3.构造方法：Contructor
}

示例：

public class Person {

    //属性，成员变量
    public int age; //姓名
    public String name; //年龄
    //...

    //行为，成员方法
    public void eat(){
        //局部变量
        int age = 20;
        System.out.println("吃饭。。。");
    }

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

创建一个对象

类名 对象 = new 类名();

使用对象访问类中的成员：

对象名.成员变量;
对象名.成员方法();

示例：

public class PersonTest {
    public static void main(String[] args) {
        //创建对象
        //类名 对象名 = new 类名();
        Person person = new Person();
        //访问成员变量成员方法
        //设值
        person.age = 23;
        person.name = "张三";
        //取值
        System.out.println("person对象的年龄:"+person.age);
        System.out.println("person对象的姓名:"+person.name);
		//成员方法的调用
        person.eat();
        person.sleep();
    }
}

类中成员变量，和局部变量不同，有默认值。

基本类型：

int，byte，short，long，float，double默认值都是0。

char 的默认值是“空字符”，也就是"\u0000"，数值为0；

boolean默认值false

引用类型：默认值都是null，空。

构造函数

构造方法是一种特殊的方法：

1.定义的语法结构不同：

[访问修饰权限] 方法名(参数列表){

}
修饰符：访问权限修饰符
没有返回值类型，也不写void
方法名必须要和类名一致
参数：
	没有参数：无参构造
	有参数列表：有参构造

2.调用不同：

1.通过new关键字调用
2.new 构造方法();

3.作用不同：专门用于创建对象的

注意点：如果一个类中，没有写构造方法，那么当创建对象的时候，编译器会自动添加一个无参的构造方法，但是类中如果写了构造方法，那么编译器将不再自动添加无参了。

示例：

public class Person {
    //属性，成员变量
    public int age; //姓名
    public String name; //年龄
    //...
    //行为，成员方法
    public void eat(){
        //局部变量
        int age = 20;
        System.out.println("吃饭。。。");
    }

    //行为，成员方法
    public void sleep(){
        System.out.println("睡觉。。。");
    }

    /*
      [访问修饰权限] 方法名(参数列表){

      }
    */
    public Person(){ //默认的无参构造方法
        System.out.println("这是无参构造方法");
    }

    //在创建对象的同时可以直接给成员变量赋值
    public Person(String n,int a){ //有参构造方法
        System.out.println("这个是有参构造方法");
        name = n;
        age = a;
    }
}

public class PersonTest {
    public static void main(String[] args) {
        //创建对象
        //类名 对象名 = new 类名();
        Person person = new Person(); //创建person对象走无参构造方法
        //访问成员变量成员方法
        //设值
        person.age = 23;
        person.name = "张三";
        //取值
        System.out.println("person对象的年龄:"+person.age);
        System.out.println("person对象的姓名:"+person.name);
        //成员方法的调用
        person.eat();
        person.sleep();

        System.out.println("---------");
        Person person2 = new Person("李四",45); //创建person2对象走有参构造方法
        System.out.println("person2对象的名字:"+person2.name);
        System.out.println("person2对象的年龄:"+person2.age);
    }
}

打印结果：
这是无参构造方法
person对象的年龄:23
person对象的姓名:张三
吃饭。。。
睡觉。。。
---------
这个是有参构造方法
person2对象的名字:李四
person2对象的年龄:45

this关键字

this关键字：代表所在类的当前对象的引用，即对象自己的引用

方法被那个对象调用，方法中的this就代表那个对象，即谁在调用，this就代表谁

指代本类的对象，可以访问本类的属性和方法

用途1：当局部变量和成员变量命名冲突的时候，通过this来区分。

this.成员变量

示例：

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

用途2：访问本类的属性和方法。

this.属性；
this.方法();

习惯上直接省略this，直接用属性和方法。

public void print(){
	System.out.println("名字："+ this.name,"性别:"+sex,"年龄："+age);
}
public void eat(){
    this.print();
}

指代构造方法：this();

如果存在多个构造方法，那么this指代的构造方法要靠参数来区分：顺序，个数，类型。

**注意：**this指代构造函数只能放在第一句。

示例：

//默认的无参构造方法
public Person(){
	System.out.println("这是默认的构造方法！");
}
//有参的构造方法
public Person(){
	this(); //可以调用无参的构造方法
	this.name = name;
	this.age = age;
}

public Person(String name,int age,String sex){
    this(name,age); //有参的构造方法
//    System.out.println(name);
//    System.out.println(age);
//    System.out.println(sex);
//    this.name = name;
//    this.age = age;
    this.sex = sex;
    
}

面向对象三大特性之封装

面向对象有三个特性：封装，继承，多态

封装性：尽可能隐藏对象的内部实现细节。控制对象的修改以及访问的权限。

1.隐藏了实现的细节；

2.提高了代码的复用性

3.提高了安全性，保护了细节，保护数据的安全。

封装步骤：

在类中，属性的数值不安全，所以要将属性进行封装。

1.使用private修饰符来修饰属性。限于本类中访问。

2.因为对象对属性的操作：赋值和取值。

​ 类中提供两个方法，分别用于给属性赋值和取值。

​ 赋值方法setter：setXXX():比如setAge()，setName()

​ 取值方法getter：getXXX():比如getAge()，getName()

访问修饰符4个
public：公共的
private：私有的，属性，方法 只能在本类中使用

示例：

public class Student { //封装
    //第一步：用访问修饰符修饰成员变量，限于本类访问
    //三个成员变量
    private String stuNo;
    private int age;
    private char sex;

    //第二步：提供设值取值相应的方法
    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //可以在set方法中设置一些条件规则
        if(age<0){
            System.out.println("要设置的参数不合理，请重新赋值！");
            return;
        }
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

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

    //成员方法，行为
    public void study(){
        System.out.println("学习------------");
    }

    public void play(){
        System.out.println("玩游戏------------");
    }

    //打印自己本身的属性
    public void print(){
        System.out.println("stuNo:"+stuNo);
        System.out.println("age:"+age);
        System.out.println("sex:"+sex);
        System.out.println("hahahah");
    }

}

public class StudentTest {
    public static void main(String[] args) {
        //1.创建对象
        Student student = new Student();
        student.setStuNo("001");
        student.setAge(18);
        student.setSex('男');
        student.print();

        System.out.println("------------------------");
        Student student2 = new Student();
        student2.setStuNo("001");
        student2.setAge(18);
        student2.setSex('女');

        student2.print();
    }

}
止由Ba
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面向对象程序设计概念
kangjialong_的博客
11-02 2295
一. 程序设计范型   面向对象程序设计（object-oriented programming，OOP）是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格，它是一类程序设计语言的基础。 面向对象设计范型的主要特征是：  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是：一、程序一般由类的定义和类的使用两部分组成；二、程序中的一切操作都是向对象发送消息来实现的，对象收到消息后，启动有关方法完成相应的操作。   需要说明的是，某一种程序设计语言不一定与一种程
python 面向对象全面详解
热门推荐
日入上万
01-12 5万+
目录   一、对面向对象的理解 1、面向对象的编程---object oriented programming 2、python面向对象的重要术语： 3、函数和面向对象编程的区别 二、封装、继承、多态 1、封装（Encapsulation） 2、继承（Inheritance） 3、多态（Polymorphism） 三、面向对象的各种方法 1、静态方法  (用这个装饰器来表示 ...
Homework20191108
qq_40245464的博客
11-09 128
作业 /*创建一个Student 类 包含属性有 序号 姓名 年龄 生日 * 提供对应的setter/getter 创建对象，完成赋值(setter赋值和构造方法赋值) 在控制台输出学生对象的信息，要求生日的格式为 yyyy-MM-dd*/ import java.text.SimpleDateFormat; import java.util.Date; public c...
面向对象基础
王梦杰_MengJie
05-13 1万+
面向对象和面向过程是两种不同的编程范式，它们在代码组织、设计思想和解决问题的方式上有很大的区别。1. 抽象层次不同：面向过程编程以过程或函数为中心，强调程序的执行顺序和步骤。代码主要是一系列的过程（函数）调用，以完成特定的任务。面向对象编程以对象为中心，强调事物之间的关系和交互。代码主要是由对象组成，每个对象包含数据和操作数据的方法。2. 数据处理方式不同：数据和函数（过程）是分开的，数据通过函数进行处理和操作。数据和操作数据的方法被封装在一起，通过对象进行处理和操作。
如何实现面向对象
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
05-05 6352
如何实现面向对象面向对象的定义面向对象的三大特征、面向对象的基础实现面向对象基本准则实例 面向对象的定义 对象是指具体的某一事物，在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象指的是计算机系统中的某一个成分。 在面向对象程序设计中，对象包含两个含义，其中一个是数据，另一个是动作。对象是数据和动作的结构体。 面向对象是在对象这一层次。 面向对象的三大特征、面向对象的基础 封装、继承、多态 封装：在面向对象中，对数据和动作进行包装，其中的某些数据动作，可以是私有的，不能被外界访问，以此来实现对数
Java面向对象浅谈
编程界明世隐的博客
12-06 4838
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
什么是面向对象
G_hongbin的博客
07-01 1960
引用自面向对象_百度百科 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。 对象我们可以理解为一个实物，比
JAVA_面向对象1
GitHubClub
05-28 4033
一、面向过程的思想和面向对象的思想    面向对象和面向过程的思想有着本质上的区别, 作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，然后再分析这些类和对象应该具有哪些属性和方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。    面向对象有一个非常重要的设计思
C 语言面向对象思想
lzs940320的博客
10-22 3385
注：本博客参考了很多大神的文章加上自己的理解，只做学习复习用 一. C语言面向对象设计引入 1.我们为什么要学习面向对象思想？？？ 在我们平时的开发中也经常会遇到一些简单的项目我们很快就完成了，并且测试着也没有任何问题，但是随着产品迭代，需求增加，项目维护起来越来越耗时，一个看似简单的需求，需要花费较多的时间去开发，出现项目延期。 项目超期的很大一部分原因都是因为代码“牵一发动全身”，当我们的项目需求在累加的过程中，功能相近的应用我们也习惯性的复制，粘贴。导致出现了很多的冗余代码，同时业务逻辑与执.
面向对象名词解释
AHincsdn的博客
11-10 3733
面向对象：将现实生活中的事物封装成对象，通过对象的实例化和调用，完成需求。关注点是对象的属性和方法，忽略事物执行的顺序或过程。面向对象的特点有：抽象、封装、继承、多态。 抽象：抽象就是将现实生活中的事物，忽略与当前目标无关的方面，抽取出当前有用的属性和方法，使用类来表示。 封装：①封装就是使用private隐藏类的内部属性，使用set方法（设置赋值条件）赋值，使用get方法在外部访问。②将需要多次...
Python面向对象1
08-04
Python面向对象面向对象面向对象的程序设计把计算机程序视为一组对象的集合在Python中，所有数据类型都可以视为对象，当然也可以自定义对象万物皆为对象概念从
EcmaScript面向对象1
08-08
EcmaScript面向对象1
C++面向对象1
08-03
C++面向对象1
面向对象实验unit1
10-04
面向对象实验课unit1（UML类图），亲自做的，保证质量和正确性
简单的项目部署脚本（转载）
u010230019的博客
06-09 630
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1332
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 433
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 427
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
python面向对象1
09-13
1. 面向对象的概念：面向对象是一种程序设计范式，将数据和操作封装在对象中，通过对象之间的相互作用来完成程序的设计和实现。面向对象的特点包括封装、继承和多态。 2. 类和对象：类是一种抽象数据类型，用于定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值