第四章：面向对象编程上

已于 2023-11-29 17:30:46 修改
阅读量120 收藏
点赞数 1
分类专栏： Java语言 文章标签： java intellij-idea
于 2023-07-12 10:49:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63925896/article/details/131676519
版权

目录

四：面向对象编程上

4.1：OOP

4.2： 类中属性的使用

4.3：方法的使用（重载、递归）

4.4：OOP特征之一：封装与隐藏

4.5：类的成员之三：构造器（或构造方法）

4.6：this关键字

4.7：Package && Import关键字

4.8：javabean

第四章：面向对象编程上

4.1：OOP

package com.jiayifeng.java;
/*
 * 一：Java面向对象(三条主线)
 * 1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 * 2.面向对象的三大特征：封装性、继承性、多态性（抽象性）
 * 3.其它关键字：this、super、static、final、abstract、
 * interface、package、import等
 * 
 * 二：面向过程(process-oriented programming,POP)&&
 * 	  面向对象(object-oriented programming,OOP)
 * 			①面向过程：强调功能行为，以函数为最小单位，考虑如何做
 * 			②面向对象：将功能封装进对象，强调具备了功能的对象，
 * 		    以类/对象为最小单位，考虑谁来做
 * 
 * 三：类和对象
 * 1.类是对一类事物的描述，是抽象的、概念上的定义
 * 2.对象是实际存在的，是该类事物的每个个体，因而也称为实例(instance)
 * 
 * 四：设计类，其实就是设计类的成员
 * 1.属性 = 成员变量 = field = 域、字段
 * 2.方法 = 成员方法 = 函数 = method
 * 3.创建类的对象 = 类的实例化 = 实例化类
 * 
 * 五：如果创建了一个类的多个对象，则每个对象都独立拥有一套类的属性（非static的）
 * 	  这意味着：如果我们修改一个对象的属性，则不影响另一个对象属性的值
 * 
 * 六：对象的内存解析
 * 1.堆(Heap)：存放对象实例
 * 2.栈(Stack)：指虚拟机栈。用于存储局部变量，方法执行完自动释放
 * 3.方法区(Method Area)：用于存储已被虚拟机加载的类信息、常量、
 * 静态变量、编译器编译后的代码等数据 
 */

public class OOPTest {
	public static void main(String[] args) {
		//创建类的对象
		Person p1 = new Person();
		
		//调用对象的结构：属性、方法
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");
		
		Person p2 = new Person();
		System.out.println(p2.name);  //null
		System.out.println(p2.isMale);  //false
		
		//将p1变量保存的对象地址值赋给p3，导致p1和p3指向了堆空间中的同一个对象实体
		Person p3 = p1;
		System.out.println(p3.name);  //Tom
	}
}

class Person{
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat() {
		System.out.println("人可以吃饭！");
	}
	
	public void sleep() {
		System.out.println("人可以睡觉！");
	}
	
	public void talk(String language) {
		System.out.println("人可以说话,使用的是：" + language);
	}
}

4.2： 类中属性的使用

package com.jiayifeng.java;
/*
 * 一：类中属性的使用
 * 属性（成员变量） VS 局部变量
 * 1.相同点：
 * 	1.1：定义变量的格式：数据类型 变量名 = 变量值
 * 	1.2：先声明、后使用
 * 	1.3：变量都有其对应的作用域
 * 
 * 2.不同点：
 * 	2.1：在类中声明的位置的不同
 * 		属性：直接定义在类的一对{}内
 * 		局部变量：声明在方法内、方法形参内、代码块内、构造器形参内、构造器内部的变量
 * 	2.2：权限修饰符的不同
 * 		属性：
 * 			可以在声明属性时，指明其权限，使用权限修饰符
 * 	        常用的权限修饰符：private、protected、public、缺省（default）
 * 		局部变量：
 * 			不可以使用权限修饰符
 * 	2.3：默认初始化值的情况
 * 		属性：类的属性，根据其类型，都有默认初始化值
 * 		局部变量：没有初始化值
 * 			意味着：在调用局部变量之前，一定要显示赋值
 * 			特别地：形参在调用时，我们赋值即可
 * 	2.4：在内存中加载的位置不同
 * 		属性：加载到堆空间中(非static)
 * 		局部变量：加载到栈空间
 */

public class UserTest {
	public static void main(String[] args) {
		user u1 = new user();
		System.out.println(u1.name);
		System.out.println(u1.age);
		System.out.println(u1.isMale);
		u1.talk("日语");
	}
}

class user{
	//属性（或成员变量）
	public String name;
	int age;
	boolean isMale;
	
	public void talk(String language) { //language:形参，也是局部变量
		System.out.println("我们使用" + language + "进行交流");
	}
	
	public void eat() {
		String food = "烙饼";  //局部变量
		System.out.println("北方人喜欢吃" + food);
	}
}

4.3：方法的使用（重载、递归）

package com.jiayifeng.java;
/*
 * 一：类中方法的声明和使用
 * 1.方法：描述类应该具有的功能
 * 	 比如：
 * 		Math类：sqrt()\random()\...
 * 		Scanner类：nextXxx()\...
 * 		Arrays类：sort()\binarySearch()/toString()\equals()\...	
 * 
 * 2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
 * 		方法体;
 * }
 * 
 * 3.说明
 * 3.1：权限修饰符：private、protected、public、缺省
 * 3.2：返回值类型：有返回值 && 无返回值
 * 	3.2.1：
 * 	 (1)如果方法有返回值，则必须在方法声明时，指定返回值的类型；同时，方法中，需要使用return关键字来返回指定类型的变量或常量
 * 	 (2)如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不使用return，但是，如果使用的话，只能“return;”表示结束方法的意思
 * 	3.2.2：我们定义方法时该不该有返回值？
 * 	  1>题目要求
 * 	  2>凭经验,具体问题具体分析
 * 3.3：方法名：属于标识符，见名知意
 * 3.4：形参列表：方法可以声明0个、1个...个形参
 * 		格式：数据类型1 形参1，数据类型2 形参2，...
 * 3.5：方法体：方法功能的体现
 * 
 * 4.return关键字的使用
 * 	1.使用范围：使用在方法体中
 * 	2.作用：
 * 		结束方法
 * 		针对有返回值类型的方法，使用"return 数据"方法返回所要的数据
 * 		注意点：return关键字后面不可以声明执行语句
 * 
 * 5.方法的使用：
 * 		可以调用当前类的属性或方法
 * 		不可以在方法中再定义另一个方法
 */

public class CustomerTest {
	public static void main(String[] args) {
		Customer c1 = new Customer();
		c1.eat();
	}
}

//客户类
class Customer{
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat() {
		System.out.println("客户吃饭");
	}
	
	public void sleep(int hour) {
		System.out.println("休息了" + hour + "个小时");
	}
	
	public String getName() {
		if(age > 18) {
			return name;
		}else {
			return "Tom";
		}
	}
	
	public String getNation(String nation) {
		String info = "我的国籍是：" + nation;
		return info;
	}
}
package com.jiayifeng.java;
/*
 * 一：如何理解“万事万物皆对象”？
 * 1.在Java语言范畴内，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的
 * 功能结构
 * 	>Scanner,String
 * 	>文件:file
 *	>网络资源:URL
 * 2.涉及到Java语言与前端HTML、后端的数据库交互时，前后端的结构在Java层面交互时，
 * 都体现为类、对象
 * 
 * 二：匿名对象
 * 1.理解：我们创建的对象，没有显式的赋给一个变量名，即为匿名对象
 * 2.特征：匿名对象只能调用一次
 * 
 * 三：方法
 * 3.1：方法的重载(overload)：“两同一不同”：同一个类、相同方法名；参数列表不同
 * 	3.1.2：定义
 * 		在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型
 * 		不同即可
 * 	3.1.2：判断是否重载
 * 		与方法的权限修饰符、方法体、返回值类型、形参变量名无关
 * 
 * 3.2：可变个数形参的方法
 * 	3.2.1：格式
 * 		数据类型 ... 变量名
 * 	3.2.2：说明
 * 		可变个数的形参在方法的形参中，必须声明在末尾
 * 		可变个数的形参在方法的形参中，最多只能声明一个
 * 
 * 3.3：方法参数的值传递机制
 * 	值传递
 * 		如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值
 * 	地址传递
 * 		如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值
 * 
 * 3.4：递归(recursion)方法：一个方法体内调用它自身
 * 	方法递归包含了一种隐式的循环，它会重复的执行某段代码，但这种重复执行无须循环控制
 * 	递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环
 */

public class WaysTest {
	public static void main(String[] args) {
		WaysTest test = new WaysTest();
		test.show(12);
		test.show("Hello!");
		test.show("Hello","World");
	}

	//3.1：重载
	public void show(int i) {
		System.out.println(i);
	}

	public void show(String s) {
		System.out.println("show(String)");
	}

	//3.2：可变个数的形参
	public void show(String ... strs) {
		System.out.println("show(String ... strs)");
	}
}

//3.4：递归
public class WaysTest{
	public static void main(String[] args) {
		//计算1~100之间所有自然数的和
		WaysTest test = new WaysTest();
		int sum1 = test.getSum(100);
		System.out.println(sum1);
		
		//方法一
		int sum = 0; 
		for(int i = 0;i <= 100;i++) {
			sum += i; 
		}
		System.out.println(sum);
}
		
		//方法二（递归）
		public int getSum(int n) {
			if(n == 1) {
				return 1;
			}else {
				return n + getSum(n - 1);
			}
		}
}

4.4：OOP特征之一：封装与隐藏

修饰符

类内部

同一个包

不同包的子类

同一个工程

private

yes

default

yes

yes

protected

yes

yes

yes

public

yes

yes

yes

yes

package com.jiayifeng.java;
/*
 * OOP特征之一：封装与隐藏
 * 一：概述
 * 隐藏内部的复杂性，只对外公开简单的接口
 * 便于外界调用，从而提高系统的可维护性、可扩展性
 * 通俗的说，就是把该隐藏的隐藏起来，该暴露的暴露出来
 * 
 * 二：封装性的体现，需要权限修饰符来配合
 * 2.1：Java规定的四种权限
 * 	private、default(缺省)、protected、public
 * 2.2：对于class的权限修饰符只可以用public和default
 * 	public类可以在任何地方被访问
 * 	default类只可以被同一个包内部的类访问
 * 2.3：四种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
 * 2.4：四种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
 * 总结：Java提供了四种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被
 * 调用时的可见性的大小
 */

public class AnimalTest {
	public static void main(String[] args) {
		Animal a = new Animal();
		a.name = "大黄";
		a.age = 10;
//		a.legs = 4;  //The field Animal.legs is not visible
		a.eat();
		a.show();
		
		a.setLegs(6);
		a.show();
	}
}

class Animal{
	String name;
	int age;
	private int legs;  //腿的个数
	
	//对属性的设置
	public void setLegs(int l) {
		if(l >= 0 && l % 2 == 0) {
			legs = l;
		}else {
			legs = 0;
			//或者抛出异常
		}
	}
	
	//对属性的获取
	public int getLegs() {
		return legs;
	}
	
	public void eat() {
		System.out.println("动物进食！");
	}
	
	public void show() {
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
}

4.5：类的成员之三：构造器（或构造方法）

package com.jiayifeng.java;
/*
 * 类的成员之三：构造器
 * 一：constructor作用
 *	1、创建对象
 *	2、给对象的属性进行初始化
 *
 * 二：说明
 * 	1、如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 * (权限与本类的权限相同)
 * 	2、定义构造器的格式：权限修饰符 类名(形参列表){}
 * 	3、一个类中定义多个构造器，彼此构成重载
 * 	4、一旦我们显式的定义了类的构造器后，系统就不再提供默认的空参构造器
 * 	5、一个类中，至少会有一个构造器
 * 
 * 三：特征
 * 	1、具有与类相同的名称
 * 	2、不声明返回值类型
 * 	3、不能被static、final、synchronize、abstract、native等修饰、
 *  不能有return语句
 * 
 * 四：属性赋值的先后顺序
 * 	1.默认初始化
 * 	2.显式初始化
 * 	3.构造器中赋值
 * 	4.通过"对象.方法"或"对象.属性"的方式赋值
 * 	以上操作的先后顺序：1 2 3 4
 */
public class PersonTest {
	public static void main(String[] args) {
		//创建类的对象：new + 构造器
		Person1 p = new Person1();
		p.name = "小贾";
		p.age = 22;
		p.eat();
		p.study();
		
		Person1 p1 = new Person1("Tom");
		System.out.println(p1.name);
	}
}

class Person1{
	//属性
	String name;
	int age;
	
	//构造器
	public Person1() {
		System.out.println("Person()......");
	}
	
	public Person1(String n) {
		name = n;
	}
	
	//方法
	public void eat() {
		System.out.println("人吃饭！");
	}
	
	public void study() {
		System.out.println("人可以学习！");
	}
}

4.6：this关键字

package com.jiayifeng.java2;
/*
 * this关键字的使用
 * 一：this可以用来修饰或调用：属性、方法、构造器
 * 
 * 二：this修饰属性和方法：
 * this理解为：当前对象或当前正在创建的对象
 * 		2.1：在类的方法（构造器）中，我们可以使用“this.属性”或“this.方法”的方式，调用当前
 * 对象属性或方法。但是通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的
 * 形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明变量是属性，而
 * 非形参
 * 
 * 三：this修饰或调用构造器
 * 		①我们在类的构造器中，可以显式的使用“this(形参列表)”的方式，调用类中指定
 * 		的其它构造器
 * 		②构造器中不能通过“this(形参列表)”方式调用自己
 * 		③如果一个类中有n个构造器，则最多有n-1个构造器使用了“this(形参列表)”
 * 		④规定：“this(形参列表)”必须声明在当前构造器的首行
 * 		⑤构造器内部，最多只能声明一个“this(形参列表)”，用来调用其他的构造器
 */
public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setAge(22);
		p1.getAge();
		System.out.println(p1.getAge());
	}
}

class Person{
	private String name;
	private int age;
	
	public void setName(String name) {
		this.name = name;  //当前对象的姓名
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
}

4.7：Package && Import关键字

package com.jiayifeng.java2;

import java.util.Arrays;

/*
 * 一：Package关键字的使用
 * 1.为了更好的实现项目中类的管理，提供包的概念
 * 2.使用package声明类或接口所属的包，声明在源文件的首行
 * 3.包，属于标识符，遵循标识符所的命名规范
 * 4.每“.”一次，就代表一层文件目录
 * 5.同一个包下，不能命名同名的接口、类
 *   不同的包下，可以命名同名的接口、类
 *   
 * 二：Import关键字的使用
 * 1.import：导入
 * 2.在源文件中显式的使用import结构导入指定包下的类、接口
 * 3.声明在包的声明和类的声明之间
 * 4.如果需要导入多个结构，则并列写出即可
 * 5.使用“xxx.*”的方式，表示可以导入xxx包下的所有结构
 * 6.如果使用的类或接口是java.lang包下定义的，则可以省略import结构
 * 7.如果使用的类或接口是本包下定义的，可以省略import结构
 * 8.如果在源文件中使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
 * 9.如果使用“xxx.*”方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下
 * 的结构，则仍需要以全类名显示
 * 10.import static：导入指定类或接口中的静态结构
 */
public class PackageImportTest {
	public static void main(String[] args) {
		String info = Arrays.toString(new int[] {1,2,3});
	}
}

4.8：javabean

指符合如下标准的java类：

        1.类是公共的

        2.一个无参的公共构造器

        3.有属性，且含有对应的get、set方法

*晨晨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python程序设计 第7章：Python面向对象编程
惊鸿若梦一书生
04-05 7389
Python程序设计 第7章：Python面向对象编程7.1 面向对象编程概述7.1.1 OOP的产生7.1.2 OOP核心思想7.1.3 OOP特征7.2 类和对象7.2.1 类的创建7.2.2 对象的创建7.2.3 类的属性7.2.4 类的方法7.2.5 内部类7.2.6 魔术方法7.3 类间关系7.3.1 依赖关系7.3.2 关联关系7.3.3 继承关系7.4 总结 7.1 面向对象编程概述 7.1.1 OOP的产生 7.1.2 OOP核心思想 7.1.3 OOP特征 7.2 类和对象 7.2.1 类
编程语言发展史之：面向对象编程语言
禅与计算机程序设计艺术
09-24 1727
面向对象编程(Object-Oriented Programming，OOP)是一种计算机编程方法，它以数据抽象、继承和多态作为编程哲学基础，并通过类、对象和消息传递的方式实现对真实世界的模拟,[1] [2][3]。在过去几十年里，面向对象编程已经成为一种主流的程序设计方法，并且越来越受到开发者的欢迎。特别是在大型软件系统中，采用面向对象的方法可以有效地提高开发效率、降低维护难度，增强系统的可扩展性、可复用性和可维护性。
第八章：面向对象分析、设计
m0_55901666的博客
12-06 1422
第八章：面向对象分析（OOA) 知识点 1.面向对象分析中，主要由对象模型：静态模型（类图）、动态模型（状态图、先画数据跟踪图）和功能模型（用例图或数据流图）组成。 2.分析工作主要包括3项内容即：理解、表达和验证 3.面向对象分析即（OOA）。 4.三个子模型和5个层次：对象模型、动态模型、功能模型。 ​ 主题层、类与对象层、结构层、属性层、服务层。 5.具体地说，大多数客观事物可分为下述5类：(1) 可感知的物理实体 。 (2) 人或组织的 角色 (3) 应该记忆的事
java面向对象第四章上机_java面向对象编程——第四章 类和对象
weixin_35970228的博客
02-26 243
OO：面向对象OOP：面向对象编程OOA：面向对象分析OOD：面向对象设计结构化编程：从顶向下，将一个大问题分解成更小的任务，然后为每一个更小的任务编写一个过程。最后程序员会编写一个主过程来启动程序流程，随后根据程序流程走向，调用想要的其它过程。对象是存在的具体实体，具有明确定义的特征和行为。万物皆为对象，对象因我关注而产生。面向对象：一种认识事物的方式，注重对事物整体的认知，最符合人类自然的思维...
Go：面向对象编程
热门推荐
学习记录和总结
06-01 1万+
Go语言面向对象编程
5. 设计模式之对象思维：面向对象编程有哪些优势？
卜卦的博客
03-01 1815
设计模式之对象思维：面向对象编程有哪些优势？
第四章_面向对象编程(上)
完全体
08-07 916
01.Java教程-基础必备\2.Java核心基础好评30天入门\课件笔记源码JAVA基础资料\JAVA基础\1_课件\第1部分：Java基础编程
Python编程实验六：面向对象应用
Morse_Chen的博客
03-07 1328
Python编程实验六：面向对象应用
C#学习笔记（八）——第七章：面向对象编程（一）
lllxxq141592654的博客
08-24 2614
博文适用于编程小白，基于《叩响C#之门》，传送门：链接：https://pan.baidu.com/s/1y2UegjDUJz-xrOQu3qKMjQ 密码：4v2n 《叩响C#之门》通俗易懂，又不失专业性，比传统的《C#入门经典》《C#从入门到精通》这类书好的多，是一本不可多得的好教材。 C#学习笔记（一）——第一章：初识编程 C#学习笔记（二）——第二章：变量 C#学习笔记（三）...
Python 面向对象编程详解
CSDN
08-04 6388
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
c#第4章面向对象的高级编程.ppt
11-13
C# 第4章面向对象高级编程 本章教学目的：介绍C# 高级编程的相关知识，使学生对C# 高级编程有一个感性认识。 一、封装、继承与多态 * 封装：隐藏调用者不需要了解的信息。例如，模块信息通过类封装，类的成员通过...
面向对象编程技术第四章PPT资料.pptx
12-01
面向对象编程技术第四章PPT资料.pptx
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 ...本章内容涵盖了 JAVA 面向对象编程的基础知识，包括定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等，旨在帮助读者掌握 JAVA 面向对象编程的基础知识和技能。
第四章：面向对象编程基础
10-20
第四章，各例题，分难度等级，参考答案。。初学者看下啦
Scala编程详解 第13讲-Scala编程详解：面向对象编程之对象 共9页.pptx
11-25
第12讲-Scala编程详解：面向对象编程之类 共12页 第13讲-Scala编程详解：面向对象编程之对象 共9页 第14讲-Scala编程详解：面向对象编程之继承 共13页 第15讲-Scala编程详解：面向对象编程之Trait 共14页 第16讲-...
简单的项目部署脚本（转载）
u010230019的博客
06-09 613
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1276
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 423
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 415
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
面向对象编程第四版王育坚
04-03
《面向对象编程第四版》是一本由王育坚编写的计算机编程教材，介绍了面向对象编程的基本概念、原则、方法和技术。本书从面向对象的思想出发，系统讲解了面向对象的程序设计与实现，围绕类、对象、继承、多态等概念...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值