Java开发之路—面向对象（上）

最新推荐文章于 2024-07-09 16:46:46 发布
最新推荐文章于 2024-07-09 16:46:46 发布
阅读量153 收藏 1
点赞数
分类专栏： Java开发之路 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xiaobai_rabbit0/article/details/109700053
版权

面向对象（上）

1、类与对象

1.1、面向对象学习的三条主线

  1. Java类及类的成员：属性、方法、构造器：代码块、内部类；
  2. 面向对象三大特征：封装性、继承性、多态性、（抽象性）；
  3. 其他关键字：this、super、static、final、abstract、interface、package、import等。

1.2、关于面向对象与面向过程的理解

  1. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做；
  2. 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

1.3、完成一个项目（或功能）的思路

  1. 根据问题需要，选择问题所针对的现实世界中的实体；
  2. 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类；
  3. 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构；
  4. 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具；

1.4、面向对象中两个重要的概念

  1. 类：对一类事物的描述，是抽象的、概念上的定义
  2. 对象：是实际存在的该类事物的每个个体，因而也称为实体（instance）
    面向对象程序设计的重点是类的设计；
    设计类，就是设计类的成员。
    二者之间的关系：
    对象，是由类new出来的，派生出来的

1.5、面向对象思想—落地实现的规则

  1. 创建类，设计类的成员；
  2. 创建类的对象；
  3. 通过“对象.属性”或“对象.方法”调用对象的结构；

补充：几个概念的使用说明

  • 属性 = 成员变量=field=域、字段；
  • 方法=函数=成员方法=method;
  • 创建类的对象=实例化类=类的实例化。

1.6、对象的创建&对象的内存解析

典型代码：

  • Person p1 = new Person();
  • Person p2 = new Person();
  • Person p3 = p1; //没有创建新的对象，只是将地址赋过去了，公用一个堆空间中的对象实体。

说明：如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

对象的内存解析：
在这里插入图片描述
对象数组的内存解析：
在这里插入图片描述

1.7、匿名对象

匿名对象：我们创建的对象，没显式的赋给一个变量名。
特点：匿名对象只能调用一次。
eg:

举例：
		new Phone().sendEmail();
		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
应用场景：
PhoneMall mall = new PhoneMall();

//匿名对象的使用
mall.show(new Phone());
其中，
class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
	
}

1.8、理解“万事万物皆对象”

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构；

eg:

  • Scanner,String等；
  • 文件：File;
  • 网络资源：URL

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

2、JVM内存结构

  1. 编译完源程序以后，生成一个或多个字节码文件。
  2. 我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。

也就是说：编译的时候没有分配内存，只有运行的时候才分配内存。
在这里插入图片描述

  • 虚拟机栈：即我们平时常说的栈结构，我们将局部变量存储在栈结构中；
  • 堆：我们将new出来的结构（比如：数组、对象等）加载在堆空间中；
  • 堆的补充：对象的属性（非static的）加载在堆空间中。（static的，对象的属性在方法区）；
  • 方法区：类的加载信息、常量池、静态域。

3、类的结构（属性、方法、构造器）

3.1、类的结构之一：属性

对比：属性 vs 局部变量
1、相同点：

  • 定义变量的格式：数据类型 变量名=变量值；
  • 先声明，后使用；
  • 变量都有其对应的作用域。

2、不同点：

  1. 在类中声明的位置不同
    • 属性：直接定义在类的一对{}内；
    • 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
  2. 关于权限修饰符的不同
    • 属性：可以在声明属性时，使用权限修饰符，指明其权限。；
      常用的权限修饰符：private、public、缺省、protected ——> 封装性
      一般，在声明属性时，都使用缺省
    • 局部变量：不可以使用权限修饰符。
  3. 默认初始化值的情况
    • 属性：类的属性，根据其类型，都默认初始化值；
      整型：byte、short、int、long:0
      浮点型：float、double:0.0
      字符型：char:0（或：’\u0000’）
      布尔型：boolean：false
    • 局部变量：没默认初始化值；
      意味着：在调用局部变量之前，一定要显式赋值
      特别地：形参在调用时，我们赋值即可
  4. 在内存中加载的位置
    • 属性：加载到堆空间中（非static）；
    • 局部变量：加载到栈空间中。

3.1.1 回顾变量的分类

1、按照数据类型分：
在这里插入图片描述
2、按照在类中声明的位置分：

在这里插入图片描述

3.2、类的结构之二：方法

方法：描述类应该具备的功能。
 * 比如：Math类：sqrt()\random() \...
 *      Scanner类：nextXxx() ...
 *      Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
 * 
 * 1.举例：
 * public void eat(){}
 * public void sleep(int hour){}
 * public String getName(){}
 * public String getNation(String nation){}
 * 
 * 2. 方法的声明：权限修饰符  返回值类型  方法名(形参列表){
 * 					方法体
 * 			  }
 *   注意：static、final、abstract 来修饰的方法。
 *   
 * 3. 说明：
 * 		3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
 * 			Java规定的4种权限修饰符：private、public、缺省、protected  --> 封装性
 * 
 * 		3.2 返回值类型： 返回值  vs 没返回值
 * 			3.2.1      如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
 *                 return关键字来返回指定类型的变量或常量：“return 数据”。
 * 				       如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要
 *                 使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 * 
 * 			3.2.2 我们定义方法该不该返回值？
 * 				① 题目要求
 * 				② 凭经验：具体问题具体分析
 * 
 *      3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *      
 *      3.4 形参列表： 方法可以声明0个，1个，或多个形参。
 *         3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
 *         
 *         3.4.2 我们定义方法时，该不该定义形参？
 *         		① 题目要求
 *         		② 凭经验：具体问题具体分析
 *      
 *      3.5 方法体：方法功能的体现。 	

4. 方法的使用中，可以调用当前类的属性或方法
 *  		特殊的：方法A中又调用了方法A:递归方法。
 *     方法中，不可以定义方法。

3.2.1、return关键字

1.使用范围：使用在方法体中
2.作用：

  • ① 结束方法
  • ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。

3.注意点：return关键字后面不可以写任何执行语句。

3.2.2、方法重载（重要）

1、方法重载的概念

  • 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型****不同即可
  • 总结：“两同一不同”：同一个类、相同方法名，参数列表不同（参数个数不同 / 参数类型不同）

2、构成方法重载的举例：

  • 举例1：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
  • 举例2：是否构成重载举例
构成重载举例：
//如下的4个方法构成了重载
	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2){
		System.out.println("2");
	}
	
	public void getSum(String s ,int i){
		System.out.println("3");
	}
	
	public void getSum(int i,String s){
		System.out.println("4");
	}
   
不构成重载的举例：
//如下的3个方法不能与上述4个方法构成重载
	public int getSum(int i,int j){
		return 0;
	}
	
	public void getSum(int m,int n){
		
	}
	
	private void getSum(int i,int j){
		
	}

3、如何判断是否构成方法的重载？

  • 严格按照定义判断：两同一不同；
  • 是否重载与 方法的权限修饰符、返回值类型、形参变量名、方法体 都没关系！

4、如何确定类中某一个方法的调用：

  • 方法名 ——> 参数列表

5、面试题：方法的重载与重写的区别？ （很老，很基础）
在后面给出答案
提示：这两个没什么关系
eg:类似的考题

#   如下的区别（其实都没啥相关性，只是像而已）
throws\throw
String\StringBuffer\StringBuilder
Collection\Collections
final\finally\finalize
...

抽象类、接口
sleep() / wait()    张的不像的，问区别，一般就有一致的地方。

3.2.3、可变个数形参的方法

1、使用说明：

 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 *   2.1 可变个数形参的格式：数据类型 ... 变量名
 *   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
 *   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *   2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
 *   2.5 可变个数形参在方法的形参中，必须声明在末尾
 * 	 2.6  可变个数形参在方法的形参中,最多只能声明一个可变形参。

2、举例说明：

 	public void show(int i){
		
	}
	
	public void show(String s){
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	//不能与上一个方法同时存在
//	public void show(String[] strs){
//		
//	}

调用时：

	test.show("hello");
	test.show("hello","world");
	test.show();
	
	test.show(new String[]{"AA","BB","CC"});

3.2.4、Java的 值传递机制

1、针对于方法内变量的赋值举例：

	System.out.println("***********基本数据类型：****************");
	int m = 10;
	int n = m;
	
	System.out.println("m = " + m + ", n = " + n);
	
	n = 20;
	
	System.out.println("m = " + m + ", n = " + n);
	
	System.out.println("***********引用数据类型：****************");
	
	Order o1 = new Order();
	o1.orderId = 1001;
	
	Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
	
	System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
	
	o2.orderId = 1002;
	
	System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

规则：

  • 如果变量是基本数据类型，此时赋值的是变量所保存的 数据值；
  • 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

2、针对于方法的参数概念

  • 形参：方法定义时，声明在小括号内的参数；
  • 实参：方法调用时，实际传递给形参的数据。

3、Java中参数传递机制：值传递
规则：

  • 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值；
  • 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

推广：

  • 如果变量是基本数据类型，此时赋值的是变量所保存的数据值；
  • 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

4.典型例题与内存解析：
例题一：
在这里插入图片描述
例题二：
在这里插入图片描述

3.2.5、递归方法

1、定义
递归方法：一个方法体内，调用它自身
2、如何理解 递归方法？

  • 递归方法包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制；
  • 递归一定要向已知方法递归，否则这种递归就变成了无穷递归，类似于死循环。

3、举例

// 例1：计算1-n之间所有自然数的和
	public int getSum(int n) {// 3

		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}

	}

	// 例2：计算1-n之间所自然数的乘积:n!
	public int getSum1(int n) {

		if (n == 1) {
			return 1;
		} else {
			return n * getSum1(n - 1);
		}

	}
	
	//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public int f(int n){
		if(n == 0){
			return 1;
		}else if(n == 1){
			return 4;
		}else{
//			return f(n + 2) - 2 * f(n + 1);
			return 2*f(n - 1) + f(n - 2);
		}
	}

	//例4：斐波那契数列
	
	//例5：汉诺塔问题
	
	//例6：快排

3.2.6、面向对象的特征：1、封装性（2、继承性，3、多态性）

1、为什么要引入封装性？

  • 我们程序设计追求“高内聚，低耦合”
    高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
    低耦合：仅对外暴露少量的方法用于使用。
  • 隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。（这就是封装性的思想）

2、问题引入

  • 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
    –>此时，针对于属性就体现了封装性。

3、封装性思想具体的代码体现：
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(**getXxx)和设置(setXxx)**此属性的值；

private double radius;
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4、Java规定的四种权限修饰符

  • 权限从大到小顺序为：public > protected > 缺省 > private;
  • 具体的修饰范围：
    在这里插入图片描述
  • 权限修饰符可以用来修饰的结构说明：
    4中权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类；
    修饰类的话，只能使用：缺省、public。

3.3、类的结构之三：构造器

1、构造器（或构造方法）：Constructor
构造器的作用：只要构造对象，必须要用到构造器

  • 创造对象；
  • 初始化对象的信息。

2、使用说明：

  • 如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器；
  • 定义构造器的格式：权限修饰符 类名（形参列表）{}；
  • 一个类中定义的多个构造器，彼此构成重载；
  • 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器；
  • 一个类中，至少会有一个构造器。

3、举例

//构造器
	public Person(){
		System.out.println("Person().....");
	}
	
	public Person(String n){
		name = n;
		
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}

3.3.1、属性赋值顺序（重要）

  1. 默认初始化
  2. 显式初始化
  3. 构造器中初始化
  4. 通过“对象.方法” 或 “对象.属性”的方式赋值

3.3.2、JavaBean的概念（重要）

所谓JavaBean，是指符合如下标准的Java类：

  • 类是公共的（public）；
  • 一个无参的公共的构造器；
  • 属性，且对应的get、set方法。

3.3.3、关键字：this

1、可以调用的结构：属性、方法、构造器

2、this调用属性、方法：
this理解为：当前对象 或 当前正在创建的对象

  • 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性****同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
  • 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性****同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3、this调用构造器

  • 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器；
  • 构造器中不能通过"this(形参列表)"方式调用自己；
  • 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"；
  • 规定："this(形参列表)"必须声明在当前构造器的首行；
  • 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器。

3.3.4、关键字：package、import

1、package的使用
1.1、使用说明：

  • 为了更好的实现项目中类的管理，提供包的概念；
  • 使用package声明类或接口所属的包，声明在源文件的首行；
  • 包，属于标识符，遵循标识符的命名规则、规范（xxxyyyzzz）、“见名知意”；
  • 每" . "一次，就代表一层文件的目录。

1.2、举例
举例一：
某航运软件系统包括：一组域对象、GUI和reports子系统
在这里插入图片描述
举例二：MVC设计模式
在这里插入图片描述
1.3 JDK中的主要包介绍：
在这里插入图片描述
2. import的使用
2.1、import的导入

  • 在源文件中显式的使用import结构导入指定包下的类、接口；
  • 声明在包的声明和类的声明之间；
  • 如果需要导入多个结构，则并列写出即可；
  • 可以使用"xxx."的方式，表示导入xxx包下的所结构*；
  • 如果使用的类或接口是java.lang包下定义的，则可以省略import结构；
  • 如果使用的类或接口是本包下定义的，则可以省略import结构；
  • 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示；
  • 使用"xxx."方式表明可以调用xxx包下的所结构*。但是如果使用的是xxx子包下的结构，则仍需要显式导入；
  • import static:导入指定类或接口中的静态结构 : 属性或方法。
ClFH
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 2998
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
JAVA面向对象
JINGJID的博客
03-25 4946
一、类与对象的创建 1.使用new关键字创建对象 Person person = new Person("Jingjing"); 二、构造器详解 一个类即使什么也不写，也会存在一个构造方法 即便前面的类是空的，仍然可以使用new方法创建一个对象 1.无参构造器和有参构造器 2.快捷方法 alt + insert :生成有参构造 alt +insert +seleteNone(弹出的中间）：生成无参构造 ...
Java——面向对象编程
m0_53485626的博客
03-27 1733
面向对象的思想和特性
Java面向对象
Peaceuai的博客
12-22 2万+
一、思想 1、要理解面向对象思想，我们先要知道什么是对象？ 《Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性）及行为特征（方法），java就是通过对象之间行为的交互来解决问题的。 面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行为。 类是面向对
Java面向对象浅谈
编程界明世隐的博客
12-06 4903
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java面向对象详解
王梦杰_MengJie
03-07 1万+
1、初识面向对象： 面向过程vs面向对象 面向过程思想：步骤清晰简单，第一步做什么，第二步做什么……，面向过程适合处理一些较为简单的问题 面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程的思路去处理。
Java面向对象（知识点整理）
热门推荐
yang642019851的博客
02-22 6万+
文章目录面向对象类与对象匿名对象创建对象的内存分析栈(stack)堆(heap)方法区PC寄存器本地方法栈内部类成员内部类局部内部类匿名内部类静态内部类包装类拆箱和装箱操作字符串转换基本数据类型和包装类型的区别Integer类型的重点抽象类抽象方法不能被实例化常见问题抽象类和普通类的区别接口面向接口编程思想全局常量和抽象方法的简写接口的实现 implements接口的继承 extends接口与抽象类的区别多态多态的体现多态的使用：对象的类型转换InstanceofObject类Object的多态toStri
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
Java面向对象基础
weixin_60719453的博客
10-13 8369
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
java基础之面向对象开发讲解，适合java初级人员入门学习
04-10
java基础之面向对象开发讲解，适合java初级人员入门学习
浅谈Java和C#在面向对象上语法的区别
12-22
做了几年了开发一直没有总结什么，回到了家乡的小城做了一名培训班的教员，教授软件开发的知识。细小的知识从头细细嚼来，别有一番滋味。或是以前遗漏的太多，或是确实没有系统的学习过，教学生的... 　面向对象 　
java开发基础教程，讲解面向对象基础理论
02-23
java开发基础教程，讲解面向对象基础理论
漫画面向对象编程 Java
06-16
借助于漫画展示的形式，面向对象的简、由类创建一个对象的方法、类...还讲解了搭建Java开发环境的步骤和方法，便于练习、内容。 可以在轻松幽默的氛围中对面向对象编程产生浓厚的兴趣，从而为后续的编程进阶树立信心。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1391
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 770
在 Java 中，可以通过多种方法将一个Object转换为Integer。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 1642
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
最新发布
qq_44304677的博客
07-09 527
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
面向对象编程（Java）.pdf
06-27
"面向对象编程（Java）的PDF文档包含了面向对象编程的所有基础知识和实战代码，主要涉及Java语言，涵盖的概念包括面向对象编程的定义、特点、三大特性（封装、继承和多态），以及相关的编程实践，如方法调用、构造器...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值