day11、面向对象进阶（static、单例、代码块、继承）

已于 2022-04-21 15:30:40 修改
阅读量348 收藏
点赞数 1
分类专栏： java 进阶 文章标签： java 开发语言 后端
于 2021-12-09 01:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjl200212/article/details/121799453
版权

面向对象进阶（static、单例、代码块、继承）

面向对象进阶

请添加图片描述
请添加图片描述

静态关键字：static

static的作用、修饰成员变量的用法

请添加图片描述
请添加图片描述

package com.itheima.d1_static_field;

public class User {
    // 在线人数信息：静态成员变量
    public static int onLineNumber = 161;
    // 实例成员变量
    private String name;
    private int age;

    public static void main(String[] args) {
        // 1、类名.静态成员变量
        User.onLineNumber++;
        // 注意：同一个类中访问静态成员变量，类名可以省略不写
        System.out.println(onLineNumber);

        // 2、对象.实例成员变量
        // System.out.println(name);
        User u1 = new User();
        u1.name = "猪八戒";
        u1.age = 36;
        System.out.println(u1.name);
        System.out.println(u1.age);
        // 对象.静态成员变量(不推荐这样访问)
        u1.onLineNumber++;

        User u2 = new User();
        u2.name = "孙悟空";
        u2.age = 38;
        System.out.println(u2.name);
        System.out.println(u2.age);
        // 对象.静态成员变量(不推荐这样访问)
        u2.onLineNumber++;

        System.out.println(onLineNumber);

    }
}

162
猪八戒
36
孙悟空
38
164

在这里插入图片描述

static修饰成员变量的内存原理

请添加图片描述

static修饰成员方法的基本用法

请添加图片描述
请添加图片描述

package com.itheima.d2_static_method;

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

    /**
        实例方法：无static修饰，属于对象的，通常表示对象自己的行为，可以访问对象的成员变量
     */
    public void study(){
        System.out.println(name + "在好好学习，天天向上~~");
    }

    /**
        静态方法：有static修饰，属于类，可以被类和对象共享访问。
     */
    public static void getMax(int a, int b){
        System.out.println(a > b ? a : b);
    }

    public static void main(String[] args) {
        // 1、类名.静态方法
        Student.getMax(10, 100);
        // 注意：同一个类中访问静态成员 可以省略类名不写
        getMax(200, 20);

        // 2、对象.实例方法
        // study(); // 报错的
        Student s = new Student();
        s.name = "全蛋儿";
        s.study();

        // 3、对象.静态方法(不推荐)
        s.getMax(300,20);
    }
}

100
200
全蛋儿在好好学习，天天向上~~
300

请添加图片描述

请添加图片描述

static实际应用案例：定义工具类

请添加图片描述
请添加图片描述

package com.itheima.d3_static_test;

public class Login {
    public static void main(String[] args) {
        // 验证码：
        System.out.println("验证码：" + VerifyTool.createCode(10));
    }
}

package com.itheima.d3_static_test;

public class Register {
    public static void main(String[] args) {
        // 验证码：
        System.out.println("验证码：" + VerifyTool.createCode(5));
    }
}

package com.itheima.d3_static_test;

import java.util.Random;

public class VerifyTool {
    /**
       私有构造器
     */
    private VerifyTool(){
    }

    /**
      静态方法
     */
    public static String createCode(int n){
        // 1、使用String开发一个验证码
        String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        // 2、定义一个变量用于存储5位随机的字符作为验证码
        String code = "";
        // 3、循环
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(chars.length());
            // 4、对应索引提取字符
            code += chars.charAt(index);
        }
        return code;
    }
}

请添加图片描述
请添加图片描述
请添加图片描述

请添加图片描述

package com.itheima.d3_static_test;

public class ArrayUtils {
    /**
       把它的构造器私有化
     */
    private ArrayUtils(){
    }

    /**
       静态方法，工具方法
     */
    public static String toString(int[] arr){
        if(arr != null ){
            String result = "[";
            for (int i = 0; i < arr.length; i++) {
                result += (i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
            result += "]";
            return result;
        }else {
            return null;
        }
    }

    /**
     静态方法，工具方法
     */
    public static double getAverage(int[] arr){
        // 总和  最大值 最小值
        int max = arr[0];
        int min = arr[0];
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
            if(arr[i] < min){
                min = arr[i];
            }
            sum += arr[i];
        }
        return (sum - max - min)*1.0 / (arr.length - 2);
    }
}

package com.itheima.d3_static_test;

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println(arr);
        System.out.println(ArrayUtils.toString(arr));
        System.out.println(ArrayUtils.getAverage(arr));

        int[] arr1 = null;
        System.out.println(ArrayUtils.toString(arr1));
        int[] arr2 = {};
        System.out.println(ArrayUtils.toString(arr2));

    }
}

static的注意事项

请添加图片描述

package com.itheima.d4_static_attention;

public class Test {
    // 静态成员变量
    public static int onLineNumber;
    // 实例成员变量
    private String name;

    public static void getMax(){
        // 1、静态方法可以直接访问静态成员,不能访问实例成员。
        System.out.println(Test.onLineNumber);
        System.out.println(onLineNumber);
        inAddr();

        // System.out.println(name);

        // 3、静态方法中不能出现this关键字
        // System.out.println(this);
    }

    public void run(){
        // 2、实例方法可以直接访问静态成员，也可以访问实例成员
        System.out.println(Test.onLineNumber);
        System.out.println(onLineNumber);
        Test.getMax();
        getMax();

        System.out.println(name);
        sing();

        System.out.println(this);
    }

    public void sing(){
        System.out.println(this);
    }

    // 静态成员方法
    public static void inAddr(){
        System.out.println("我们在黑马程序员~~");
    }

    public static void main(String[] args) {

    }
}

static应用知识：代码块

代码块的分类、作用

请添加图片描述

package com.itheima.d5_static_codeblock;

public class TestDemo1 {

    public static String schoolName;

    public static void main(String[] args) {
        // 目标：学习静态代码块的特点、基本作用
        System.out.println("=========main方法被执行输出===========");
        System.out.println(schoolName);
    }

    /**
     特点：与类一起加载，自动触发一次，优先执行
     作用：可以在程序加载时进行静态数据的初始化操作（准备内容）
     */
    static{
        System.out.println("==静态代码块被触发执行==");
        schoolName = "黑马程序员";
    }
}


package com.itheima.d5_static_codeblock;

public class TestDemo2 {

    private String name;

    /**
       属于对象的，与对象一起加载，自动触发执行。
     */
    {
        System.out.println("==构造代码块被触发执行一次==");
        name = "张麻子";
    }

    public TestDemo2(){
        System.out.println("==构造器被触发执行==");
    }

    public static void main(String[] args) {
        // 目标：学习构造代码块的特点、基本作用
        TestDemo2 t = new TestDemo2();
        System.out.println(t.name);

        TestDemo2 t1 = new TestDemo2();
        System.out.println(t1.name);
    }

}

请添加图片描述

package com.itheima.d5_static_codeblock;

import java.util.ArrayList;

public class StaticCodeTest3 {
    /**
       模拟初始化牌操作
         点数: "3","4","5","6","7","8","9","10","J","Q","K","A","2"
         花色: "♠", "♥", "♣", "♦"
       1、准备一个容器，存储54张牌对象，这个容器建议使用静态的集合。静态的集合只加载一次。
     */
    // int age = 12;
    public static ArrayList<String> cards = new ArrayList<>();

    /**
       2、在游戏启动之前需要准备好54张牌放进去，使用静态代码块进行初始化
     */
    static{
        // 3、加载54张牌进去。
        // 4、准备4种花色：类型确定，个数确定了
        String[] colors = {"♠", "♥", "♣", "♦"};
        // 5、定义点数
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        // 6、先遍历点数、再组合花色
        for (int i = 0; i < sizes.length; i++) {
            // sizes[i]
            for (int j = 0; j < colors.length; j++) {
                cards.add(sizes[i] + colors[j]);
            }
        }
        // 7、添加大小王
        cards.add("小🃏");
        cards.add("大🃏");
    }

    public static void main(String[] args) {
        System.out.println("新牌：" +  cards);
    }
}

请添加图片描述

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

设计模式、单例模式介绍、饿汉单例模式

请添加图片描述
请添加图片描述
请添加图片描述

package com.itheima.d6_singleinstance;

/**
    目标：学会使用恶汉单例模式设计单例类
 */
public class SingleInstance1 {
    /**
       static修饰的成员变量，静态成员变量，加载一次，只有一份
     */
    // public static int onLineNumber = 21;
    public static SingleInstance1 instance = new SingleInstance1();

    /**
        1、必须私有构造器：私有构造器对外不能被访问。
     */
    private SingleInstance1(){
    }


}

package com.itheima.d6_singleinstance;

public class Test {
    public static void main(String[] args) {
//        SingleInstance1 s1 = new SingleInstance1();
//        SingleInstance1 s2 = new SingleInstance1();
//        SingleInstance1 s3 = new SingleInstance1();

        SingleInstance1 s1 = SingleInstance1.instance;
        SingleInstance1 s2 = SingleInstance1.instance;
        SingleInstance1 s3 = SingleInstance1.instance;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s1 == s2);
    }
}

请添加图片描述

懒汉单例模式

请添加图片描述

package com.itheima.d6_singleinstance;

/**
    目标：设计懒汉单例
 */
public class SingleInstance2 {
    /**
       2、定义一个静态的成员变量用于存储一个对象，一开始不要初始化对象，因为人家是懒汉
     */
    private static SingleInstance2 instance;

    /**
       1、私有构造器啊
     */
    private SingleInstance2(){
    }

    /**
      3、提供一个方法暴露，真正调用这个方法的时候才创建一个单例对象
     */
    public static SingleInstance2 getInstance(){
        if(instance == null){
            // 第一次来拿对象，为他做一个对象
            instance = new SingleInstance2();
        }
        return instance;
    }
}

package com.itheima.d6_singleinstance;

public class Test2 {
    public static void main(String[] args) {
        // 得到一个对象
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();

        System.out.println(s1 == s2);
    }
}

请添加图片描述

面向对象三大特征之二：继承

继承概述、使用继承的好处

请添加图片描述

package com.itheima.d7_extends;

public class People {
    private String name;
    private int 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;
    }
}

package com.itheima.d7_extends;

public class Student extends People{
    /**
       独有的行为
     */
    public void study(){
        System.out.println(getName() + "学生开始学习~~~~~");
    }
}

package com.itheima.d7_extends;

public class Teacher extends People{
    /**
       独有的行为
     */
    public void teach(){
        System.out.println("老师在快乐的教Java~~~~~");
    }

}

package com.itheima.d7_extends;

public class Test {
    public static void main(String[] args) {
        // 创建子类对象，看是否可以使用父类的属性和行为
        Student s = new Student();
        s.setName("西门"); // 父类的
        s.setAge(25);// 父类的
        System.out.println(s.getName());// 父类的
        System.out.println(s.getAge());// 父类的
        s.study();
    }
}

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

继承的设计规范、内存运行原理

请添加图片描述
请添加图片描述

package com.itheima.d8_extends_test;

/**
   角色类 父类
 */
public class Role {
    private String name;
    private int age;

    /**
        共同行为
     */
    public void queryCourse(){
        System.out.println(name + "开始查看课程信息~~");
    }

    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;
    }
}

package com.itheima.d8_extends_test;

public class Student extends Role{
    // 独有属性
    private String className;

    // 独有行为
    public void writeInfo(){
        System.out.println(getName()
                + "说：今天学习感觉美美的,老师也是666~~~");
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

package com.itheima.d8_extends_test;

public class Test {
    public static void main(String[] args) {
        // 1、创建学生对象
        Student s = new Student();
        s.setName("张松松"); // 父类的
        s.setAge(25); // 父类的
        s.setClassName("Java999期"); // 子类的
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getClassName());
        s.queryCourse(); // 父类的
        s.writeInfo(); // 子类的

    }
}

请添加图片描述
请添加图片描述

继承的特点

请添加图片描述

请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

package com.itheima.d9_extends_feature;

public class ExtendsDemo {
    public static void main(String[] args) {
        // 子类是否可以继承私有的属性和行为呢？我认为可以的
        Student s = new Student();
//        System.out.println(s.age);
//        s.run();
    }
}

class C extends A{

}

class A{

}

class B{

}

class People{
    private int age = 21;
    private void run(){
        System.out.println("人跑的很快~~");
    }
}

class Student extends People{

}

请添加图片描述

继承后：成员变量、成员方法的访问特点

请添加图片描述

package com.itheima.d10_extends_field_method;

public class ExtendsDemo {
    public static void main(String[] args) {
        Wolf w = new Wolf();
        System.out.println(w.name); // 子类的
        w.showName();
    }
}

class Animal{
    public String name = "父类动物";
}

class Wolf extends Animal{
    public String name = "子类动物";

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

package com.itheima.d10_extends_field_method;

public class ExtendsDemo2 {
    public static void main(String[] args) {
        Student s = new Student();
        s.run(); // 子类的
        System.out.println("-----------");
        s.go();
    }
}

class People{
    public void run(){
        System.out.println("可以跑~~");
    }
}

class Student extends People{
    public void run(){
        System.out.println("学生跑的贼快~~");
    }

    public void go(){
        run(); // 子类的
        super.run(); // 父类的
    }
}

请添加图片描述

继承后：方法重写

请添加图片描述

package com.itheima.d11_extends_methodoverride;

public class NewPhone extends Phone{
    /**
      方法重写了
     */
    @Override
    public void call() {
        super.call();
        System.out.println("支持视频通话~~~");
    }

    /**
     方法重写了
     */
    @Override
    public void sendMessage() {
        super.sendMessage();
        System.out.println("支持发送图片和视频~~~");
    }
}

package com.itheima.d11_extends_methodoverride;

public class Phone {
    public void call(){
        System.out.println("打电话开始~~~");
    }

    public void sendMessage(){
        System.out.println("发送短信开始~~~");
    }
}

package com.itheima.d11_extends_methodoverride;

public class Test {
    public static void main(String[] args) {
        NewPhone huawei = new NewPhone();
        huawei.call();
        huawei.sendMessage();
    }
}

请添加图片描述

请添加图片描述

继承后：子类构造器的特点

请添加图片描述

package com.itheima.d12_extends_constructor;

public class Animal {
    public Animal(){
        System.out.println("==父类Animal无参数构造器被执行===");
    }
}

package com.itheima.d12_extends_constructor;

public class Cat extends Animal{
    public Cat(){
        super(); // 默认的，写不写都有，默认就是找父类无参数构造器
        System.out.println("==子类Cat无参数构造器被执行===");
    }

    public Cat(String n){
        super(); // 默认的，写不写都有，默认就是找父类无参数构造器
        System.out.println("==子类Cat有参数构造器被执行===");
    }
}

package com.itheima.d12_extends_constructor;

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        System.out.println("------------");
        Cat c1 = new Cat("叮当猫");
    }
}

请添加图片描述

继承后：子类构造器访问父类有参构造器

请添加图片描述

package com.itheima.d13_extends_constructor2;

public 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;
    }
}

package com.itheima.d13_extends_constructor2;

public class Student extends People{
    private String className;

    public Student(){
    }

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

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

package com.itheima.d13_extends_constructor2;

public class Test {
    public static void main(String[] args) {
        Student s = new Student("张三", 21, "99期");
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getClassName());
    }
}

请添加图片描述

this、super使用总结请添加图片描述

请添加图片描述

package com.itheima.d14_this;

public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }

    public Student(String name) {
        // 借用兄弟构造器！
        this(name, "黑马培训中心");
    }


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

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

package com.itheima.d14_this;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("王亮", "清华大学");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());


        Student s2 = new Student("王超");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}
wjl200212
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
学习java第10天(面向对象进阶篇)
m0_54354241的博客
03-22 538
static关键字:开发中如何定义一个共享的信息，给所有对象共享访问，如在线人数信息等 设计模式:单例 有些类只需要一个对象就可以了，如任务管理器对象，如何实现一个类只能对外产生同一个对象 面向对象三大特征:继承 大量角色类的属性和行为存在重复代码，如果把一类的角色信息进行优化，提升代码复用，降低代码冗余 静态关键字： static的作用，修饰成员变量的用法 static是静态的意思，可以修饰成员变量，表示该成员变量只在内存中只存储一份，可以被共享访问、修改 成员变量可以分为两类 静态成员变量(
java之6天 static代码块,单例模式
路虽远行则将至，事虽难做则必成
03-24 82
static(静态) 关键字 [code="java"] //用于修饰成员(成员变量和成员函数) //被static修饰后的特点 1.随着类的加载而加载,消失而消失(说明生命周期随着类) 2.优先于对象存在 3.被所有对象共享 4.可以直接被类名调用 5.静态变量定义多了,就会消耗更多的内存 //实例变量 和 类变量(静态变量)的区别 1....
static、单例、代码块、继承
小马测试之路的博客
09-17 289
面向对象进阶（static、单例、代码块、继承）
java static静态关键字、单例、代码块 学习笔记
dafsq的博客
05-15 451
java static静态关键字、单例、代码块 学习笔记
JAVA学习笔记(十六)-static
CSDNXXCQ的博客
02-05 574
static public class User { // 在线人数信息：静态成员变量 public static int onLineNumber = 161; // 实例成员变量 private String name; private int age; public static void main(String[] args) { // 1、类名.静态成员变量 User.onLineNumber++;
day11-面向对象-static&继承
12-12
小白新人，基础java知识分享
day12-面向对象-static&继承
12-12
小白新人，基础java知识分享
day12-面向对象进阶语法.xmind
12-03
day12-面向对象进阶语法.xmind
day01-03讲义(面向对象进阶).zip
03-05
day01-03讲义(面向对象进阶).zip
Day 08 面向对象
12-22
面向对象 ScorpioDong 1. 生活中的面向对象 找合适的人做合适的事 面向对象: 合适人做合适事情 面向过程: 一个人做所有事情 2. 类和对象 类：对于一类事物的统称，对当前事物的一些描述，属性描述和行为描述 对象...
【Java】static关键字案例：创建工具类
lixingecho的博客
11-18 2036
一、工具类概述 1、工具类是什么，有什么好处？ 工具类内部都是一些静态方法，每个方法完成一个功能 一次编写，处处可用，提高代码重用性 2、工具类有什么要求 建议将工具类构造器私有化 私有化目的：禁止外部创建对象，因为工具类里面都是静态方法，直接用类名访问即可。（还可以节约内存） 二、工具类案例 1、利用工具类，生成随机验证码 工具类：(生成随机验证码) public class VerifyTool { /** * 构造器私有化 */ private Verif
Java继承
CHANBAEKXUN的博客
08-28 75
因为为了保证在继承关系下，子类对象可以访问父类的成员，必须先对父类成员初始化，子类对象才能访问。特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。当子类需要父类的功能，但父类的该功能不完全满足自己的需求时，子类可以重写父类中的方法。在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。表示对象自己的行为的，且方法中需要访问对象的成员，则该方法必须声明成实例方法。代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），...
静态关键词：static
weixin_52270382的博客
01-21 781
如果登录和注册等多处地方都存在验证码逻辑，就会导致同一个功能多处开发，会出现代码重复度过高。在企业的管理系统中，通常需要在一个系统的很多业务处使用验证码进行防刷新等安全机制。static实际应用案例：使用静态方法定义工具类。static修饰成员变量的内存原理。static修饰成员方法的内存原理。练习：定义数组工具类。
单例模式--静态内部类和静态代码块实现单例的区别
qq_25956141的博客
07-28 2008
静态资源不是一开始就存在于内存中的。 我们来看一个例子，静态资源不是一开始就存在于内存中的。 class A{ private A(){ System.out.println(&amp;quot;A被初始化了&amp;quot;); } private static A a = new A(); } 我们创建了一个类A，我们并没有使用这个类，在控制台，也不会输出：“A初...
c#复习part1----控制台部分
weixin_44575911的博客
06-22 1061
第一章和第二章 1.在c#中char型转int可以隐式转换，但int到char必须显示强制转换 2.float作为分母可以是0，结果是无穷大（double也是无穷大，int和decimal会报错） 3.c#中无法将int转成bool，c#的bool只有true和false 4.ToInt32的结果是趋偶的 static void Main(string[] args) { Console.WriteLine("{0},{1},{2},{3}",t, c,10/
利用static来实现单例模式
sometime here
01-08 952
一：之前旧的写法 class Singleton{ private Singleton() {} private static Singleton instance = null; public synchronized static Singleton getInstance() { if (instance == null) { ...
静态代码块和单例混合
weixin_34235457的博客
05-05 122
使用单例是为了像一些工具，不用去重复的new，而静态代码块，可以在类加载的时候就执行。 static块的执行发生在“初始化”的阶段。 public class T4 { static { //静态代码块 System.out.println("Tom"); } public static void hahah ...
【仿真建模-anylogic】FlowchartPort原理解析
最新发布
zhaoyaxuan001的博客
06-14 353
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
python面向对象编程做一个课程表
05-13
好的，我可以给你提供一个简单的示例代码，用于实现一个课程表的功能。 ```python class Course: def __init__(self, course_name, course_time): self.course_name = course_name self.course_time = course_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值