Java 学习 Day05

最新推荐文章于 2022-11-22 09:19:24 发布

心飞扬(●ˇ∀ˇ●)

最新推荐文章于 2022-11-22 09:19:24 发布

阅读量120

点赞数

分类专栏： JAVA 学习日志文章标签： java 类面向对象编程编程语言

本文链接：https://blog.csdn.net/weixin_47152812/article/details/114640349

版权

JAVA 学习日志专栏收录该内容

41 篇文章 0 订阅

订阅专栏

Java 学习 Day05

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

1.Java类及类的成员：属性、方法、构造器；代码块、内部类

2.面向对象的三大特征：封装性、继承性、多态性、（抽象性）

3.其他关键字：this、super、static、final、abstrasct、interface、package、import等

“大处着眼，小处着手”

二、“人把大象装进冰箱”

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

（1）把冰箱门打开
（2）抬起大象塞进冰箱
（3）把冰箱门关闭

2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

人{
 * 		打开(冰箱){
 * 			冰箱.开开();
 * 		}
 * 
 * 		抬起(大象){
 * 			大象.进入(冰箱);
 * 		}
 * 
 * 		关闭(冰箱){
 * 			冰箱.闭合();
 * 		}
 * 
 * }
 * 
 * 
 * 冰箱{
 * 		开开(){}
 * 		闭合(){}
 * }
 * 
 * 大象{
 * 		进入(冰箱){
 * 		}
 * }

三、面向对象的两个要素

类：对一类事物的描述，是抽象的、概念上的定义

对象：是实际存在的该类事务的每个个体，因而也称为实例（instance）

注：（1）面向对象的程序设计的重点是类的设计
（2）设计类就是设计类的成员

四、设计类的成员

1.属性=成员变量=filed=域、字段

2.方法=成员方法=函数=method

3.创建类的对象=类的实例化=实例化类

4.类和对象的使用（面向对象思想落地的实现）
（1）创建类、设计类的成员
（2）创建类的对象
（3）通过“对象.属性”或“对象.方法”调用对象的结构

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

package day08;

public class PersonTset {
	public static void main(String[] args) {
		//2.创建Person类的对象
		Person p1=new Person();
		
		//调用对象的结构：属性、方法
		//调用属性：“对象.属性”
		p1.name="Tom";
		p1.isMale=true;
		System.out.println(p1.name);
		System.out.println(p1.isMale);
		
		//调用方法
		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
		
		p3.age=10;
		System.out.println(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(name+"可以吃饭");
		
	}
	
	public void sleep() {
		System.out.println("人可以睡觉");
	}
	
	public void talk(String language) {
		System.out.println("人可以说话，使用的是："+language);
	}
}

五、类中属性的使用

属性（成员变量）VS 局部变量

1.相同点：
（1）定义变量的格式：数据类型变量名=变量值
（2）先声明，后使用
（3）变量都有其对应的作用域

2.不同点
（1）在类中声明的位置不同
①属性：直接定义在类的一对{}内
②局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
（2）关于权限修饰符的不同
①属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected（封装性）
②局部变量：不可以使用权限修饰符。
（3）默认初始化值得情况
①属性：类的属性，根据其类型，都有默认初始化值。
整型（byte、short、int、long）：0
浮点型（float、double）：0.0
字符型（char）：0 （或’\u0000’）
布尔型（boolean）：false
引用数据类型（类、数组、接口）：null

②局部变量：没有默认初始化值。意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。
（4）在内存中加载的位置
①属性：加载到堆空间中（非static）
②局部变量：加载到栈空间

package day08;

public class UserTest {
	public static void main(String[] args) {
		User u1=new User();
		System.out.println(u1.age);
		System.out.println(u1.name);
		System.out.println(u1.isMale);
		
		u1.talk("中文");
		u1.eat();
		
	}
}

class User{
	String name;
	int age;
	boolean isMale;
	
	public void talk(String laguage) {//language:形参，也是局部变量
		System.out.println("我们使用"+laguage+"交流");
	} 
	
	public void eat() {
		String food="饼";//局部变量
		System.out.println("北方人喜欢吃"+food);
				
	}
	
}

六、类中方法的声明和使用
1. 方法：描述类应该具有的功能。
比如：Math类：squrt()\random()…
Scanner类：nextXxx()…
Arrays类：sort()\binarySearch()\toString()\equals()…
2. 举例：

public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

3、方法的声明：权限修饰符返回值类型方法名（形参列表）{
方法体
}

注意：static,final,abstract来修饰的方法后面再讨论。

4、说明：
（1）关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
（2）返回值类型：有返回值 VS 无返回值
①如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中需要用return关键字来返回指定类型的变量或常量：“return 数据”。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法不需要使用return，但是如果使用的话，只能“return；”表示结束此方法的意思。

②我们定义的方法该不该有返回值？
a.题目要求
b.凭经验：具体问题具体分析

（3）方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

（4）形参列表：方法可以声明0个、1个、或多个形参。
①格式：数据类型1 形参1，数据类型2 形参2，…

②我们定义方法时，该不该定义形参？
a.题目要求
b.凭经验：具体问题具体分析

(5)方法体：方法功能的体现。

5、retrun关键字的使用
（1）使用范围：使用在方法体中
（2）作用：① 结束方法
② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
（3）注意点：return关键字后面不可以声明执行语句。

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

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

}

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

七、练习
1.利用面向对象的编程方法，设计类Circle计算圆的面积。

public class CircleTest {
	public static void main(String[] args) {
		Circle c1=new Circle();
		//方式1
//		c1.r=2.5;
//		c1.findArea();
		//方式2
//		double area=c1.findArea1();
//		System.out.println(area);
		
		//方式3
		double area=c1.findArea(2.5);
		System.out.println(area);
	}
}


class Circle{
	//方式1
//	double r;
//	public void findArea() {
//		double area = Math.PI*r*r;
//		System.out.println("圆的面积为"+area);
//	}
	
	//方式2
//	public double findArea1() {
//		double area = Math.PI*r*r;
//		return area;
//	}
	
	//方式3
	public double findArea(double r){
		double area = Math.PI * r * r;
		return area;
	}
}

2.1 编写程序，声明一个method方法，在方法中打印一个108 的型矩形，在main方法中调用该方法。
2.2 修改上一个程序，在method方法中，除打印一个108的型矩形外，再计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

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

package day08;

public class ExerTest {
	public static void main(String[] args) {
		ExerTest test=new ExerTest();
		//2.1
//		test.method();
		
		//2.2
//		方式1
//		int area=test.method();
//		System.out.println("面积为"+area);
//		方式2
//		System.out.println(test.method());
		
		//2.3
		int area = test.method(12, 10);
		System.out.println("面积为：" + area);
	}

	//2.1 
//	public void method(){
//		for(int i = 0;i < 10;i++){
//			for(int j = 0;j < 8;j++){
//				System.out.print("* ");
//			}
//			System.out.println();
//		}
//	}
	
	//2.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;
//	}
	
	//2.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;
	}
}

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

提示：

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

public class StudentTest {
	public static void main(String[] args) {
		//声明Student类型的数组
		Student[] stus=new Student[20];
		
		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;
	}
}

此代码是对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 jzh
		 * @date Mar 14, 2021 9:21:16 PM
		 * @param n
		 * @return
	 */
	public void print(Student1[] stus){
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
	}
	/**
	 * 
		 * 
		 * @Description 查找Stduent数组中指定年级的学生信息
		 * @author jzh
		 * @date Mar 14, 2021 9:21:55 PM
		 * @param n
		 * @return
	 */
	 

	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 jzh
		 * @date Mar 14, 2021 9:22:21 PM
		 * @param n
		 * @return
	 */
	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;
	}
	
}

心飞扬(●ˇ∀ˇ●)

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 学习 Day05

Java 学习 Day05一、Java面向对象学习的三条主线1.Java类及类的成员：属性、方法、构造器；代码块、内部类2.面向对象的三大特征：封装性、继承性、多态性、（抽象性）3.其他关键字：this、super、static、final、abstrasct、interface、package、import等“大处着眼，小处着手”二、“人把大象装进冰箱”1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。（1）把冰箱门打开（2）抬起大象塞进冰箱（3）把冰箱门关闭2.面向对象
复制链接

扫一扫