Java基础知识（十）（面向对象--1）（含java三大特征之一-----封装）

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量321 收藏 2
点赞数
分类专栏： java 文章标签： java apache 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986314/article/details/122439958
版权

·一、类和对象

1、类与对象的关系：

类相当于抽象的概念，对象是类的具体表现

2、 事物

       属性：用来描述事物的信息

行为：用来描述事物能够做什么

3、类

      成员变量：事物的属性

      成员方法：事物行为

定义一个类，其实就是定义这个类中成员变量和成员方法。

4、如何定义一个成员变量？

  (1)定义的位置：在类中，方法外；

  (2)定义的格式： 数据类型 变量名。

5、如何定义一个成员方法？

  (1)、定义的位置：在类中

  (2)、定义的格式： 修饰符 返回值类型 方法名(参数列表)

                            {

                                    方法体;

                            }

6、成员变量与局部变量的区别：

     (1)在类中定义的位置不同

         成员变量：类中，但是在方法外

         局部变量：定义在方法内部

     (2)在内存中的位置也不同

         成员变量：在堆内存中

         局部变量：在栈内存中

     (3)初始化值也不同

          成员变量：系统会给予默认值

         局部变量：没有系统给的默认值，必须在定义的时候赋值，亦或者在方法中使用之前赋值，                             然后才能使用。

     (4)生命周期不同

         成员变量的生命周期：随着对象的创建而创建，随着对象的消失而消失 

         局部变量的生命周期：随着方法的调用而创建，随着方法的调用完毕而消失

*注意事项：

(1)局部变量的名字可以和成员变量的名字一样，在方法中使用的时候，采用就近原则 方法中使用      的变量，会现在方法内部查找，如果方法内部没有，去成员变量中查找。

(2)方法与方法之间里面的局部变量变量，不能互相调用。

7、匿名对象：

     就是没有名字对象

8、匿名对象的使用场景：

(1)调用方法的时候，仅仅调用一次的时候，可以使用匿名对象 注意，当调用多次的时候，不适         合,      每次new的时候都是一个新的匿名对象，会频繁的在堆内存中开辟空间 当匿名对象使用       完毕之后，无法再使用第二次，就变成了一个垃圾（当栈中没有变量引用它的时候，判定是一       个垃圾），等待被垃圾回收器回收。

(2)当方法的参数类型是一个类的时候，可以使用匿名对象调用方法。

class Phone4{
    public void show(){
        System.out.println("手机可以打电话");
    }
}
class PhoneDemo{
    public void function(Phone4 p){
        p.show();
    }
}
public class AnonymousDemo {
    public static void main(String[] args) {
        //创建一个PhoneDemo对象
        PhoneDemo pd = new PhoneDemo();
        Phone4 phone = new Phone4();
        pd.function(phone);
        System.out.println("=============================");
        //当new完对象之后直接使用，没有用变量名接收的对象，称之为匿名对象
        new PhoneDemo().function(new Phone4());
        new PhoneDemo().function(new Phone4());
    }
}

9、形式参数的问题：

(1)当形式参数是基本数据类型的时候,将来调用方法的时候传入的是常量值,或者是该类型的变量

(2)当形式参数是引用数据类型的时候，将来调用方法的时候传入的是该类对象的地址值

(3)当形式参数是基本数据类型的时候，在方法中对变量做修改，不会影响到外部实际的栈内存中        的值。

(4)当形式参数是引用数据类型的时候，在方法中对变量做修改，会影响到外部实际的堆内存中的值。

class Demo2 {
    public int getSum(int a,int b) {
        a=100;
        b=200;
        return a + b;
    }
}
class Student2{
    String name;
    public void speak(){
        System.out.println("我热爱学习");
    }
}
class StudentTest2{
    /**
     * 如果将来你看到一个方法的形式参数是一个类的类型，说明他是一个引用数据类型
     * 这里其实需要的是该类的对象
     * 调用的时候，把main方法中创建好的对象名传过来，实际上传的就是对象的地址值
     * @param s
     */
    public void function(Student2 s){ //Student2 s = new Student2();
        s.name = "小王";
        s.speak();
    }
}
public class XingShiCanShuDemo {
    public static void main(String[] args) {
        Demo2 d = new Demo2();
        int a = 10;
        int b = 20;
        System.out.println(d.getSum(a,b));
        System.out.println("a:"+a+",b:"+b);
        //要想调用function(),就必须创建StudentTest2对象
        StudentTest2 st2 = new StudentTest2();
        Student2 student2 = new Student2();
        System.out.println(student2.name);
        st2.function(student2);
        System.out.println(student2.name);
    }
}

10、定义一个学生类，完成类的成员（成员变量和成员方法）

(1)分析：在一个java文件可以定义多个类，我们这里，就先定义基本的类，和测试类 将来编译的时候，JVM会读取java文件，有多少个class类，就编译生成多少个.class文件

(2)注意事项：一个java文件中只能有一个类被public修饰 只需要记住被public修饰的类规范是要与java文件名一致

(3)如何在测试类中使用学生类呢？

创建该类的对象去使用

(4)如何创建对象呢？创建对象的格式是什么呢？

类名 对象名称 = new 类名(..);

public class Student {
    //成员变量
    //姓名
    String name;
    //性别
    String gender;
    //年龄
    int age;
    //定义成员方法
    //学习
    public void study(){
        System.out.println("我热爱学习大数据");
    }
    //吃饭
    public void eat(){
        System.out.println("学习饿了，吃会东西");
    }
    //睡觉
    public void sleep(){
        System.out.println("学习类，睡一会觉");
    }
}
class StudentTest{
    public static void main(String[] args) {
//        System.out.println("HelloWorld");
        //如果不创建对象能不能使用呢？（指的是能否访问到成员变量或者成员方法）
//        System.out.println(name);

        //创建一个学生对象才能使用
        Student s1 = new Student();
        //这样我们就创建出一个学生对象s1
        //如何通过对象访问成员变量呢？
        //访问格式：对象名.成员变量名
        //访问s1对象的姓名是什么
//        s1.name; //访问到的变量值不能直接使用，应该用一个变量接收或者直接使用输出
        System.out.println(s1.name);   //null
        System.out.println(s1.gender); //null
        System.out.println(s1.age);    //0
        //如何给成员变量赋值
        s1.name = "wade";
        s1.gender = "男";
//        s1.age = "james "; //注意，赋值的时候，注意数据类型
        s1.age = 18;
        System.out.println(s1.name);
        System.out.println(s1.gender);
        System.out.println(s1.age);
        //如何去调用成员方法呢？
        //调用格式：对象名.成员方法名(...);
        s1.study();
        s1.eat();
        s1.sleep();
    }
}

11、（1）定义一个手机类：

      属性：品牌，价格，颜色

      行为：打电话，发信息，听音乐

      定义一个类：Phone

      成员变量：brand,price,color

      成员方法：call(String s),sendMessage(),listenMusic()

class Phone{
    //定义成员变量
    String brand;
    int price;
    String color;
    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }
    public void sendMessage(){
        System.out.println("发信息");
    }
    public void listenMusic(){
        System.out.println("听音乐");
    }
}
public class PhoneTest {
    public static void main(String[] args) {
        //根据手机类创建一个手机对象
        Phone p1 = new Phone();
        //通过创建出来的手机对象访问对象成员变量
        //创建对象另外一种说法：实例化
        System.out.println(p1.brand); //null
        System.out.println(p1.price); //0
        System.out.println(p1.color); //null
        //给对象的成员变量进行赋值
        p1.brand = "华为";
        p1.price = 9999;
        p1.color = "曜石黑";
        System.out.println("手机的品牌是："+p1.brand);
        System.out.println("手机的价格是："+p1.price);
        System.out.println("手机的颜色是："+p1.color);
        //通过对象调用成员方法
        p1.call("吴老板"); //注意，调用对象的成员方法的时候，需要注意是否要传参！
        p1.sendMessage();
        p1.listenMusic();
    }
}

（2）创建两个对象并赋值调用

//同一个包下，类名不能重复
class Phone1{
    //成员变量
    String brand;
    int price;
    String color;
    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }
    public void sendMessage(){
        System.out.println("发信息");
    }
    public void listenMusic(){
        System.out.println("听音乐");
    }
}
public class PhoneTest2 {
    public static void main(String[] args) {
        //定义一个手机类
        Phone1 p1 = new Phone1();
        //给手机对象p1成员变量赋值
        p1.brand = "小米";
        p1.price = 1999;
        p1.color = "白色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
        p1.call("雷军");
        p1.sendMessage();
        p1.listenMusic();
        //定义第二个手机对象
        Phone1 p2 = new Phone1();
        p2.brand = "苹果";
        p2.price = 4999;
        p2.color = "黑色";
        System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
        p2.call("乔布斯");
        p2.sendMessage();
        p2.listenMusic();
    }
}

（3）创建三个对象并赋值调用，其中有两个引用指向同一个对象

class Phone3{
    //成员变量
    String brand;
    int price;
    String color;
    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }
    public void sendMessage(){
        System.out.println("发信息");
    }
    public void listenMusic(){
        System.out.println("听音乐");
    }
}
public class PhoneTest3 {
    public static void main(String[] args) {
        //定义一个手机类
        Phone3 p1 = new Phone3();
        //给手机对象p1成员变量赋值
        p1.brand = "小米";
        p1.price = 1999;
        p1.color = "白色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
        p1.call("雷军");
        p1.sendMessage();
        p1.listenMusic();
        //定义第二个手机对象
        Phone3 p2 = new Phone3();
        p2.brand = "苹果";
        p2.price = 4999;
        p2.color = "黑色";
        System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
        p2.call("乔布斯");
        p2.sendMessage();
        p2.listenMusic();
        //创建第三个手机对象，将第一个对象名赋值给它
        Phone3 p3 = p1;
        p3.brand = "华为";
        p3.price = 19999;
        p3.color = "蓝色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
    }
}

12、封装（private）

       我们在定义一个学生类并使用的时候，发现了一个问题： 通过对象给成员变量赋值的时候，可以赋值一些非法的数据。 这样是不合理不符合现实生活的。 我们应该在赋值之前，做一次判断，数据校验，也就是对即将要赋值的数据做判断。 问题又来了，我们应该在哪里定义这个判断逻辑呢？ StudentDemo2是一个测试类，一般情况下，测试类负责创建对象并使用对象的地方，在这里定义判断逻辑是不合适的。 所以我们这里应该定义在Student3类中。 又因为，我们在定义成员变量的时候无法加入逻辑判断。 所以，我们在成员方法中定义。 因为做数据判断的时候，加的是一些逻辑判断语句，肯定不是只有一条。 我们应该在Student3类中提供一个方法来数据校验。 按照我们的想法，在类中提供了一个数值校验的方法，如果符合就成功赋值，反之则不赋值。 但是，谁规定了我定义了方法就一定会被使用呢，如果我还是用之前的获取成员变量的方式进行赋值，问题依旧存在 那么我们给出的方法意义就不是很大了。 实际上，我们应该定义了一个方法后，让调用必须使用我们的方法进行赋值，并且不能让调用者直接获取到我们成员变量。

怎么去强制要求不直接获取成员变量呢？ 针对这样的情况，java就提供了一个关键字：private private： 私有的。

其实说到现在，就是为了引出一个思想：封装

封装：其实就是隐藏对象的属性和相关的实现细节，仅仅对外提供公共的访问方式

class Student3 {
    //定义成员变量
    String name;
    private int age;
    public void setAge(int a){
        if(a<0 || a>200){
            System.out.println("您要传入的年龄数据有误，请重新赋值");
        }else{
            age = a;
        }
    }
    //定义一个输出所有的成员变量
    public void show() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }
}
public class StudentDemo2 {
    public static void main(String[] args) {
        //创建一个学生对象
        Student3 s = new Student3();
        s.show();
        //给对象的成员变量赋值
        s.name = "wade";
//        s.age = 18;
//        s.age = 10000;
//        s.setAge(10000);
        //age 在 com.shujia.wyh.day08.Student3 中是 private 访问控制
//        s.age = 10000; //由于我们在Student3类中name前面加了一个private关键字，不可以直接使用获取到成员变量，要想赋值，
                        //就必须使用我们提供的数据校验赋值方法
        s.setAge(10000);
        s.show();
    }
}

13、获取成员变量值的方法：

（1）提供一个公共的方法，打印所有的成员变量值

（2）单个使用公共的获取方法，一个一个获取打印（开发）

        原因：单个使用比一起使用的灵活度要高。

（3）private : 私有的。

        a、它可以修饰成员（成员变量和成员方法）

        b、被private修饰的成员只能在本类中访问使用。其他类中使用不了

class Person {
    //private修饰成员变量
    private String name;
    private int age;
    //提供一个公共set方法
    public void setName(String s) {
        name = s;
    }
    public void setAge(int a) {
        age = a;
    }
    //提供一个公共的get方法，让外界获取到成员变量值
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    //打印所有的成员变量值
    private void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }
    public void show2(){
        show();
    }
}
public class PrivateDemo1 {
    public static void main(String[] args) {
        Person p = new Person();
//        System.out.println();
        //调用公共的方法为成员变量进行赋值
        p.setName("小明");
        p.setAge(18);
//        p.show();
        p.show2();
        //调用公共的方法获取成员变量的值
        String name = p.getName();
        System.out.println(name);
        int age = p.getAge();
        System.out.println(age);
    }
}

14、练习：请把手机类写成一个标准类的格式，然后创建对象并测试

       手机类：

           成员变量：

                     品牌：String brand; 价格：int price; 颜色：String color;

           成员方法： 提供公共的getXxx()和setXxx()

                              提供一个方法查看手机详情

       测试类： 创建手机对象并测试（给成员变量赋值，取值）

class Phone2 {
    //定义成员变量
    private String brand;
    private int price;
    private String color;
    //提供公共的getXxx()和setXxx()方法
    public void setBrand(String s) {
        brand = s;
    }
    public String getBrand() {
        return brand;
    }
    public void setPrice(int p) {
        price = p;
    }
    public int getPrice() {
        return price;
    }
    public void setColor(String s) {
        color = s;
    }
    public String getColor() {
        return color;
    }
    //提供一个公共的方法打印手机详情
    public void show() {
        System.out.println("品牌：" + brand + ",价格：" + price + ",颜色：" + color);
    }
}
public class PrivateTest {
    public static void main(String[] args) {
        //创建一个手机对象
        Phone2 p = new Phone2();
        //给成员变量进行赋值
        p.setBrand("小米");
        p.setPrice(2999);
        p.setColor("黑色");
        //获取成员变量并打印
        //获取手机品牌
        String brand = p.getBrand();
        //获取手机对象p的价格
        int price = p.getPrice();
        //获取手机对象p的颜色
        String color = p.getColor();
        System.out.println("品牌：" + brand + ",价格：" + price + ",颜色：" + color);
        //调用方法打印所有的成员变量值
        p.show();
    }
}

15、规范定义一个类的标准版本1.0

(1)将成员变量使用private修饰

(2)提供公共getXxx()和setXxx()

(3)提供一个方法打印所有的成员变量值（先自己定义，后面我们会学习新的方法替代）

public class Teacher {
    //定义成员变量
    private String name;
    private int age;
    //提供公共的getXxx()和setXxx()方法
    public void setName(String s) {
        name = s;
    }
    public String getName() {
        return name;
    }
    public void setAge(int a) {
        age = a;
    }
    public int getAge(){
        return age;
    }
    //提供一个方法打印所有的成员变量值
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }
}
class TeacherTest{
    public static void main(String[] args){
        //创建一个老师对象
        Teacher t1 = new Teacher();
        //使用成员变量
        //不能直接获取，因为它们都被private修饰了
//        System.out.println(t1.name+"---"+t1.age);
        //通过公共的方法来获取成员变量
        System.out.println(t1.getName()+"---"+t1.getAge());
        //给成员变量赋值
        t1.setName("刘志城");
        t1.setAge(18);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.show();
    }
}

16、定义一个标准类的2.0版本

       成员变量：被private修饰

       成员方法：getXxx()和setXxx()，其中setXxx(..)形参的名字与成员变量名字一致，使用this关                             键字赋值 show()

     引出-------this关键字

class Doctor2 {
    private String name;
    private int age;
    private String gender;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name; //其实这里隐藏了一个this，但是我们也可以不写，因为就近原则取的就是对象的成员变量
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getGender() {
        return gender;
    }
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age + ",性别：" + gender);
    }
}
public class DoctorDemo2 {
    public static void main(String[] args) {
        //创建一个医生对象
        Doctor2 d = new Doctor2();
        //给成员变量进行赋值
        d.setName("阿杰");
        d.setAge(18);
        d.setGender("男");
        d.show();
    }
}

L缶神
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象（一）：类、抽象、对象
m0_57701510的博客
08-01 521
访问修饰符] class 类名{类的内部成员}定义一个手机类（示例1.0）
Java基础：17 面向对象特征（1）——封装
weixin_44306551的博客
12-22 106
1、封装的作用和含义
面向对象编程1（类与对象基本介绍）
weixin_927326的博客
02-11 659
如何定义一个类的成员变量以及成员方法 对象的内存图 成员变量与局部变量的区别 形式参数的问题 匿名对象的介绍
JAVA练习题30：添加手机对象并返回要求的数据
m0_46457497的博客
10-13 429
【代码】JAVA练习题30：添加手机对象并返回要求的数据。 需求： 1. 定义Javabean类：Phone 2. Phone属性：品牌，价格 3. main方法中定义一个集合，存入三个手机对象。分别为：小米，1000。苹果，8000。oppo , 2999。 4. 定义一个方法，将价格低于3000的收据信息返回。
8. Python 面向对象
qq_44378854的博客
09-16 4227
私有成员变量：变量名以__开头（2个下划线）私有成员方法：方法名以__开头（2个下划线）私有成员无法被。
Java学习（超详细）六（面向对象与封装）
jojo_oulaoula的博客
06-13 113
它是一个方法方法名与类名相同修饰符与方法名之间没有返回值，包括也不能有void方法名相同参数类型或是个数不同和返回值、修饰符无关注意:普通方法的重载和构造方法的重载条件相同//普通方法构成重载//条件：一定是多个方法之间才能构成重载//方法名相同，参数类型不同//方法名相同，参数个数不同//与返回值无关————》不构成重载//与修饰符无关————》不构成重载（1）隐藏 （2）方法 （3）控制语句。
java的面向对象基础（1） —— 封装
weixin_50546241的博客
08-29 499
java的面向对象基础（1） —— 封装
Java面向对象知识测试-A卷-答案.doc
11-15
面向对象是Java编程的核心概念，本测试主要涵盖了面向对象的基础知识，包括函数重写、类设计、封装、静态成员、抽象类与接口、构造函数等多个方面。以下是对这些知识点的详细解释： 1. 函数重写（Override）： - ...
java基础教程----精华版
09-22
以上只是Java基础知识的一部分，实际的Java基础教程会更深入地讲解每个概念，并配有实例来帮助理解。这份"java基础教程----精华版"应该涵盖了这些主题，并且可能还有更多的实践指导和示例代码，对于学习和巩固Java...
java-oo:面向对象的一些 Java 示例
06-07
封装是面向对象编程的基础原则之一，它隐藏了对象的内部实现细节，只对外提供公共接口。在Java中，我们使用访问修饰符（如public、private、protected）来控制类成员的可见性。这样可以防止外部代码直接修改对象的...
java-完美笔记-北京邮电大学.pdf
11-29
本笔记是北京邮电大学的一份 Java 笔记，涵盖了 Java 语言的基础知识、语法、面向对象编程、异常处理、多线程编程、IO 操作、网络编程、数据库编程等方面的内容。 Java 语言基础 Java 语言是由 Sun Microsystems ...
Java面向对象（基础）- 属性赋值过程、JavaBean和UML类图
10-24
【Java面向对象基础】属性赋值过程、JavaBean与UML类图 一、属性赋值过程 ...同时，讲解了JavaBean的基本概念和UML类图的构成，这些都是Java面向对象编程中的基础知识，对于理解和编写高质量的Java程序至关重要。
Java面向对象之封装及相关知识合集
二师兄想吃肉的博客
04-30 992
一、封装（Encapsulation） 1.封装的相关概念 2.封装的优点 3.封装实现步骤 二、private关键字 1.private的作用 2.private使用实例 三、this关键字 1.this的适用范围 2.this关键字的使用 四、构造方法 五、定义一个标准类(Java Bean) 1.标准类的组成 2.标准类示例
创建一个手机类 定义属性名称、型号、颜色、价格， 并定义打电话和听音乐的功能。在测试类中创建对象进行测试。
beyongboy的博客
03-15 4708
class Phone: def init(self,name,model,colour,money): self.name=name self.model=model self.colour=colour self.money=money def str(self): return “名称:%s ,型号:%s,颜色:,%s,价格:%s”%(self.name,self.model,self.co...
Java面向对象基础（Object Oriented）
oholie的博客
09-13 339
简介 面向对象简称 OO（Object Oriented），20 世纪 80 年代以后，有了面向对象分析 OOA（Object Oriented Analysis）、 面向对象设计 OOD （Object Oriented Design）、面向对象程序设计 OOP（Object Oriented Programming）等新的系统开发方式模型的研究。 一，对象（Object）是什么？ 对象的定义...
创建一个继承和重写的手机类
happy_lol的博客
03-26 933
创建一个继承和重写的手机类 首先，创建手机的父类 public class Phone { public void sendMessage(){ System.out.println(“发短信”); } public void call(){ System.out.println(“打电话”); } public void showNum(){ System.out.println(“来电显示号码...
手机类对象的创建和使用
Ss950410的博客
01-31 991
package Phone; /* 创建对象 格式：类名 对象名 = new 类名(); 范例：Phone p = new Phone(); 使用对象 ①：使用成员变量 格式：对象名.变量名 范例：p.brand ②：使用成员方法 格式：对象名.方法名() 范例：p.call() */ public class PhoneDemo { //因为是要创建对象和使用
编写一个手机类，包括手机品牌、手机型号， 方法包括显示手机信息，并编写测试类进行对象的创建
zninini1的博客
01-03 6296
//编写一个手机类，包括手机品牌、手机型号，  方法包括显示手机信息，并编写测试类进行对象的创建 package sjpp; public class Mobile {// 定义Mobile类 String brand, type;// 成员变量 public void information() {// 成员方法 System.out.println(ty
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 539
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
"面向对象技术Java-期末复习试卷(三)单项选择题解析
面向对象技术Java-期末复习试卷(三).docx是一份涵盖了面向对象技术的Java编程语言的期末复习试卷。该试卷涵盖了多个单项选择题，以下是其中的两道题目： 1、有一段java应用程序，其中包含一个公共类，名字为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值