类的设计、方法声明、对象数组练习（计算圆的面积）

原創 qq_45766098 2020-06-29 18:58

练习一：类的设计

在这里插入图片描述
先新建一个Person

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;
	}
}

再建一个PersonTest来调用Person方法

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();
		
	}
}

练习二：类的设计

利用面向编程方法，设计类Circle计算圆的面积
方式一

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

		Circle c1 = new Circle();//创建一个对像

		c1.radius = 2.1;//给半径一个数，随便赋值

		double area = c1.findArea();
		System.out.println(area);
	}
}

// 圆
class Circle {

	// 属性，定义一个半径
	double radius;

	// 求圆的面积
	public double findArea() {
		double area = Math.PI * radius * radius;//这里直接调用了
		//double area = 3.14 * radius * radius;和上面的一样，只是没有那么精细
		return area;
	}

}

方式二

public class Test {
	public static void main(String[] args) {
		Circle c1 = new Circle();

		c1.radius = 2.1;// 给半径赋值

		c1.findArea();

	}
}

//圆
class Circle {

	// 属性，定义了一个半径
	double radius;

	// 求圆的面积
	public void findArea() {
		double area = Math.PI * radius * radius;// 这里直接调用了
		// double area = 3.14 * radius * radius;和上面的代码一样，只是没有那么精细
		System.out.println("面积为：" + area);
	}

}

错误的示例

public class CircleTest {
	public static void main(String[] args) {
		
		Circle c1 = new Circle();
		
		c1.radius = 2.1;

		double area = c1.findArea(3.4);
		System.out.println(area);
		
	}
}

//圆
class Circle{
	
	public double findArea(double r){//不能直接在里面定义形参
		double area = 3.14 * r * r;
		return area;
	}	
}

练习三:方法声明

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

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

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

		Test test = new Test();

		test.method();
	}

	public void method() {
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 8; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
	}
}

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

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

		Test test = new Test();

		int area = test.method();
		System.out.println("面积为" + area);
		// 以下这种方式和上面两行代码所表示的意思一样，只是更为简洁
		// System.out.println("面积为"+test.method());
	}

	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;
	}
}

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

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

		Test test = new Test();

		int area = test.method(12, 11);
		System.out.println("面积为" + area);
//		 以下这种方式和上面两行代码所表示的意思一样，只是更为简洁
//		 System.out.println("面积为"+test.method(11,10));
	}

	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;
	}
}

练习四：对象数组

定义类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 Student {
	public static void main(String[] args) {

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

		for (int i = 0; i < stus.length; i++) {

			stus[i] = new Student();// 给数组元素赋值

			stus[i].number = (i + 1);// 给Student对象的属性赋值

			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);// 年级：[1,6]

			stus[i].score = (int) (Math.random() * (100 - 0 + 1));// 成绩：[0,100]
		}
		// 这里可以遍历学生数组
		for (int j = 0; j < stus.length; j++) {
			System.out.println(stus[j].info());// 在这里调用显示学生信息的方法
		}
	}

}

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

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

}

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

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

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

		for (int i = 0; i < stus.length; i++) {

			stus[i] = new Student();// 给数组元素赋值

			stus[i].number = (i + 1);// 给Student对象的属性赋值

			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);// 年级：[1,6]

			stus[i].score = (int) (Math.random() * (100 - 0 + 1));// 成绩：[0,100]
		}

		// 遍历学生数组
		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());
			}
		}

		// 遍历学生数组
		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;
	}

}

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

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

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

		for (int i = 0; i < stus.length; i++) {

			stus[i] = new Student();// 给数组元素赋值

			stus[i].number = (i + 1);// 给Student对象的属性赋值

			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);// 年级：[1,6]

			stus[i].score = (int) (Math.random() * (100 - 0 + 1));// 成绩：[0,100]
		}

		// 遍历学生数组
		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("********************");

		// 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		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;
	}

}

对问题一和问题二进行优化

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);

	}

	// 遍历Student1[]数组的操作，封装
	public void print(Student1[] stus) {
		for (int i = 0; i < stus.length; i++) {
			System.out.println(stus[i].info());
		}
	}

	// 查找Stduent数组中指定年级的学生信息 ，stus 要查找的数组 ，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());
			}
		}
	}

	// 给Student1数组排序
	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;
	}

}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

生成器、原型模式——创建型设计模式

生成器 封裝一個對象的構造過程，並允許按步驟構造 參考JDK 1.8 源碼簡易的 StringBuilder 實現： class AbstractStringBuilder { protected: char[] value

零度苏打 2020-07-02 18:43:41

类中方法的使用和声明

類中方法的使用 方法：描述類應該具有的功能。 比如：Math類：sqrt()\random() … Scanner類：nextXxx() …與鍵盤交互，獲取數據的 Arrays類：sort() \ binarySearch() \

qq_45766098 2020-06-29 18:58:41

面向对象编程的重要知识及要点

面向對象的主線： Java類及類的成員：屬性、方法、構造器（高頻）；代碼塊、內部類（低頻） （類是由對象派生的） 面向對象的三大特徵：封裝(Encapsulation)、繼承(Inheritance)、多態(Polymor

qq_45766098 2020-06-29 18:58:41

类和对象的创建及使用，JVM内存结构与对象的内存解析，匿名对象

類和對象的創建及使用 類和對象的使用（面向對象思想落地的實現）： 1.創建類，設計類的成員 2.創建類的對象 3.通過“對象.屬性”或“對象.方法”調用對象的結構 先創建一個類，再創建person類的對象，並且調用。 public

qq_45766098 2020-06-29 18:58:41

简单工厂、抽象工厂、工厂——创建型设计模式

amara ๑•̌.•̑๑ 2020-04-03 05:13:21

Java面向对象概念以及常见面试题

倚栏静望 2020-03-16 19:50:24

Java--构造函数，this关键字

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--抽象类，接口

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--多态

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--代码块

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--包|权限修饰符

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--继承

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--static关键字

roll_(¦3」∠)_back 2020-02-23 19:04:33

Java--private关键字与get和set方法的理解

roll_(¦3」∠)_back 2020-02-23 19:04:33

类和对象的创建及使用，对象的内存解析

qq_45766098 2020-02-23 09:01:38