Java基础第五天：面向对象（上）

原创 于 2021-01-13 16:43:22 发布 · 130 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文围绕Java面向对象编程展开，介绍了面向对象的三条主线，对比了面向对象和面向过程，阐述了类和对象的概念，分析了类中属性与局部变量的异同，说明了方法的使用。此外，还给出多个练习，包括计算圆面积、打印矩形及计算面积，以及学生对象数组的操作等。

面向对象的三条主线

  • java类及类的成员：属性、方法、构造器；代码块、内部类。
  • 面向对象的三大特征：封装性、继承性、多态性（主要注重在代码中的体现）、（抽象性:如果说有四个特征）
  • 其他关键字：this、super、static、final、abstract、interface、package等

面向对象和面向过程

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

类和对象

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

  • 对象：是实际存在的该类事物的每个个体，因而也称为实例。

  • 类及类的成员：

    • 属性

      • 属性 = 成员变量 = field = 域、字段

    • 方法

      • 方法 = 成员方法 = 函数 = Method

    • 创建类的对象 = 类的实体化 = 实例化类

package com.atguigu.class1;
/*
 * 一、设计类，其实就是设计类的成员
 * 
 *  属性 = 成员变量 = 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);
	}
	
}

类中属性的使用 属性（成员变量） 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 static void means(String[] b，int a){
	//public 是权限修饰符
	//权限修饰符有四种：private、 public 、 缺省 、 protected
	
	//static 修饰方法  有 static 、 final 、 abstract
	
	//void 表示返回值
	//如果 int 型 则要返回一个int  == return 0;

	//means是方法名 ： 属于标识符，要符合他的功能-->见名知意
	
	//(String[] b，int a) 是形参列表
}

可以在方法中调用方法

class hanShu(){
	String name;
	int age = 10 ;
	boolean = isMale;
//方法
	public void eat(){
		sleep();//方法中可以调用方法
	}
	public void sleep(){
	}


}

练习

练习1：
在这里插入图片描述

package com.atguigu.class1;

public class exer1 {
	public static void main(String[] args) {
		Person2 p1 = new Person2();
		p1.name = "tom";
		p1.age = 11;
		p1.sex = 1;
		
		p1.study();
		p1.addAge();
		p1.showAge();
		
		Person2 p2 = new Person2();
		p2 = p1;
		p2.showAge();
	}
}

class Person2{
	String name;
	int age;
	int sex;
	/**
	 * sex = 1表示男性
	 * sex = 0 表示女性
	 */
	
	public void study(){
		System.out.println("studying");
	}
	public void showAge(){
		System.out.println("年龄为" + age + "岁");
	}
	public int addAge(){
		age = age + 2;
		return age;
	}
}

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

package com.atguigu.class1;

public class area {
	public static void main(String[] args) {
		CountArea a1 =new CountArea();
		a1.radius = 1;
		a1.count();
	}
}

class CountArea{
		//属性
	double radius;
	
	public void count(){
		double area = Math.PI * radius * radius;
		System.out.println("面积是" + area);
		
	}
}

练习3：

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

public class exer3 {
	public static void main(String[] args) {
		Method a = new Method();
		a.col = 8;
		a.row = 10;
		a.print_juxing();
		a.countareanum();

	}
	
}

class Method{
	int area;
	int col;
	int row;
	public void print_juxing(){
		for(int i = 0 ; i < row ; i++){
			for(int j = 0 ; j < col ; j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
	
	public void countareanum(){
		area = col * row;
		System.out.println(area);
	}
}

重要练习

  1. 对象数组题目：
    定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩
    score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
    问题一：打印出3年级(state值为3）的学生信息。
    问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
    提示：
  1. 生成随机数：Math.random()，返回值类型double;
  2. 四舍五入取整：Math.round(double d)，返回值类型long。
package com.atguigu.class1;
/*
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 exer3{
	public static void main(String[] args) {
		//重要
		Student[] stu = new Student[20];
		
		for(int i = 0 ; i < stu.length ; i++){
			stu[i] = new Student();
			stu[i].number = i + 1;
			//[1,6]
			stu[i].state = (int)(Math.random() * (6-1+1) + 1);
			//[0,100]	
			stu[i].score = (int)(Math.random() * (100 + 1));
		}
		//所有学生
		for(int i = 0 ; i< stu.length ; i++){
			System.out.println(stu[i].info());
		}
		System.out.println();
		System.out.println("輸出三年級學生的成績：");
		//三年级学生
		for(int i = 0 ; i< stu.length ; i++){
/*			if(stu[i].state == 3){
				System.out.println("学号为" + stu[i].number + "的学生" + "成绩为" + stu[i].score);
			}*/
			if(stu[i].state == 3){
				System.out.println(stu[i].info());
			}
		}
		System.out.println();
		System.out.println("輸出所有學生排序后的成績");
		//冒泡排序
		
		for(int i = 0 ; i < stu.length -1 ; i++ ){
			
			int flag = 0;
			for(int j = 0 ; j < stu.length -1;j++){
				
				if(stu[j].score > stu[j+ 1].score){
					//重要
					Student temp = new Student();
					temp = stu[j];
					stu[j] = stu[j + 1];
					stu[j + 1] = temp;
					flag = 1;
				}
			}
			if(flag == 0 ) break;
		}
		
		//所有学生
		for(int i = 0 ; i< stu.length ; i++){
			System.out.println(stu[i].info());
		}
	}
}

class Student{
	int number;
	int state;
	int score;
	
	
	public String info(){
		return ("学号为" + number + "的学生" + "成绩为" + score);
	}
	
}

由于main函数中很多功能可以简化为方法 ， 简化后的代码如下：

package com.atguigu.class1;
/*
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 exer3{
	public static void main(String[] args) {
		//重要
		Student[] stu = new Student[20];
		exer3 test = new exer3();
		test.inputnum(stu);
		test.print_score(stu);
		System.out.println("输出三年级的成绩");
		test.research_state(stu, 3);
		System.out.println("输出排序后的成绩");
		test.Bulletsort(stu);
		test.print_score(stu);
		
	}
	//方法
	/**
	 * @description 输入学生数据
	 * @author jianghao
	 * @param stu
	 */
	public void inputnum(Student[] stu){
		for(int i = 0 ; i < stu.length ; i++){
			stu[i] = new Student();
			stu[i].number = i + 1;
			//[1,6]
			stu[i].state = (int)(Math.random() * (6-1+1) + 1);
			//[0,100]	
			stu[i].score = (int)(Math.random() * (100 + 1));
		}
	}
	/**
	 * @Descriptions 遍历state年级的所有学生的成绩
	 * @auther janghao
	 * @data 2021/1/13 星期三 16：30
	 * @param stu表示要遍历的数组
	 * @param state表示要遍历的年级
	 */
	public void research_state(Student[] stu,int state){
		for(int i = 0 ; i< stu.length ; i++){
/*			if(stu[i].state == 3){
				System.out.println("学号为" + stu[i].number + "的学生" + "成绩为" + stu[i].score);
			}*/
			if(stu[i].state == state){
				System.out.println(stu[i].info());
			}
		}
	}
	
	/**
	 * @Descriptions 遍历所有学生的成绩
	 * @auther janghao
	 * @data 2021/1/13 星期三 16：30
	 * @param stu 表示要遍历的数组
	 */
	public void print_score(Student[] stu){
		for(int i = 0 ; i< stu.length ; i++){
			System.out.println(stu[i].info());
		}
	}
	/**
	 * @descriptions 冒泡排序
	 * @auther jianghao
	 * @param stu
	 */
	public void Bulletsort(Student[] stu){
		for(int i = 0 ; i < stu.length -1 ; i++ ){
			
			int flag = 0;
			for(int j = 0 ; j < stu.length -1;j++){
				
				if(stu[j].score > stu[j+ 1].score){
					//重要
					Student temp = new Student();
					temp = stu[j];
					stu[j] = stu[j + 1];
					stu[j + 1] = temp;
					flag = 1;
				}
			}
			if(flag == 0 ) break;
		}
	}
}

class Student{
	int number;
	int state;
	int score;
	
	
	public String info(){
		return ("学号为" + number + "的学生" + "成绩为" + score);
	}
	
}
Camellia0212
关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值