Java笔记1(java类、接口、封装、继承、多态、约瑟夫环应用)

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量118 收藏
点赞数
分类专栏： Java 文章标签： java 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sgj_4732514/article/details/84270887
版权
[color=blue][size=x-large]文件结构 [/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071458163814.png[/img]
[color=blue][size=x-large]Java访问修饰符 [/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071458177029.png[/img] 
com.xiaoming / XiaoMing.java: 

package com.xiaoming;    
import java.util.*;    
import com.xiaoqiang.*;    
public class XiaoMing {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        // TODO Auto-generated method stub    
        HashMap hm=new HashMap();    
        Cat cat1=new Cat();    
        System.out.println(cat1.getName());    
    }    
}    

class Dog    
{    
} 
com.xiaoqiang / Cat.java: 

package com.xiaoqiang;    

public class Cat {    
    public int a;    
    protected String name;    
    String color;    
    private float price;    

    //提供一个访问name的成员方法    
    public String getName()    
    {    
        return this.name;    
    }    
} 
com.xiaoqiang / Test2.java: 

package com.xiaoqiang;    

public class Test2 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        // TODO Auto-generated method stub    
        Dog dog1=new Dog();    
        System.out.println(dog1.a);    
    }    
}    

class Dog    
{    
    public int a;    
    protected String name;    
    String color;    
    private float price;    

    public void abc1()    
    {    
        System.out.println(a);    
    }    
}   
Com.XiaoQiang /XiaoQiang.java: 

package com.xiaoqiang;    

public class XiaoQiang {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    

    }    
} 
com.test / Test.java: 

/*   
 * 功能：抽象类的必要性   
 */   
package com.test;    

public class Test {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //Animal an=new Animal();//抽象类不能被实例化    

    }    

}    

abstract class Animal //抽象类    
{    
    String name;    
    int age;    
    //动物会叫    
    /*   
    public void cry()//父类方法不确定性   
    {   
        System.out.println("不知道怎么叫！");   
    }   
    */   

    public void aaa()    
    {    
        System.out.println("抽象类中的实现方法");    
    }    
    //抽象类中可以包含实现了的方法    

    abstract public void cry();//抽象方法    
    //抽象类的特征：    
    //1.抽象类不能被实例化    
    //2.抽象类可以没有抽象方法    
    //3.包含了abstract(抽象)方法的类，必须声明为abstract    
    //4.抽象方法不能有主体，即不能有{}    
}    

class Cat extends Animal    
{    
    //当一个类继承的父类是抽象类的话，就需要在子类在把抽象类    
    //的所有抽象方法全部实现    

    //实现    
    public void cry()    
    {    
        System.out.println("猫猫叫。。。");    
    }    
}    
com.test2 / Test.java: 

/*   
 * 功能：接口的案例   
 */   

package com.test2;    

public class Test {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        System.out.println(Usb.a);    

        //创建一个计算机    
        Computer computer=new Computer();    
        //创建Camera    
        Camera cameral=new Camera();    
        //创建手机    
        Phone phone1=new Phone();    

        computer.useUsb(cameral);    
        computer.useUsb(phone1);    

    }    
}    

//Usb接口    
interface Usb    
{    
    int a=1;    
    public void start();    
    public void stop();    
}    
interface aaa    
{    
    public void Eee();    
}    
interface kkk extends aaa    
{    
    public void cry();    
}    

//接口不能被实例化，且接口中不能含有实现 了的方法    
//接口可以理解成更加抽象的抽象方法    
//接口中可以有被初始化的public,static,final类型的变量    
//接口不能继承类，接口可以继承接口    

//一个重要的原则：当一个类实现了一个接口，    
//就要求该类把这个接口的所有方法都实现    
class Camera implements Usb,kkk //一个类实现多个方法    
{    
    public void start()    
    {    
        System.out.println("相机，开始工作了！");    
    }    
    public void stop()    
    {    
        System.out.println("相机，停止工作了！");    
    }    
    public void cry()    
    {    

    }    
    public void Eee()    
    {    

    }    

}    

class Phone implements Usb    
{    
    public void start()    
    {    
        System.out.println("手机，开始工作了！");    
    }    
    public void stop()    
    {    
        System.out.println("手机，停止工作了！");    
    }    
}    

class Computer    
{    
    //开始使用use接口    
    public void useUsb(Usb usb)    
    {    
        usb.start();    
        usb.stop();    
    }    
}   
com.test3 / Test.java: 

/*   
 * final修饰类   
 */   
package com.test3;    

public class Test {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    

        Aaa aaa=new Aaa();    
        aaa.show();    
        Bbb bbb=new Bbb();    
        bbb.show();    
    }    
}    

//final修饰类，则表示该类不能被继承    
//final class Aaa    
class Aaa    
{    
    int a=0;//如果不给初值，a=? ,在类中的成员变量最好赋个初值    
    //圆周率不希望被别人改,加final修饰    
    //如果一个变量用final修饰，则在定义时必须被初始化，而且后面不能改    
    final float rate_aaa_bbb=3.1415926f;    
    //给方法用final修饰，则表示不可以被修改，不可被 覆盖    
    final public void sendMes()    
    {    
        System.out.println("发送消息");    
    }    
    public void show()    
    {    
        System.out.println("a="+this.a);    
    }    
}    
class Bbb extends Aaa    
{    
    public Bbb()    
    {    
        a++;    
        //rate_aaa_bbb++; //因为rate_aaa_bbb为final类型    
    }    
    /*   
    public void sendMes()   
    {   
        System.out.println("发送消息");   
    }   
    */   
}    

interface Fish    
{    
    //该方法实现******    
    public void swimming();    
}    
interface Bird    
{    
    public void fly();    
}    
class Monkey    
{    
    int name;    
    //跳    
    public void jump()    
    {    
        System.out.println("猴子会跳");    
    }    
}    

class LittleMonkey extends Monkey implements Fish,Bird    
{    

    @Override   
    public void swimming() {    


    }    

    @Override   
    public void fly() {    

    }    
} 
com..test3 / Mty99.java: 

/*   
99乘法表   
*/   

package com.test3;    

public class Mty99    
{    
    public static void main(String [] args)    
    {    
        for(int i=1;i<=9;i++)    
        {    
            for(int j=1;j<=i;j++)    
            {    
                if(i==3&&j==3||i==4&&j==3)    
                    System.out.print(" "+j+"*"+i+"="+i*j+" ");    
                else   
                    System.out.print(j+"*"+i+"="+i*j+" ");    
            }    
            System.out.println("");    
        }    
    }    
} 
com.luowei / Demo1.java: 

/*   
 * 功能：说明继承的必要性   
 */   

package com.luowei;    

public class Demo1 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    

        Pupil p1=new Pupil();    
        p1.printName();    
    }    
}    

//小学生类    
class Pupil extends Stu    
{    
    /*   
    //定义成员属性   
    private int age;   
    private String name;   
    private float fee;   
    */   
    //交学费    
    public void pay(float fee)    
    {    
        this.fee=fee;    
    }    
}    
//幼儿    
class Kid extends Pupil    
{    
}    

//中学生    
class MiddleStu extends Stu    
{    
    /*   
    //定义成员属性   
    private int age;   
    private String name;   
    private float fee;   
    */   
    //交学费    
    public void pay(float fee)    
    {    
        this.fee=fee*0.8f;    
    }    
}    

//大学生生    
class CloStu extends Stu    
{    
    /*   
    //定义成员属性   
    private int age;   
    private String name;   
    private float fee;   
    */   
    //交学费    
    public void pay(float fee)    
    {    
        this.fee=fee*0.1f;    
    }    
}    

//将学生的共同属性抽象出来，做一个父类    
class Stu    
{    
    protected int age;    
    public String name;    
    public float fee;    

    public void printName()    
    {    
        System.out.println("名字："+this.name);    
    }    
    //如果不希望子类继承某个属性或方法，则将其显示声明为私有     
}   
com.luowei / Demo2.java: 

package com.luowei;    

import javax.swing.*;    
public class Demo2 extends JFrame {    
    public static void main(String [] args)    
    {    
        //Demo2 demo2=new Demo2();    

        Abc abc1=new Abc();    
        System.out.println(abc1.getMax(4,1.2f));    
    }    
    /*   
    public Demo2()   
    {   
        this.setVisible(true);   
        this.setSize(200,200);   
    }   
    */   
}    

class Abc    
{    
    //返回较大的整数    
    public int getMax(int i,int j)    
    {    
        if(i>j)    
        {    
            return i;    
        }    
        else   
        {    
            return j;    
        }    
    }    
    public float getMax(float a,float b)//重载，参数类型不同    
    {    
        if(a>b)    
        {    
            return a;    
        }    
        else   
        {    
            return b;    
        }    
    }       
    //如果只是返回类型不同，是不能构成重载的    
    /*   
    public double getMax(float a,float b)//重载，参数类型不同   
    {   
        if(a>b)   
        {   
            return a;   
        }   
        else   
        {   
            return b;   
        }   
    }   
    */   

    //如果只是控制访问修饰符号不一样，也不能构成重载    
    /*   
    protected float getMax(float a,float b)//重载，参数类型不同   
    {   
        if(a>b)   
        {   
            return a;   
        }   
        else   
        {   
            return b;   
        }   
    }   
    */   
} 
com.luowei / Demo3.java: 

package com.luowei;    

public class Demo3 {    

    public static void main(String [] args)    
    {    
        //创建一只猫    
        Cat cat1=new Cat();    
        cat1.cry();    
        Dog dog1=new Dog();    
        dog1.cry();    
    }    
}    

class Animal    
{    
    int age;    
    String name;    
    //都会叫    
    public void cry()    
    {    
        System.out.println("是个动物，不知道 怎么叫唤");    
    }    
}    

//猫猫类    
class Cat extends Animal    
{    
    //覆盖就是将父类的方法再重新写一遍，如下边的cry()方法    
    public void cry()    
    {    
        System.out.println("猫猫叫！");    
    }    
}    

//狗类    
class Dog extends Animal    
{    
    public void cry()    
    {    
        System.out.println("汪汪叫！");    
    }    
}   
com.luowei / Demo4.java: 

/*   
 * 功能：约瑟夫环，数到m的小孩 出圈   
 */   

package com.luowei;    

public class Demo4 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        CycLink cyclink=new CycLink();    
        cyclink.setLen(5);    
        cyclink.createLink();    
        cyclink.setK(2);//设置从第几个人开始数数    
        cyclink.setM(2);//设置的数m    
        cyclink.show();    
        cyclink.play();    

    }    
}    

class Child    
{    
    int no;    
    Child nextChild;    
    public Child(int no)    
    {    
        //给一个编号    
        this.no=no;    
    }    
}    

class CycLink    
{    
    //先定义一个指向链表第一个小孩的引用    
    //指向第一个小孩的引用，不能动    
    Child firstChild=null;    
    Child temp=null;    
    int len=0;//表示共有多少个小孩    
    int k=0;    
    int m=0;    

    //设置小孩的个数    
    public void setLen(int len)    
    {    
        this.len=len;    
    }    

    //设置m    
    public void setM(int m)    
    {    
        this.m=m;    
    }    

    //设置从第几个人开始数数    
    public void setK(int k)    
    {    
        this.k=k;    
    }    

    //开始数数    
    public void play()    
    {    
        Child temp=this.firstChild;    
        //1.先找到开始数数的人    
        for(int i=1;i<k;i++)    
        {    
            //因为自己数一下，再找到下一个人，所以将i<k    
            temp=temp.nextChild;    
        }    

        while(this.len!=1)    
        {    
            Child temp2=temp;//用来存放第m-1个孩子    
            //2.数m下    
            for(int j=1;j<m;j++)    
            {    

                if(j==m-1)    
                {    
                    temp2=temp;    
                }    
                temp=temp.nextChild;    
            }    
            /*   
            //找到要出圈的前一个小孩   
            Child temp2=temp;   
            while(temp2.nextChild!=temp)   
            {   
                temp2=temp2.nextChild;   
            }   
            */   
            //3.将数到m的小孩，退出圈    
            temp2.nextChild=temp.nextChild;    
            //让temp指向下一个数数的小孩    
            temp=temp.nextChild;    
            this.len--;    
        }    
        //最后一个小孩子    
        System.out.println("最后出圈："+temp.no);    
    }    

    //初始化环形链表    
    public void createLink()    
    {    
        for(int i=1;i<=len;i++)    
        {    
            if(i==1)//处理第一个小孩    
            {    
                //创建第一个小孩    
                Child ch=new Child(i);    
                this.firstChild=ch;    
                this.temp=ch;    
            }    
            else   
            {    
                if(i==len)//创建最后一个小孩    
                {    
                    //继续创建小孩子    
                    Child ch=new Child(i);    
                    temp.nextChild=ch;    
                    temp=ch;    
                    temp.nextChild=this.firstChild;    
                }    
                else//创建中间小孩    
                {    
                    //继续创建小孩子    
                    Child ch=new Child(i);    
                    temp.nextChild=ch;    
                    temp=ch;    
                }    
            }    
        }    
    }    
    //打印该环形链表    
    public void show()    
    {    
        //定义一个跑龙套    
        Child temp=this.firstChild;    
        do   
        {    
            System.out.print(temp.no+" ");    
            temp=temp.nextChild;//指到下一个    
        }while(temp!=this.firstChild);    
    }    
}   
com.luowei / Demo5.java: 

/*   
 * 功能：多态的应用   
 */   

package com.luowei;    

public class Demo5 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        /*   
        Cat2 cat=new Cat2();   
        cat.cry();   
        Dog2 dog=new Dog2();   
        dog.cry();   
        */   
    /*     
        Animal2 an=new Cat2();//多态的应用，创建Animal引用an，在这an是猫   
        an.cry();//通过Animal中的覆盖cry()方法可以实现多态   
        an=new Dog2();//利用多态性，使an的状态成为狗   
        an.cry();   
        //用一种引用可以管理很多的实例   
    */   
        Master master=new Master();    
        master.feed(new Dog2(), new Bone());    
        master.feed(new Cat2(), new Fish());    
    }    
}    

//动物类Animal    
class Animal2    
{    
    String name;    
    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;    
    }    

    //动物会叫    
    public void cry()    
    {    
        System.out.println("不知道怎么叫");    
    }    
    //方法覆盖(重写)的作用：    
    //1.可以实现多态，实现一个父类引用管理多个子类实例，呈现多种状态    
    //2.可以具体化子类行为。    

    //动物可以吃东西    
    public void eat()    
    {    
        System.out.println("不知道 吃什么");    
    }    
}    

class Dog2 extends Animal2    
{    
    //狗叫    
    public void cry()    
    {    
        System.out.println("汪汪叫");    
    }    

    //狗吃    
    public void eat()    
    {    
        System.out.println("狗喜欢吃骨头");    
    }    
}    

class Cat2 extends Animal2    
{    
    //猫自己叫    
    public void cry()    
    {    
        System.out.println("猫猫叫");    
    }    
    //猫吃东西    
    public void eat()    
    {    
        System.out.println("猫喜欢吃鱼");    
    }    
}    

//食物    
class Food    
{    
    String name;    
    public void showName()    
    {    

    }    
}    

//鱼类    
class Fish extends Food    
{    
    public void showName()    
    {    
        System.out.println("鱼");    
    }    
}    

//骨头类    
class Bone extends Food    
{    
    public void showName()    
    {    
        System.out.println("骨头");    
    }    
}    

//主人类    
class Master    
{    
    //给动物喂食物，使用多态，方法就可以只用一个    
    //这样就不必给每一种具体类型的动物都写一个喂食物的方法了    
    public void feed(Animal2 an,Food f)    
    {    
        an.eat();    
        f.showName();    
    }    
}
sgj_4732514
关注
专栏目录
一、Java面试基础之面向对象的特征：继承、封装和多态（原创实例）
玻璃汽水的博客
08-05 687
一、继承 1、概念：继承是类与类的一种关系，是一种“is a”的关系。比如“狗”继承“动物”，这里动物类是狗类的父类或者基类，狗类是动物类的子类或者派生类。 2、java中的继承是单继承，即一个类只有一个父类、 3、优点：子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用 4、语法规则，只要在子类加上extends关键字继承相应的父类就可以了 c...
java知识点总结（继承，封装，多态）
m0_37933543的博客
09-05 465
java就是一个面向对象的思想，而面向对象有三大特性： 封装 继承 多态 封装 1，定义： 封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法。 2，好处： 1，实现了低耦合高内聚。 2，类内部的结构可以自由修改。 3，隐藏实现细节，提供公共的访问方式。 继承 1，概述： 继承就是子类继承父类的特征、行为，体现了类与类之间的"is-a"关系。A类是B类的父类，可以说B...
Java类继承以及接口实现实例
weixin_33744854的博客
10-07 234
Java类继承以及接口实现实例：这个实例非常容易理解，贴在这里与大家共享。 1 //抽象父类，交通工具(Vehicle) 2 public abstract class Vehicle{ 3 private String name; 4 private double cost; 5 6 //无参构造函数 7 public V...
关与多态的的一个理解，猫狗主人喂食的一个实例
qq_36991183的博客
06-28 1121
摘自博客园 https://www.cnblogs.com/1693977889zz/p/8296595.html Java中多态实现机制靠的是父类或接口定义的引用变量可以指向子类或其具体的实现类。 https://www.cnblogs.com/crane-practice/p/3671074.html ...
【Java基础】(01)类，继承，接口
西海 Tech
10-13 992
本文快速总结了Jave基础的类，继承，接口等相关的知识点。
Java 多态 ——一个案例 彻底搞懂它
aiqi1964的博客
07-23 687
原文：https://www.cnblogs.com/1693977889zz/p/8296595.html 最近，发现基础真的很重要。比如，Java中多态的特性，在学习中就是很难懂，比较抽象的概念。学的时候就犯糊涂，但日后会发现，基础在日常工作的理解中占有重要的角色。 下面，我将用一个代码实例，回忆和巩固多态的概念和存在的意义。理解多态，是面向对象编程的重要一步。 先来个热...
Java基础知识点（类和对象、方法、封装、继承、多态、抽象类和接口）
StruggleBamboo的博客
12-18 1042
Java基础知识点一、类和对象1.类是什么？对象又是什么？类和对象的关系又是什么？2.单元测试：3.输出简洁方式4.类：二、方法1.方法的组成：2.修饰符：3.返回值类型：4.方法名：5.参数：6.调用：7.构造方法：8.重载：三、封装和继承1.封装：2.包：3.访问修饰符：4.static和this关键字5.继承：6.this和super的区别：7.重写（覆盖）和重载：8.Final：9.要想让一个类不被其它类继承：10.继承总结：四、多态1.重写object类的equals方法2.instanceof3
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
Java面向对象编程（封装/继承/多态）实例解析
08-29
Java 面向对象编程（封装/继承/多态）实例解析 Java 面向对象编程是一种编程范式，它强调对象之间的交互和继承关系。在 Java 中，面向对象编程主要体现在三大特征：封装、继承和多态。 封装是指隐藏对象的内部细节...
Java实验报告——类的继承、多态的应用
02-21
在本实验报告中，我们将深入探讨Java编程中的两个核心概念：类的继承和多态的应用。实验主要目标是加深对抽象类和抽象方法的理解，并掌握如何在实际编码中实现类的继承以及多态性。 首先，让我们理解抽象类和抽象...
spring事务详细讲解-深入浅出
小电玩
09-08 542
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1527
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 590
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 626
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 593
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Linux服务器Java启动脚本
Jack魏
09-08 575
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 803
MyBatis面试
Java程序设计实验：类继承与多态应用探索
"西南科技大学Java程序设计与实践的实验三主要关注类的继承与多态的应用，旨在让学生熟练掌握面向对象编程的关键概念。实验要求学生设计一个基于图形用户界面（GUI）的应用，能够计算和绘制不同形状的面积，如等腰...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值