Java基础——面向对象（一）

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

目录

一、类和对象

1、面向过程和面向对象

面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，以函数为最小单位，考虑怎么做。

面向对象：注重找“参与者”,将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

例：人把大象装进冰箱：

  • 面向过程：
    函数1：打开冰箱(){人站在冰箱前，打开冰箱，冰箱卡到30度角的时候，冰箱的灯打开了…}
    函数2：储存大象(){大象先迈左腿，再迈右退，考虑冰箱能不能装下…}
    函数3：关闭冰箱(){人站在冰箱前，关闭冰箱，冰箱开到30度角的时候，冰箱的灯关闭了…}
  • 面向对象：
    人{
     打开（冰箱）{
      冰箱.打开（）；
     }
     存储（大象）{
      大象.进入（）；
     }
     关闭（冰箱）{
      冰箱.关闭（）；
     }
    }
    冰箱{
     
    }
    大象{
     
    }

面向过程 —> 面向对象 , 其实就是由执行者 —> 指挥者的一个过渡。面向过程是编年体，面向对象是纪传体。二者相辅相成，并不是对立的。解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析整个系统；具体到微观操作，仍然使用面向过程方式来处理。

2、类和对象

类和对象

  • 万事万物皆对象
  • 对象：具体的事物，具体的实体，具体的实例，模板下具体的产品
  • 类：对对象向上抽取出公共的部分，形成类，类是抽象的，是一个模板
  • 一般在写代码的时候先写类，然后再根据类创建对应的对象。

面向对象三个阶段：

  1. 面向对象分析OOA — Object Oriented Analysis
    对象：张三，王五，朱六，你，我
    抽取出一个类 —> 人类
    类里面有什么：
    动词 —> 动态特性 —> 方法
    名词 —> 静态特性 —> 属性
  2. 面向对象设计OOD – Object Oriented Design
    先有类，再有对象：
    类：人类： Person
    对象：zhangsan ，lisi，zhuliu
  3. 面向对象编程OOP – Object Oriented Programming

创建类：

  1. 属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
  2. 方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
package com.msb;
public class Person {
    //名词 ——> 属性 ——> 成员变量 ——> 放在类中方法外（注意：我们只把有需要的内容写到代码里，不相关的东西不要放在代码中）
    int age ;//年龄
    String name;//姓名
    double height;//身高
    double weight;//体重
    //动词 ——> 方法
    //吃饭:
    public void eat(){
        int num = 10;//局部变量：放在方法中,要初始化！！
        System.out.println("我喜欢吃饭");
    }
    //睡觉：
    public void sleep(String address){
        System.out.println("我在"+address+"睡觉");
    }
    //自我介绍：
    public String introduce(){
        return "我的名字是："+name+"，我的年龄是："+age+",我的身高是："+height+",我的体重是："+weight;
    }
}

创建对象：

public class Test {//测试类
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个人类的具体的对象/实例：
        //创建一个对象，对象的名字叫：zs
        //Person 属于 **引用数据类型**
        //第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
        Person zs = new Person();
        zs.name = "张三";
        zs.age = 19;
        zs.height = 180.4;
        zs.weight = 170.4;
        //再创建一个对象：
        //再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次
        Person ls = new Person();
        ls.name = "李四";
        ls.age = 18;
        ls.height = 170.6;
        ls.weight = 160.5;
        //对属性值进行读取：
        System.out.println(zs.name);
        System.out.println(ls.age);
        //对方法进行操作：
        //不同的对象，属性有自己的特有的值，但是方法都是调用类中通用的方法。
        //属性：各个对象的属性是独立的，
        //方法：各个对象的方法是共享的。
        zs.eat();
        ls.eat();
        zs.sleep("教室");
        /*String str = zs.introduce();
        System.out.println(str);*/
        System.out.println(zs.introduce());
    }
}

3、成员变量和局部变量

成员变量和局部变量的区别：

  1. 代码中位置不同
    成员变量：类中方法外定义的变量
    局部变量：方法中定义的变量 代码块中定义的变量
  2. 代码的作用范围
    成员变量：当前类的很多方法
    局部变量：当前一个方法（当前代码块）
  3. 是否有默认值
    成员变量：有
    局部变量：没有
  4. 是否要初始化
    成员变量：不需要，不建议初始化，后续使用的时候再赋值即可
    局部变量：一定需要，不然直接使用的时候报错
  5. 内存中位置不同
    成员变量：堆内存
    局部变量：栈内存
  6. 作用时间不同
    成员变量：当前对象从创建到销毁
    局部变量：当前方法从开始执行到执行完毕

二、构造器

public class Person {
    //构造器：没有任何参数的构造器我们叫做：空参构造器 —> 空构造器
    public Person(){
        /*age = 19;
        name = "lili";
        height = 169.5;*/
    }
    //属性：
    String name;
    int age;
    double height;
    //方法：
    public void eat(){
        System.out.println("我喜欢吃饭");
    }
}

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Person类的具体的对象/实例/实体：
                Person p = new Person();
        System.out.println(p.age);
        System.out.println(p.name);
        System.out.println(p.height);
        Person p2 = new Person();
        System.out.println(p2.age);
        System.out.println(p2.name);
        System.out.println(p2.height);
    }
}

创建对象的过程：

  1. 第一次遇到Person的时候，进行类的加载（只加载一次）
  2. 创建对象，为这个对象在堆中开辟空间
  3. 为对象进行属性的初始化动作

new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）。
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
可以自己显式地将构造器编写出来：
构造器的格式：
[修饰符] 构造器的名字(){
}

构造器和方法的区别：

  1. 没有方法的返回值类型
  2. 方法体内部不能有return语句
  3. 构造器的名字很特殊，必须跟类名一样

构造器的作用：
不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。
调用构造器的目的是给属性进行赋值操作的。
注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。
实际上，我们只要 保证空构造器的存在 就可以了，里面的东西不用写

构造器的重载：

  1. 一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
  2. 一般我们会重载构造器，在重载的构造器中进行属性赋值操作
  3. 在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。
  4. 当形参名字和属性名字重名的时候，会出现就近原则：
    在要表示对象的属性前加上 this. 来修饰 ，因为this代表的就是你创建的那个对象
public class Person {
    //属性：
    String name;
    int age;
    double height;
    //空构造器
    public Person(){
    
    }
    public Person(String name,int age,double height){
        this.name = name;
        this.age = age;
        this.height = height;
    }
    public Person(String a,int b){
        name = a;
        age = b;
    }
    //方法：
    public void eat(){
        System.out.println("我喜欢吃饭");
    }
}

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Person p = new Person();
        /*p.age = 19;
        p.name = "lili";
        p.height = 180.4;*/
        Person p2 = new Person("lili",19,180.4);
        System.out.println(p2.age);
        System.out.println(p2.height);
        System.out.println(p2.name);
    }
}

三、内存分析

 public class Person {
        int  id;
        int  age;
        public static void main(String args[]){
                Person p1= new Person();
        }
}

在这里插入图片描述

public class Person {
        int id;
        int age;
        String school;
        public Person (int a,int b,String c){
                id=a;
                age=b;
                school=c;
        }
        public static void main(String args[]){
                Person p= new Person(1,20, "海淀");
        }
}

在这里插入图片描述

class Person{
        int id;
        int age;
        String school;
        Person (int a,int b,String c){
                id=a;
                age=b;
                school=c;
        }

        public void setAge(int a){
                age=a;
        }
}
public class Test {
    public static void main(String[] args) {
                  Test t=new Test();
                  int age=40;
                  Person tom=new Person(1,20,"海淀");
                  Person jack=new Person(2,30,"朝阳");
                  t.change1(age);
                  t.change2(tom);
                  t.change3(jack);
                  System.out.println(age); //40
                  System.out.println("id:"+jack.id+",age:"+jack.age+",school:"+jack.school); //id:2,age:66,school:"朝阳"
    }
    public void change1(int i){
                i=3366;
    }

    public void change2(Person p){
              p=new Person(3,22,"西城");
    }

    public void change3(Person p){
        p.setAge(66);
    }

}

在这里插入图片描述

四、this

1、创建对象的过程

  1. 在第一次遇到一个类的时候，对这个类要进行加载，只加载一次
  2. 创建对象，在堆中开辟空间
  3. 对对象进行初始化操作，属性赋值都是默认的初始值
  4. new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值

在这里插入图片描述
在这里插入图片描述
this指代的就是当前对象
在这里插入图片描述

2、this的用法

  1. 修饰属性：
    当属性名字和形参发生重名的时候，或者属性名字和局部变量重名的时候，都会发生 就近原则 ，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this. 修饰
public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age ——> 局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }
}
  1. 修饰方法：
    在同一个类中，方法可以互相调用，this. 可以省略不写。
public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    /*public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age ——> 局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }*/
    public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("洗澡");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("吃饭");
    }
}
  1. 修饰构造器：
    同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行
public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this(age,name);
        this.height = height;
    }
    public Person(int age,String name){
        this(age);
        this.name = name;
    }
    public Person(int age){
        this.age = age;
    }
    //方法：
    /*public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age ——> 局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }*/
    public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("洗澡");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("吃饭");
    }
}

五、static

1、static修饰属性

public class Test {
    //属性：
    int id;
    static int sid;
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Test类的具体的对象
        Test t1 = new Test();
        t1.id = 10;
        t1.sid = 10;
        Test t2 = new Test();
        t2.id = 20;
        t2.sid = 20;
        Test t3 = new Test();
        t3.id = 30;
        t3.sid = 30;
        //读取属性的值：
        System.out.println(t1.id);
        System.out.println(t2.id);
        System.out.println(t3.id);
        System.out.println(t1.sid);
        System.out.println(t2.sid);
        System.out.println(t3.sid);
    }
}

内存分析：
在这里插入图片描述
总结：

  1. 在类加载的时候一起加载入方法区中的静态域中
  2. 先于对象存在
  3. 访问方式： 对象名.属性名 类名.属性名（推荐）
  4. 应用场景：某些特定的数据想要在内存中共享，只有一块 —> 这个情况下，就可以用static修饰的属性
  5. 静态属性 （类变量）
    非静态属性（实例变量）

2、static修饰方法

public class Demo {
    int id;
    static int sid;
    public void a(){
        System.out.println(id);
        System.out.println(sid);
        System.out.println("------a");
    }
    //1.static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
    static public void b(){
        //System.out.println(this.id);//4.在静态方法中不能使用this关键字
        //a();//3.在静态方法中不能访问非静态的方法
        //System.out.println(id);//2.在静态方法中不能访问非静态的属性
        System.out.println(sid);
        System.out.println("------b");
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //5.非静态的方法可以用对象名.方法名去调用
        Demo d = new Demo();
        d.a();
        //6.静态的方法可以用   对象名.方法名去调用  也可以 用  类名.方法名 （推荐）
        Demo.b();
        d.b();
        /*在同一个类中可以直接调用
        b();*/
    }
}

总结:

  1. static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
  2. 在静态方法中
    不能访问非静态的属性
    不能访问非静态的方法
    在静态方法中不能使用this关键字
  3. 非静态的方法可以用对象名.方法名去调用
    静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐）。在同一个类中可以直接调用
  4. 静态在类加载的时候一起加载入方法区中的静态域中，先于对象存在，所以会导致上述情况

六、代码块

public class Test {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }
        //System.out.println(num);
        //if(){}
        //while(){}
    }
    public static void b(){
        System.out.println("------b");
    }
    //构造块
    {
        System.out.println("------这是构造块");
    }
    //静态块
    static{
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test(){
        System.out.println("这是空构造器");
    }
    public Test(int a){
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

总结：
代码块的执行顺序：

  1. 最先执行静态块，只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂、数据库的初始化信息都放入静态块。一般用于执行一些全局性的初始化操作；
  2. 再执行构造块；
  3. 再执行构造器；
  4. 再执行方法中的普通块。

七、包、import

包的作用： 为了解决重名问题（实际上包对应的就是盘符上的目录），解决权限问题

包的定义：

  1. 名字全部小写，中间用 . 隔开
  2. 一般都是公司域名倒着写 ：
    com.jd com.msb
  3. 加上模块名字：
    com.jd.login com.jd.register
  4. 不能使用系统中的关键字：nul,con,com1—com9…
  5. 包声明的位置一般都在非注释性代码的第一行：

import：

//声明包：
package com.msb7;
import com.msb2.Person; //导包：就是为了进行定位
import java.util.Date;
/**
 1. @Auther: msb-zhaoss
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        new Person();
        new Date();
        new java.sql.Date(1000L);//在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
        new Demo();
    }
}
  1. 使用不同包下的类要需要导包： import …;
    例如：import java.util.Date;
  2. 在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
  3. 同一个包下的类想使用不需要导包，可以直接使用。
  4. 在java.lang包下的类，可以直接使用无需导包：
    例如：Math.random();
  5. IDEA中导包快捷键：alt+enter
    可以自己设置自动导包
  6. 可以直接导入*
  7. 在Java中的导包没有包含和被包含的关系：
    设置目录平级的格式（不是包含和被包含的显示）：
    在这里插入图片描述在这里插入图片描述

静态导入：（没必要

package com.msb11;
//静态导入：
import static java.lang.Math.*;
//导入：java.lang下的Math类中的所有静态的内容
/**
 * @Auther: msb-zhaoss
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
    public static int round(double a){
        return 1000;
    }
}
行星波动、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础——面向对象基础（一）
Clannad191的博客
05-10 2550
文章目录一、Java面向对象学习的三条主线（第4-6章）：二、面向过程 vs 面向对象：三、使用"面向对象分析方法"分析问题的思路和步骤：四、面向对象的两个要素：4.1、设计类，其实就是设计类的成员4.2、类和对象的使用（面向对象思想落地的实现）五、对象的内存解析5.1、JVM内存详细图5.2、对象的内存解析 一、Java面向对象学习的三条主线（第4-6章）： Java类及类的成员：属性、方法、...
java初级基础——面向对象—案例：用户注册登录
Daw3on的博客
10-14 2926
java是面向对象的语言 概念点： 面向对象 面向过程 面向过程：将现实生活中的事物 按照发生的顺序使用代码顺序执行 面向对象：将现实生活中的事物，封装成对象，通过对象的实例化和调用，完成需求 重要概念 ： 抽象(暂讲一个) ： 将现实中的事物 抽取外部特征和方法 。使用类来表示 课题案例： 1.通过面向对象的思维 完成登陆注册系统 ； 1.1用户需要输入用户名 密码进行验证 1.2由登陆系统给出...
Java基础——面向对象（综合案例）
D_ar_ker的博客
03-11 2327
Java面向对象综合运用实例
Java基础——面向对象（一）封装
狄利克雷的博客
01-01 2616
面向对象索引： Java基础——面向对象（二）继承 Java基础——面向对象（三）抽象类 Java基础——面向对象（四）接口 Java基础——面向对象（五）多态 Java基础——面向对象（六）内部类 Java基础——面向对象（七）Object类 目录 一、什么是面向对象？怎么理解面向对象？ 二、封装 三、this关键字 四、static关键字 一、什么是面向对象？怎么理解面...
JAVA基础——面向对象程序设计的四大特性
weixin_42486795的博客
06-16 6274
1.封装性 面向对象的第一个原则是把数据和对该数据的操作都封装到一个类中，类的概念和现实世界的“事务种类”是一致的。 如电视机就是一个类，每台电视机都有尺寸、品牌，这些性能被封装成类的属性，每台电视机都可以开关电视、播放电视节目，这些行为动作被封装成类的方法。 对象是类的一个实例化结果，对象具有类所描述的所有属性及方法，是具体的。 每个对象都属于某个类，面向对象程序设计就是设计好相关的类，类中有属...
Java基础——面向对象(复习)
weixin_49405762的博客
08-12 431
面向对象汇总
Java基础——类和对象
热门推荐
explorer363的博客
04-26 3万+
本篇博客介绍了Java中类和对象的基本内容，看完本篇博客后，希望大家能对类和对象能有进一步的了解
Java学习——面向对象编程思想
weixin_53919192的博客
05-25 1765
本文向大家介绍了面对对象的基本概念、面向对象与面向过程的区别、面向对象程序设计的类与对象、面向对象的四大特征：抽象、继承、封装、多态、实现多态性的三种方式：重载、重写、接口、 面向对象思想优点、面向对象思想总结、三大特征、五种关系、七大原则，希望对你有用~~
Java学习——面向对象思维导图（简单总结）
weixin_38346215的博客
08-31 1070
Java——面向对象初阶
qq_59599094的博客
11-11 1067
Java类和对象
Java基础——面向对象编程
05-06
Java基础——面向对象编程 面向对象编程（Object-Oriented Programming，OOP）是一种编程方法，它将现实世界中的对象抽象出来，并使用计算机模型来描述。面向对象编程的核心概念是类（class）和实例（instance）。...
java基础——入门篇
07-14
Java的特点包括“一次编写，到处运行”（Write Once, Run Anywhere）、面向对象、健壮性、安全性、高效性和可移植性。 5. 程序类型： Java程序主要分为两类：应用程序（Application）和小程序（Applet）。应用...
java基础之面向对象编程
02-20
Java是一种广泛使用的面向对象编程语言，其面向对象的特性使得代码更加模块化、易于理解和维护。面向对象编程（OOP）的核心概念包括类、封装、继承和多态性。 1. **类**： 类是面向对象编程的基础，它是创建对象的...
java基础篇——java的起源与演变
07-14
Java作为一门纯面向对象的编程语言，其核心特性包括跨平台能力，这意味着Java源代码可以在任何安装了Java运行时环境（JRE）的平台上编译和运行。这得益于Java的字节码机制和Java虚拟机（JVM）。Java虚拟机是JRE的一...
Java面向对象项目——潜艇游戏
08-27
java面向对象项目——潜艇游戏，另外一个较为典型的实战项目，能够很好的帮助初学者更好的理解面向对象的思想以及对java基础知识的巩固。
配置Java开发环境
Broken_x的博客
07-10 1591
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 545
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 292
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 375
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
JAVA面试试题集，很不错哦
01-18
总结起来，"Java面试题集"是一本很不错的面试辅助书籍，它包含了许多有关Java面向对象特性和字符串操作的详细信息。通过阅读这本书，我能够更好地理解Java面向对象的概念，并且在面试和笔试中表现得更加自信和专业。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值