Java学习笔记 五、面向对象编程基础部分

已于 2022-03-18 19:32:23 修改
阅读量832 收藏
点赞数 1
分类专栏： Java学习笔记 文章标签： java 开发语言 后端 学习
于 2022-03-18 19:31:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43681634/article/details/123582714
版权

Java学习笔记 五、面向对象编程基础部分

如何创建对象

  1. 先声明再创建
    Cat cat ; //声明对象 cat
    cat = new Cat(); //创建
  2. 直接创建
    Cat cat = new Cat();

如何访问属性

基本语法:对象名.属性名;
cat.name ;

属性/成员变量/字段

属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。

注意事项和细节说明

  1. 属性的定义语法同变量，示例：访问修饰符 属性类型 属性名;
    绍访问修饰符： 控制属性的访问范围
    有四种访问修饰符 public, protected, 默认, private
  2. 属性的定义类型可以为任意类型，包含基本类型或引用类型
  3. 属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
public class PropertiesDetail {

    public static void main(String[] args) {
    //创建 Person 对象
    //p1 是对象名(对象引用)
    //new Person() 创建的对象空间(数据) 才是真正的对象
    Person p1 = new Person();

    //对象的属性默认值，遵守数组规则:
    //int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
    System.out.println("\n 当前这个人的信息");
    System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
    }
}

class Person {
    //四个属性
    int age;
    String name;
    double sal;
    boolean isPass;
}

类和对象在内存中存在形式

在这里插入图片描述

类和对象的内存分配机制

Java 内存的结构分析

  1. 栈： 一般存放基本数据类型(局部变量)
  2. 堆： 存放对象(Cat cat , 数组等)
  3. 方法区：常量池(常量，比如字符串)， 类加载信息

Java 创建对象的流程简单分析

Person p = new Person();
p.name = “jack”;
p.age = 10

  1. 先加载 Person 类信息(属性和方法信息, 只会加载一次)
  2. 在堆中分配空间, 进行默认初始化(看规则)
  3. 把地址赋给 p , p 就指向对象
  4. 进行指定初始化， 比如 p.name =”jack” p.age = 10

成员方法

访问修饰符 返回数据类型 方法名（形参列表..） {//方法体
	语句；
	return 返回值;
}
  1. 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)。
  2. 返回数据类型：表示成员方法输出, void 表示没有返回值。
  3. 方法主体：表示为了实现某一功能代码块。
  4. return 语句不是必须的。。

成员方法的好处

  1. 提高代码的复用性。
  2. 可以将实现的细节封装起来，然后供其他用户来调用即可。

成员方法注意事项和使用细节

访问修饰符 (作用是控制 方法使用的范围)

  1. 如果不写默认访问，[有四种: public, protected, 默认, private]

返回数据类型

  1. 一个方法最多有一个返回值
  2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
  3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
    而且要求返回值类型必须和 return 的值类型一致或兼容
  4. 如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;

方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可

形参列表

  1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，
    比如getSum(int n1,int n2)
  2. 参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(intD[] map)
  3. 调用带参数的方法时， 一 定对应着参数列表传入相同类型或兼容类型的参数
  4. 方法定义时的参数称为形式参数，简称形参;
    方法调用时的传入参数称为实际参数，简称实参，
    实参和形参的类型要一致或兼容、 个数、顺序必须一致

方法体
里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，
但里面不能再定义方法!即:方法不能嵌套定义。

public class MethodDetail {

    public static void main(String[] args) {
        AA a = new AA();
        int[] res = a.getSumAndSub(1, 4);
        System.out.println("和=" + res[0]);
        System.out.println("差=" + res[1]);
        //调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
        byte b1 = 1;
        byte b2 = 2;
        a.getSumAndSub(b1, b2);//byte -> int
        //a.getSumAndSub(1.1, 1.8);//double ->int(false)
        //实参和形参的类型要一致或兼容、个数、顺序必须一致

        //a.getSumAndSub(100);//false 个数不一致
        a.f3("tom", 10); //ok
        //a.f3(100, "jack"); //false 实际参数和形式参数顺序不对
    }
}

class AA {

    //方法不能嵌套定义
    public void f4() {
        //错误
        // public void f5() {
        // }
    }
    public void f3(String str, int n) {
    }

    //一个方法最多有一个返回值 [如何返回多个结果 返回数组 ]
    public int[] getSumAndSub(int n1, int n2) {
        int[] resArr = new int[2]; //
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }

    //2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)

    //3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
    // 而且要求返回值类型必须和 return 的值类型一致或兼容
    public double f1() {
        double d1 = 1.1 * 3;
        int n = 100;
        return n; // int ->double
        //return d1; //ok? double -> int
    }
    //如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
    //方法名要有一定含义，最好是见名知意
    public void f2() {
        System.out.println("hello1");
        System.out.println("hello1");
        System.out.println("hello1");
        int n = 10;

        //return ;
    }
}

方法调用细节说明

  1. 同一个类中的方法调用:直接调用即可。;
  2. 跨类中的方法A类调用B类方法:需要通过对象名调用。
    比如对象名.方法名(参数)
  3. 跨类的方法调用和方法的访问修饰符相关
public class MethodDetail02 {
    
    public static void main(String[] args) {
        A a = new A();
        //a.sayOk();
        a.m1();
    }
}

class A {
    //同一个类中的方法调用：直接调用即可
    public void print(int n) {
        System.out.println("print()方法被调用 n=" + n);
    }
    public void sayOk() { //sayOk 调用 print(直接调用即可)
        print(10);
        System.out.println("继续执行 sayOK()~~~");
    }

    //跨类中的方法 A 类调用 B 类方法：需要通过对象名调用
    public void m1() {
    //创建 B 对象, 然后在调用方法即可
        System.out.println("m1() 方法被调用");
        B b = new B();
        b.hi();
        System.out.println("m1() 继续执行:)");
    }
}

class B {
    public void hi() {
        System.out.println("B 类中的 hi()被执行");
    }
}

成员方法传参机制

基本数据类型的传参机制

基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参。

引用数据类型的传参机制

引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参。

方法递归调用

递归就是方法自己调用自己

递归规则

  1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
  2. 方法的局部变量是独立的，不会相互影响
  3. 如果方法中使用的是引用类型变量(比如数组，对象)，就会共享该引
    用类型的数据
  4. 递归必须向退出递归的条件逼近，否则就是无限递归,
    出现StackOverflowError
  5. 当一个方法执行完毕，或者遇到return, 就会返回，遵守谁调用，就
    将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行
    完毕。

方法重载

java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println()
好处：
1.减轻了起名的麻烦
2.减轻了记名的麻烦

方法重载的注意事项和使用细节

  1. 方法名:必须相同
  2. 形参列表:必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
  3. 返回类型:无要求
public class OverLoad {
    //编写一个 main 方法
    public static void main(String[] args) {

    MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}

class MyCalculator {
    //下面的四个 calculate 方法构成了重载
    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }

    //没有构成方法重载, 仍然是错误的，因为是方法的重复定义
    // public void calculate(int n1, int n2) {
    //  System.out.println("calculate(int n1, int n2) 被调用");
    //  int res = n1 + n2;
    // }

    //没有构成，而是方法的重复定义,错了
    // public int calculate(int a1, int a2) {
    //  System.out.println("calculate(int n1, int n2) 被调用");
    //  return a1 + a2;
    // }

    //一个整数，一个 double 的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }

    //一个 double ,一个 Int 的和
    public double calculate(double n1, int n2) {
        System.out.println("calculate(double n1, int n2) 被调用..");
        return n1 + n2;
    }
    
    //三个 int 的和
    public int calculate(int n1, int n2,int n3) {
        return n1 + n2 + n2;
    }
}

可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现
基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) {}

可变参数注意事项和使用细节

  1. 可变参数的实参可以为0个或任意多个。
  2. 可变参数的实参可以为数组。
  3. 可变参数的本质就是数组.
  4. 可变参数可以和普通类型的参数一 起放在形参列表，但必须保证可变参数在最后
  5. 一个形参列表中只能出现一个可变参数
public class VarParameterDetail {

    public static void main(String[] args) {
    //可变参数的实参可以为数组
    int[] arr = {1, 2, 3};
    T t1 = new T();
    t1.f1(arr);
    }
}

class T {
    public void f1(int... nums) {
        System.out.println("长度=" + nums.length);
    }
    //可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) {}

    //一个形参列表中只能出现一个可变参数
    //下面的写法是错的. 
    // public void f3(int... nums1, double... nums2) {
    // }
}

作用域

  1. 在java编程中，主要的变量就是属性(成员变量)和局部变量。
  2. 我们说的局部变量一般是指在成员方法中定义的变量。
  3. java中作用域的分类
    全局变量:也就是属性，作用域为整个类体
    局部变量:也就是除了属性之外的其他变量，作用域为定义它的代码块中
  4. 全局变量(属性)可以不赋值，直接使用，因为有默认值，
    局部变量必须赋值后，才能使用，因为没有默认值。

作用域的注意事项和使用细节

  1. 属性和局部变量可以重名，访问时遵循就近原则。
  2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
  3. 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
    局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
  4. 作用域范围不同
    全局变量/属性:可以被本类使用，或其他类使用(通过对象调用)
    局部变量:只能在本类中对应的方法中使用
  5. 修饰符不同
    全局变量/属性可以加修饰符
    局部变量不可以加修饰符
public class VarScopeDetail {

    public static void main(String[] args) {
        Person p1 = new Person();
        /*
        属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
        局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中
        */
        //p1.say();//当执行 say 方法时，say 方法的局部变量比如 name,会创建，当 say 执行完毕后
        //name 局部变量就销毁,但是属性(全局变量)仍然可以使用

        T t1 = new T();
        t1.test(); //第 1 种跨类访问对象属性的方式
        t1.test2(p1);//第 2 种跨类访问对象属性的方式
    }
}

class T {
    //全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
    public void test() {
        Person p1 = new Person();
        System.out.println(p1.name);//jack
    }
    public void test2(Person p) {
        System.out.println(p.name);//jack
    }
}

class Person {
    //属性可以加修饰符(public protected private..)
    //局部变量不能加修饰符
    public int age = 20;
    String name = "jack";
    public void say() {
        //属性和局部变量可以重名，访问时遵循就近原则
        String name = "king";
        System.out.println("say() name=" + name);
    }
    public void hi() {
        String address = "北京";
        //String address = "上海";//错误,重复定义变量
        String name = "hsp";//可以
    }
}

构造方法/构造器

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

  1. 方法名和类名相同
  2. 没有返回值
  3. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
[修饰符] 方法名(形参列表){
	方法体;
}
  1. 构造器的修饰符可以默认， 也可以是 public protected private
  2. 构造器没有返回值
  3. 方法名 和类名字必须一样
  4. 参数列表 和 成员方法一样的规则
  5. 构造器的调用, 由系统完成

构造方法/构造器注意事项和使用细节

  1. 一个类可以定义多个不同的构造器，即构造器重载
  2. 构造器名和类名要相同
  3. 构造器没有返回值
  4. 构造器是完成对象的初始化，并不是创建对象
  5. 在创建对象时,系统自动的调用该类的构造方法
  6. 如果程序员没有定义构造器，系统会自动给类生成个默认无参构造器(也
    叫默认构造器)
  7. 一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无
    参构造器，除非显式的定义一下
public class ConstructorDetail {

    public static void main(String[] args) {
        Person p1 = new Person("king", 40);//第 1 个构造器
        Person p2 = new Person("tom");//第 2 个构造器
        Dog dog1 = new Dog();//使用的是默认的无参构造器
    }
}

class Dog {
    //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
    //使用 javap 指令 反编译看看
    /*
    默认构造器
    Dog() {
    }
    */
    //一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
    //除非显式的定义一下,即: Dog(){} 写 (这点很重要)
    //
    //public Dog(String dName) {
    //... }
    //Dog() { //显式的定义一下 无参构造器
    //}
}

class Person {
    String name;
    int age;//默认 0
    //第 1 个构造器
    public Person(String pName, int pAge) {
        name = pName;
        age = pAge;
    }
    //第 2 个构造器, 只指定人名，不需要指定年龄
    public Person(String pName) {
        name = pName;
    }
}

对象创建的流程分析

在这里插入图片描述

this关键字

哪个对象调用，this就代表哪个对象

this的注意事项和使用细节

  1. this 关键字可以用来访问本类的属性、方法、构造器
  2. this 用于区分当前类的属性和局部变量
  3. 访问成员方法的语法：this.方法名(参数列表);
  4. 访问构造器语法：this(参数列表); 注意只能在构造器中使用
    (即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
  5. this 不能在类定义的外部使用，只能在类定义的方法中使用。

public class ThisDetail { 

	public static void main(String[] args) {
		// T t1 = new T();
		// t1.f2();
		T t2 = new T();
		t2.f3();
	}
}

class T {
	String name = "jack";
	int num = 100;
	/*
	访问构造器语法：this(参数列表); 
	注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)
	注意： 访问构造器语法：this(参数列表); 必须放置第一条语句 
	 */
	public T() {
		//这里去访问 T(String name, int age) 构造器
		this("jack", 100);
		System.out.println("T() 构造器");
	}

	public T(String name, int age) {
		System.out.println("T(String name, int age) 构造器");
	}

	//this关键字可以用来访问本类的属性
	public void f3() {
		String name = "smith";
		//传统方式
		System.out.println("name=" + name + " num=" + num);//smith  100
		//也可以使用this访问属性
		System.out.println("name=" + this.name + " num=" + this.num);//jack 100
	}

	//访问成员方法的语法：this.方法名(参数列表);
	public void f1() {
		System.out.println("f1() 方法..");
	}

	public void f2() {
		System.out.println("f2() 方法..");
		//调用本类的 f1
		//第一种方式
		f1();
		//第二种方式
		this.f1();
	}
}
XD Wen
关注
专栏目录
Java 基础 第2阶段：面向对象编程-尚硅谷学习笔记（含面试题） 2023年
05-09
面向对象编程是Java的核心特性，本学习笔记涵盖了这一主题的深度探索，旨在帮助开发者深入理解并熟练运用面向对象的思想。2023年的版本更新可能包含最新的面试趋势和技术发展。以下将详细介绍Java面向对象编程的一些...
Java基础&&java面向对象编程
04-16
Java是一种广泛使用的高级...李兴华老师的笔记可能详细介绍了这些概念，并通过实例深入浅出地讲解了Java基础和面向对象编程，包括Java 8的新特性。通过学习这些内容，开发者能够更好地理解和应用Java，提高编程技能。
JAVA学习（五）：Java面向对象编程基础
成长Bar的博客专栏
07-05 1710
Java面向对象编程基础 面向对象（Object oriented programming，OOP）技术是一种强有力的软件开发方法，它采用数据抽象与信息隐藏技术，来使软件开发简单化，以达到代码重用的目的。 1、OOP的3个特性（封装、继承和多态性） 封装是类的基础，指把类的相关实现细节隐藏起来，在类中将数据和实现操作的代码集中起来放在对象的内部，调用这些类时只需直接使
《Java面向对象程序设计》学习笔记
weixin_45940369的博客
07-31 8672
备考某学校的 817程序设计Java 专业课，在学习耿祥义老师的《Java面向对象程序设计（第3版）-微课视频版》。 发一些自己的学习笔记到专栏（一篇文章对应书上一章），可能不会及时更新，见谅。 笔记可能有错误，看看就得，现在懒得浓缩精炼了，以后再说吧🧐
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7769
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
Java零基础-面向对象编程(中级部分)
wthsoso的博客
03-18 990
韩顺平老师Java零基础笔记——面向对象编程(中级部分)，若文章有误请在评论区指出，感谢！！！
韩顺平java面向对象高级编程学习笔记
yclllllll的博客
03-30 3867
记录学习java的笔记，主要是面向对象高级编程
JAVA SE学习笔记(五)：面向对象编程-b
宇智波Akali的博客
02-13 1万+
1.面向对象特征之二： 继 承 01.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么子类无需再定义这些属性和行为，只要继承父类即可。 02.定义方法： //定义父类 public class Person { public String name; public int...
【Java基础】建立Java面向对象编程OOP模型
明月沉江春雾晓
03-06 4435
转自https://blog.csdn.net/qq443068902/article/details/44256619对其进行了改写 重新布局 因为想在笔记中夹杂这篇文章中部分内容,所以进行了还是比较多的引用,核心的地方还是自己写的 可以一直接调转到深入理解Java的OOP 大纲 一、OOA 名称：Object-Oriented Analysis：面向对象分析方法 OOA是指...
Java学习笔记（三）Java面向对象编程 -- 详细的Java基础教程系列
Calvin Haynes的Blog
03-25 1308
Java 面向对象编程（OOP） 人类思想的方法原则的高深体现：抽象，分类，继承，聚合，多态 基于java尚硅谷教程的学习笔记，以及自己的一些理解和新知识分享 前言 面向对象的三大特征 封装 继承 多态 面向对象核心思想 Object和Class是面向对象的核心概念 Class类是一类事物的抽象定义 Object对象是实际存在的该类事物的个体，是类的实例化 万事万物皆对象 Class类 Class中的Member（成员） 属性（Field） = 成员变量 行为（Meth
JAVA SE学习笔记(六)：面向对象编程-c
宇智波Akali的博客
02-16 1万+
33.关键字static 01.在Java类中，可用static修饰属性、方法、代码块、内部类 02.被修饰后的成员具备以下特点： a.随着类的加载而加载 b.优先于对象存在 c.修饰的成员，被所有对象所共享 d.访问权限允许时，可不创建对象，直接被类调用 03.类变量(即被static修饰的类属性) a.类变量...
Java开发基础知识学习总结之（上）-王者笔记建议收藏
热门推荐
java李阳勇的博客
07-24 1万+
面向过程 ：面向过程性能比面向对象高。因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发。但是，面向过程没有面向对象易维护、易复用、易扩展。面向对象 ：面向对象易维护、易复用、易扩展。因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，面向对象性能比面向过程低。参考问题 ：面向过程性能一定比面向对象高？
Java基础 学习笔记 Markdownr版
06-27
1. 面向对象（OOP）：Java的核心是面向对象编程，它将数据和操作数据的方法封装在一起，形成类。面向对象的三大特性——封装、继承和多态，在06面向对象（上）、07面向对象（中）和08面向对象（下）中进行了详细介绍...
java学习笔记（面向对象）
03-07
Java是一种广泛使用的面向对象编程语言，其面向对象特性使得它非常适合于构建复杂、可维护的软件系统。面向对象编程（Object-Oriented Programming, OOP）是Java的核心理念之一，它与面向过程编程有着本质的区别。 ...
Java基础尚硅谷宋红康学习笔记
05-29
理解封装、继承和多态是Java面向对象编程的关键概念。 3. **数组与集合**：数组用于存储固定数量的同类型元素，而集合框架（如ArrayList、LinkedList、HashSet、HashMap等）则提供了动态存储和操作对象的能力。 4....
Servlet的生命周期
最新发布
wyk的博客
11-13 969
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 274
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 677
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
1112--接口
kequanrrr的博客
11-12 382
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
面向对象编程基础——Java学习笔记
总结来说，Java学习笔记深入浅出地介绍了面向对象编程的概念，包括对象、类、属性、方法、高内聚、低耦合以及代码复用，这些都是Java编程的基础，也是理解面向对象编程的关键。对于Java初学者来说，这份笔记提供了很...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值