一文带你深入理解【Java基础】· 面向对象编程（上）①面向对象的理解、类和对象、对象的创建使用和属性

麟-小白

已于 2023-03-20 13:21:11 修改

阅读量839

点赞数 3

分类专栏： Java基础精讲文章标签： java 软件工程开发语言 eclipse

于 2022-09-16 14:12:51 首次发布

本文链接：https://blog.csdn.net/qq_34025246/article/details/126877546

版权

Java基础精讲专栏收录该内容

33 篇文章 5 订阅

订阅专栏

写在前面

Hello大家好，我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！谢谢大家！！！

如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多点赞加关注呀！❤❤❤ 爱你们！！！

5.1 什么是方法(method、函数):

【往期回顾】

一文带你深入理解【Java基础】 · 数组

一文带你深入理解【Java基础】· Java基本语法：程序流程控制

一文带你深入理解【Java基础】· Java基本语法：运算符

一文带你深入理解【Java基础】 · Java基本语法：变量

一文带你深入理解【Java基础】 · Java语言概述

【习题总结】

【Java基础】· 面向对象编程（上）习题详解

前言：

学习面向对象内容的三条主线

1.Java 类及类的成员

2. 面向对象的三大特征

3. 其它关键字

1. 面向过程与面向对象

1.1 何谓“面向对象”的编程思想？

首先解释一下“思想”。先问你个问题：你想做个怎样的人？可能你会回答：我想做个好人，孝敬父母，尊重长辈，关爱亲朋…… 你看，这就是思想。这是你做人的思想，或者说，是你做人的原则。做人有做人的原则，编程也有编程的原则。这些编程的原则呢，就是编程思想。

面向过程(POP) 与面向对象(OOP)

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象的三大特征

封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)

面向对象：Object Oriented Programming

面向过程：Procedure Oriented Programming

1.2 面向对象的思想概述

程序员从面向过程的执行者转化成了面向对象的指挥者
面向对象分析方法分析问题的思路和步骤：
根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
 * 一、Java面向对象学习的三条主线：（第4-6章）
 * 1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 * 
 * 2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)
 * 
 * 3.其它关键字：this、super、static、final、abstract、interface、package、import等
 * 
 * “大处着眼，小处着手”
 * 
 * 
 * 二、“人把大象装进冰箱”
 * 
 * 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
 * 
 * ① 把冰箱门打开
 * ② 抬起大象，塞进冰箱
 * ② 把冰箱门关闭
 * 
 * 2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
 * 
 * 人{
 * 		打开(冰箱){
 * 			冰箱.开开();
 * 		}
 * 
 * 		抬起(大象){
 * 			大象.进入(冰箱);
 * 		}
 * 
 * 		关闭(冰箱){
 * 			冰箱.闭合();
 * 		}
 * 
 * }
 * 
 * 
 * 冰箱{
 * 		开开(){}
 * 		闭合(){}
 * }
 * 
 * 大象{
 * 		进入(冰箱){
 * 		}
 * }
 * 
 * 三、面向对象的两个要素：
 * 类：对一类事物的描述，是抽象的、概念上的定义
 * 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
 * >面向对象程序设计的重点是类的设计
 * >设计类，就是设计类的成员。
 * 

2. Java语言的基本元素：类和对象

2.1 面向对象的思想概述

类(Class)和对象(Object)是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。

“万事万物皆对象”

可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

2.2 Java类及类的成员

现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。
现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java中用类class来描述事物也是如此。常见的类的成员有：
属性：对应类中的成员变量
行为：对应类中的成员方法

Field = 属性 = 成员变量，Method = (成员)方法 = 函数

2.3 类的语法格式

2.4 创建Java自定义类

步骤：

1. 定义类（考虑修饰符、类名）

2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）

3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

3. 对象的创建和使用

3.1 对象的创建和使用

创建对象语法： 类名对象名 = new 类名 ();

使用“ 对象名 . 对象成员 ”的方式访问对象成员（包括属性和方法）

说明：

如果创建了一个类的 多个对象，对于类中 定义的属性，每个对 象都拥有各自的一套 副本，且互不干扰。

类的访问机制：

在一个类中的访问机制： 类中的方法可以直接访问类中的成员变量。 例外： static 方法访问非 static ， 编译不通过。

在不同类中的访问机制： 先创建要访问类的对象，再用对象访问类中 定义的成员
/*
 * 一、设计类，其实就是设计类的成员
 * 
 *  属性 = 成员变量 = field = 域、字段
 *  方法 = 成员方法 = 函数 = method
 * 
 *  创建类的对象 = 类的实例化 = 实例化类
 * 
 * 二、类和对象的使用（面向对象思想落地的实现）：
 *  1.创建类，设计类的成员
 *  2.创建类的对象
 *  3.通过“对象.属性”或“对象.方法”调用对象的结构
 *  
 * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
 *   意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
 *   
 * 四、对象的内存解析
 */
//测试类
public class PersonTest {
	public static void main(String[] args) {
		// 2. 创建Person类的对象
		Person p1 = new Person();
		// Scanner scanner = new Scanner(System.in);

		// 调用对象的结构：属性、方法
		// 调用属性：“对象.属性”
		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);
		// *******************************
		// 将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
		Person p3 = p1;
		System.out.println(p3.name);// Tom

		p3.age = 10;
		System.out.println(p1.age);// 10

	}
}

// 1.创建类，设计类的成员
class Person {

	// 属性
	String name;
	int age = 1;
	boolean isMale;

	// 方法
	public void eat() {
		System.out.println("人可以吃饭");
	}

	public void sleep() {
		System.out.println("人可以睡觉");
	}

	public void talk(String language) {
		System.out.println("人可以说话,使用的是：" + language);
	}

}
3.2 匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

如： new Person().shout();

使用情况

如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。我们经常将匿名对象作为实参传递给一个方法调用

4. 类的成员之一：属性

4.1 语法格式

修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符
常用的权限修饰符有：private、缺省、protected、public
其他修饰符：static、final (暂不考虑)
说明2：数据类型
任何基本数据类型(如int、Boolean) 或任何引用数据类型。
说明3：属性名
属于标识符，符合命名规则和规范即可。

举例：

public class Person{

private int age; // 声明 private 变量 age

public String name = “Lila”; // 声明 public 变量 name

}

类中属性的使用：
/*
 * 类中属性的使用
 * 
 * 属性（成员变量）   vs  局部变量
 * 1.相同点：
 * 		1.1  定义变量的格式：数据类型  变量名 = 变量值
 * 		1.2 先声明，后使用
 * 		1.3 变量都有其对应的作用域 
 * 
 * 
 * 2.不同点：
 * 		2.1 在类中声明的位置的不同
 * 		属性：直接定义在类的一对{}内
 * 		局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 * 		
 * 		2.2 关于权限修饰符的不同
 * 		属性：可以在声明属性时，指明其权限，使用权限修饰符。
 * 			常用的权限修饰符：private、public、缺省、protected  --->封装性
 * 			目前，大家声明属性时，都使用缺省就可以了。
 * 		局部变量：不可以使用权限修饰符。
 * 
 * 		2.3 默认初始化值的情况：
 * 		属性：类的属性，根据其类型，都有默认初始化值。
 * 			整型（byte、short、int、long）：0
 * 			浮点型（float、double）：0.0
 * 			字符型（char）：0  （或'\u0000'）
 * 			布尔型（boolean）：false
 * 
 * 			引用数据类型（类、数组、接口）：null
 * 
 * 		局部变量：没有默认初始化值。
 *  		意味着，我们在调用局部变量之前，一定要显式赋值。
 * 			特别地：形参在调用时，我们赋值即可。
 * 
 * 		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("韩语");

		u1.eat();

	}
}

class User {
	// 属性（或成员变量）
	String name;
	public int age;
	boolean isMale;

	public void talk(String language) {// language:形参，也是局部变量
		System.out.println("我们使用" + language + "进行交流");

	}

	public void eat() {
		String food = "烙饼";// 局部变量
		System.out.println("北方人喜欢吃：" + food);
	}

}
4.2 变量的分类：成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
注意：二者在初始化值方面的异同:

同：都有生命周期

异：局部变量除形参外，均需显式初始化。

成员变量（属性）和局部变量的区别？

4.3 对象属性的默认初始化赋值

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person 及前面讲过的数组。

5. 类的成员之二：方法

5.1 什么是方法(method、函数):

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
将功能封装为方法的目的是，可以实现代码重用，简化代码。
Java里的方法不能独立存在，所有的方法必须定义在类里。

举例：

public class Person{
    private int age;
    public int getAge() { //声明方法getAge()
    return age; 
    }
    public void setAge(int i) { //声明方法setAge
        age = i; //将参数i的值赋给类的成员变量age
    }
}

5.2 方法的声明格式

修饰符 返回值类型 方法名 （ 参数类型 形参 1 , 参数类型 形参 2 , …. ）｛

方法体程序代码

return 返回值 ;

｝

其中：

修饰符： public, 缺省 ,private, protected 等

返回值类型：

没有返回值：void。
有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用",”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。

5.3 方法的分类

方法的分类：按照是否有形参及返回值

方法的调用：

方法通过方法名被调用，且只有被调用才会执行。

注意：

方法被调用一次，就会执行一次
没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
定义方法时，方法的结果应该返回给调用者，交由调用者处理。
方法中只能调用方法或属性，不可以在方法内部定义方法。

类中方法的声明和使用：

/*
 * 类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：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.return关键字的使用：
 *  	1.使用范围：使用在方法体中
 *  	2.作用：① 结束方法
 *            ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
 *      3.注意点：return关键字后面不可以声明执行语句。
 *      
 *  5. 方法的使用中，可以调用当前类的属性或方法
 *  		特殊的：方法A中又调用了方法A:递归方法。
 *     方法中，不可以定义方法。
 */
public class CustomerTest {
	public static void main(String[] args) {

		Customer cust1 = new Customer();

		cust1.eat();

		// 测试形参是否需要设置的问题
		// int[] arr = new int[]{3,4,5,2,5};
		// cust1.sort();

		cust1.sleep(8);

	}
}

// 客户类
class Customer {

	// 属性
	String name;
	int age;
	boolean isMale;

	// 方法
	public void eat() {
		System.out.println("客户吃饭");
		return;
		// return后不可以声明表达式
		// System.out.println("hello");
	}

	public void sleep(int hour) {
		System.out.println("休息了" + hour + "个小时");

		eat();
		// sleep(10);
	}

	public String getName() {

		if (age > 18) {
			return name;

		} else {
			return "Tom";
		}
	}

	public String getNation(String nation) {
		String info = "我的国籍是：" + nation;
		return info;
	}

	// 体会形参是否需要设置的问题
	// public void sort(int[] arr){
	//
	// }
	// public void sort(){
	// int[] arr = new int[]{3,4,5,2,5,63,2,5};
	// //。。。。
	// }

	public void info() {
		// 错误的
		// public void swim(){
		//
		// }

	}
}

匿名对象的使用：

/*
 * 一、理解“万事万物皆对象”
 * 1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
 * 		>Scanner,String等
 * 		>文件：File
 * 		>网络资源：URL
 * 2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
 * 
 * 二、内存解析的说明
 * 1.引用类型的变量，只可能存储两类值：null  或  地址值（含变量的类型）
 * 
 * 三、匿名对象的使用
 * 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
 * 2.特征：匿名对象只能调用一次。
 * 3.使用：如下
 * 
 */
public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//**********************************
		PhoneMall mall = new PhoneMall();
//		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());
		
	}
}

class PhoneMall{
	
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
}

class Phone{
	double price;//价格

	public void sendEmail(){
		System.out.println("发送邮件");
	}
	
	public void playGame(){
		System.out.println("玩游戏");
	}
	
	public void showPrice(){
		System.out.println("手机价格为：" + price);
	}
}

5.4 练习

1.创建一个Person类，其定义如下：

要求：

(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。

(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。

public class Person {
	String name;
	int age;
	/**
	 * sex:1 表明是男性 sex:0 表明是女性
	 */
	int sex;

	public void study() {
		System.out.println("studying");
	}

	public void showAge() {
		System.out.println("age:" + age);
	}

	public int addAge(int i) {
		age += i;
		return age;
	}
}

/*
 * 要求：
 * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
 * 输出字符串“studying”，调用showAge()方法显示age值，
 * 调用addAge()方法给对象的age属性值增加2岁。
 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
 */
public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();

		p1.name = "Tom";
		p1.age = 18;
		p1.sex = 1;

		p1.study();

		p1.showAge();

		int newAge = p1.addAge(2);
		System.out.println(p1.name + "的新年龄为：" + newAge);

		System.out.println(p1.age);// 20

		// *************************
		Person p2 = new Person();
		p2.showAge();// 0
		p2.addAge(10);
		p2.showAge();// 10
		p1.showAge();
	}
}

2.利用面向对象的编程方法，设计类Circle计算圆的面积。

/*
 * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
 */
//测试类
public class CircleTest {
	public static void main(String[] args) {
		Circle c1 = new Circle();
		c1.radius = 2.1;
		// 对应方式一：
		// double area = c1.findArea();
		// System.out.println(area);

		// 对应方式二：
		c1.findArea();

		// 错误的调用
		// double area = c1.findArea(3.4);
		// System.out.println(area);
	}
}

// 圆
class Circle {
	// 属性
	double radius;

	// 求圆的面积
	// 方式一：
	// public double findArea(){
	// 		double area = Math.PI * radius * radius;
	// 		return area;
	// }

	// 方式二：
	public void findArea() {
		double area = Math.PI * radius * radius;
		System.out.println("面积为：" + area);
	}

	// 错误情况：
	// public double findArea(double r){
	// double area = 3.14 * r * r;
	// return area;
	// }
	//
}

3.1编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法。

3.2修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

/*
 * 3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法。
 * 3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
 * 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
 * 
 * 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
 * 并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

 */
public class Exer3Test {
	public static void main(String[] args) {
		Exer3Test test = new Exer3Test();

		// 3.1测试
		// test.method();

		// 3.2测试
		// 方式一：
		// int area = test.method();
		// System.out.println("面积为：" + area);

		// 方式二：
		// System.out.println(test.method());

		// 3.3测试
		int area = test.method(12, 10);
		System.out.println("面积为：" + area);

	}

	 3.1
	 public void method(){
		 for(int i = 0;i < 10;i++){
			 for(int j = 0;j < 8;j++){
				 System.out.print("* ");
			 }
			 System.out.println();
		 }
	 }
	 3.2
	 public int method(){
		 for(int i = 0;i < 10;i++){
			 for(int j = 0;j < 8;j++){
				 System.out.print("* ");
			 }
			 System.out.println();
		 }
	
	 return 10 * 8;
	 }
	 3.3
	public int method(int m, int n) {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}

		return m * n;
	}
}

4. 对象数组题目：

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩 score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一：打印出3年级(state值为3）的学生信息。

问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

/*
 * 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long。
 */

public class StudentTest {
	public static void main(String[] args) {

		// Student s1 = new Student();
		// Student s1 = new Student();
		// Student s1 = new Student();
		// Student s1 = new Student();
		// Student s1 = new Student();
		// Student s1 = new Student();

		// 声明Student类型的数组
		Student[] stus = new Student[20]; // String[] arr = new String[10];

		for (int i = 0; i < stus.length; i++) {
			// 给数组元素赋值
			stus[i] = new Student();
			// 给Student对象的属性赋值
			stus[i].number = (i + 1);
			// 年级：[1,6]
			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
			// 成绩：[0,100]
			stus[i].score = (int) (Math.random() * (100 - 0 + 1));
		}

		// 遍历学生数组
		for (int i = 0; i < stus.length; i++) {
			// System.out.println(stus[i].number + "," + stus[i].state
			// + "," + stus[i].score);

			System.out.println(stus[i].info());
		}

		System.out.println("********************");

		// 问题一：打印出3年级(state值为3）的学生信息。
		for (int i = 0; i < stus.length; i++) {
			if (stus[i].state == 3) {
				System.out.println(stus[i].info());
			}
		}

		System.out.println("********************");

		// 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for (int i = 0; i < stus.length - 1; i++) {
			for (int j = 0; j < stus.length - 1 - i; j++) {
				if (stus[j].score > stus[j + 1].score) {
					// 如果需要换序，交换的是数组的元素：Student对象！！！
					Student temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}

		// 遍历学生数组
		for (int i = 0; i < stus.length; i++) {
			System.out.println(stus[i].info());
		}
	}
}

class Student {
	int number;// 学号
	int state;// 年级
	int score;// 成绩

	// 显示学生信息的方法
	public String info() {
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
}

改进后：

/*
 * 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long。
 * 此代码是对StudentTest.java的改进：将操作数组的功能封装到方法中。
 */
public class StudentTest1 {
	public static void main(String[] args) {

		// 声明Student类型的数组
		Student1[] stus = new Student1[20];

		for (int i = 0; i < stus.length; i++) {
			// 给数组元素赋值
			stus[i] = new Student1();
			// 给Student对象的属性赋值
			stus[i].number = (i + 1);
			// 年级：[1,6]
			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
			// 成绩：[0,100]
			stus[i].score = (int) (Math.random() * (100 - 0 + 1));
		}

		StudentTest1 test = new StudentTest1();

		// 遍历学生数组
		test.print(stus);

		System.out.println("********************");

		// 问题一：打印出3年级(state值为3）的学生信息。
		test.searchState(stus, 3);

		System.out.println("********************");

		// 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		test.sort(stus);

		// 遍历学生数组
		test.print(stus);

	}

	/**
	 * 
	 * @Description 遍历Student1[]数组的操作
	 * @author lin_xiaobai  
	 * @Email 2822817241@qq.com
	 * @data 2022年9月16日下午2:05:57
	 * @param stus
	 */
	public void print(Student1[] stus) {
		for (int i = 0; i < stus.length; i++) {
			System.out.println(stus[i].info());
		}
	}

	/**
	 * 
	 * @Description 查找Stduent数组中指定年级的学生信息
	 * @author lin_xiaobai  
	 * @Email 2822817241@qq.com
	 * @data 2022年9月16日下午2:05:18
	 * @param stus 要查找的数组
	 * @param state 要找的年级
	 */
	public void searchState(Student1[] stus, int state) {
		for (int i = 0; i < stus.length; i++) {
			if (stus[i].state == state) {
				System.out.println(stus[i].info());
			}
		}
	}
	
	/**
	 * @Description 给Student1数组排序
	 * @author lin_xiaobai   
	 * @Email 2822817241@qq.com
	 * @data 2022年9月16日下午2:04:48
	 * @param stus
	 */
	public void sort(Student1[] stus) {
		for (int i = 0; i < stus.length - 1; i++) {
			for (int j = 0; j < stus.length - 1 - i; j++) {
				if (stus[j].score > stus[j + 1].score) {
					// 如果需要换序，交换的是数组的元素：Student对象！！！
					Student1 temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
	}
}

class Student1 {
	int number;// 学号
	int state;// 年级
	int score;// 成绩

	// 显示学生信息的方法
	public String info() {
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
}

结语

本人会持续更新文章的哦！希望大家一键三连，你们的鼓励就是作者不断更新的动力

麟-小白

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
一文带你深入理解【Java基础】· 面向对象编程（上）①面向对象的理解、类和对象、对象的创建使用和属性

Hello大家好，我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！！！如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多呀！❤❤❤爱你们！！！目录写在前面1. 面向过程与面向对象1.1 何谓“面向对象”的编程思想？1.2 面向对象的思想概述2. Java语言的基本元素：类和对象2.1 面向对象的思想概述2.2 Java类及类的成员。
复制链接

扫一扫