008面向对象编程（上）-1

面向过程与面向对象

• Java类及类的成员：属性、方法、构造器；代码块、内部类
• 面向对象的三大特征：封装性、继承性、多态性、(抽象性)

类和对象

• 一、设计类，其实就是设计类的成员
• 属性 = 成员变量 = field = 域、字段
• 方法 = 成员方法 = 函数 = method
• 创建类的对象 = 类的实例化 = 实例化类
• 二、类和对象的使用（面向对象思想落地的实现）：
• 1.创建类，设计类的成员
• 2.创建类的对象
• 3.通过“对象.属性”或“对象.方法”调用对象的结构
• 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
• 意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

属性

方法

生成随机数：Math.random()，返回值类型double; (a,b) = Math.random() * (b - a + 1) + a;
四舍五入取整：Math.round(double d)，返回值类型long。

练习1：对象数组

方式一：
package com.atguigu.exer;
/*
 * . 对象数组题目：
定义类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) {
		//1.创建20个学生对象，可以使用数组方式存储
		//要想存储对象的地址值，数组创建时类型需要使用类名
		Student[] stud = new Student[20];
		//2.循环创建对象
		for(int i = 0; i < 20; i++){
			//上面创建了类类型的数组，直接将new出的类存储到数组元素中即可
			stud[i] = new Student();
			stud[i].number = i + 1;
			stud[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			stud[i].score = (int)(Math.random() * (100 - 0 + 1));
		}

		//3.输出测试
		for(int i = 0; i < stud.length; i++){
			System.out.println(stud[i].info());
		}
		System.out.println("===============搜索指定年级===============");
		//4.打印出3年级(state值为3）的学生信息。
		for(int i = 0; i < stud.length; i++){
			if(stud[i].state == 3){
				System.out.println(stud[i].info());
			}
		}
		System.out.println("==============排序================");
		//5.使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for(int i = 0; i < stud.length - 1; i++){
			for(int j = 0; j < stud.length - 1 - i; j++){
				if(stud[j].score < stud[j+1].score){
					//调换的是存储在数组中的地址值
					Student temp = stud[j];
					stud[j] = stud[j+1];
					stud[j+1] = temp;
				}
			}
		}
		//6.打印测试
		for(int i = 0; i < stud.length; i++){
			System.out.println(stud[i].info());
		}

	}
}

class Student{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	public String info(){
		return "学号：" + number + "年级：" + state + "成绩：" + score;
	}
	
}

方式二：
package com.atguigu.exer;

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

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

 * 
 */
public class StudentTest1 {
	public static void main(String[] args) {
		//1.创建20个学生对象，可以使用数组方式存储
		//要想存储对象的地址值，数组创建时类型需要使用类名
		Pupil[] stud = new Pupil[20];
		//2.循环创建对象
		for(int i = 0; i < 20; i++){
			//上面创建了类类型的数组，直接将new出的类存储到数组元素中即可
			stud[i] = new Pupil();
			stud[i].number = i + 1;
			stud[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			stud[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		StudentTest1 student = new StudentTest1();
		//3.输出测试
		student.print(stud);
		System.out.println("===============搜索指定年级===============");
		//4.打印出3年级(state值为3）的学生信息。
		student.search(stud, 3);
		System.out.println("==============排序================");
		//5.使用冒泡排序按学生成绩排序，并遍历所有学生信息
		student.order(stud);
		//6.打印测试
		student.print(stud);

	}
	
	/**
	 * 
	* @Description 输出全部信息 
	* @author xiaojie
	* @date 2021年1月20日上午10:16:48
	* @param stud 传入Pupil类型数组
	 */
	public void print(Pupil[] stud){
		for(int i = 0; i < stud.length; i++){
			System.out.println(stud[i].info());
		}
	}
	/**
	 * 
	* @Description 搜索指定班级 
	* @author xiaojie
	* @date 2021年1月20日上午10:18:43
	* @param stud 传入数组
	* @param dest 要搜索的年级
	 */
	public void search(Pupil[] stud, int dest){
		for(int i = 0; i < stud.length; i++){
			if(stud[i].state == dest){
				System.out.println("学号：" + stud[i].number + "	" + 
						"年级：" + stud[i].state + "	" + "成绩：" + stud[i].score );
			}
		}
	}
	/**
	 * 
	* @Description 使用冒泡排序方法将数组进行从大到小的排序 
	* @author xiaojie
	* @date 2021年1月20日上午10:22:40
	* @param stud 传入Pupil类型数组
	 */
	public void order(Pupil[] stud){
		for(int i = 0; i < stud.length - 1; i++){
			for(int j = 0; j < stud.length - 1 - i; j++){
				if(stud[j].score < stud[j+1].score){
					//调换的是存储在数组中的地址值
					Pupil temp = stud[j];
					stud[j] = stud[j+1];
					stud[j+1] = temp;
				}
			}
		}
	}
}

class Pupil{
	int number;//学号
	int state;//年纪
	int score;//成绩
		
	public String info(){
		String result = "学号：" + number + "	" + "年级：" + state + "	" + "成绩：" + score;
		return result;
	}
}

练习2：类与对象

package com.atguigu.java;
/*
定义银行账户类Account，有属性：卡号cid，余额balance，所属用户Customer   
银行账户类Account有方法：
（1）getInfo()，返回String类型，返回卡的详细信息
（2）取钱方法withdraw()，参数自行设计，如果取钱成功返回true，失败返回false
（3）存钱方法save()，参数自行设计，如果存钱成功返回true，失败返回false
   
其中Customer类有姓名、身份证号、联系电话、家庭地址等属性
    Customer类有方法say()，返回String类型，返回他的个人信息。
在测试类Bank中创建银行账户类对象和用户类对象，并设置信息，与显示信息
 */
public class Bank {
	public static void main(String[] args) {
		Account account = new Account();
		Customer customer = new Customer();
		account.cid = 888888; 
		System.out.println(account.getInfo(customer));
		System.out.println(account.withdraw(1000));
		System.out.println(account.getInfo(customer));
		System.out.println(account.save(500));
		System.out.println(account.getInfo(customer));
	}
}

class Account{
	int cid;
	double balance = 1000;
	//所属用户Customer
	/**
	 * 
	* @Description 显示客户银行卡信息 
	* @author xiaojie
	* @date 2021年1月24日下午8:12:15
	* @return 返回账户信息
	 */
	public String getInfo(Customer customer){
		customer.name = "jerry";
		customer.identityCard = "130111222233334444";
		customer.contactPhone = "13511112222";
		customer.homeAddress = "大屯路东";
		String info = "cid: " + cid + "
" + "balance: " + balance + "
"
						+ customer.say();
		return info;
	}
	/**
	 * 
	* @Description 客户取钱功能 
	* @author xiaojie
	* @date 2021年1月24日下午8:13:30
	* @param money 取走金额
	* @return
	 */
	public boolean withdraw(double money){
		if(money > 0.0 && balance >= money){
			balance -= money;
			return true;
		}else{
			return false;
		}
	}
	/**
	 * 
	* @Description 客户存钱功能
	* @author xiaojie
	* @date 2021年1月24日下午8:18:12
	* @param money 存入金额
	* @return 
	 */
	public boolean save(double money){
		if(money > 0.0){
			balance += money;
			return true;
		}else{
			return false;
		}
	}	
}

class Customer{
	String name;
	String identityCard;
	String contactPhone;
	String homeAddress;
	public String say(){
		String info = "name: " + name + "
" + "identityCard: " + identityCard + "
"
			+ "contactPhone: " + contactPhone + "
" + "homeAddress: " + homeAddress;
		return info;
	}
}

练习3：计算圆柱体

package com.atguigu.java;
/*
 * （1）声明一个圆柱体类型，
（2）声明属性：底边的半径，和高
（3）声明方法：
A：方法的功能：在方法中打印圆柱体的详细信息
	圆柱体的底边的半径是xxx，高是xxx，底面积是xxx，体积是xxx。
B：方法的功能：返回底面积 
C：方法的功能：返回体积
D：方法的功能：为圆柱体的底边的半径，和高赋值
E：方法的功能：为圆柱体的底边的半径，和高赋值，并返回赋值的结果
	如果底边的半径或高为<=0，赋值失败，返回false，否则返回true

 */

class Cylinder{
	//声明属性：底边的半径，和高
	double redius;
	double height;
	//在方法中打印圆柱体的详细信息
	//A 圆柱体的底边的半径是xxx，高是xxx，底面积是xxx，体积是xxx。
	public void getInfo(){
		System.out.println("圆柱体的底边的半径是: " + redius + ", " + "高是: " + height
				+ ", " + "底面积是: " + bottom() + ", " + "体积是: " + area());
	}
	//B 返回底面积
	public double bottom(){
		return Math.PI * redius * redius;
	}
	//C 返回体积
	public double area(){
		return bottom() * height;
	}
	//D 为圆柱体的底边的半径，和高赋值
	public void assign(double r, double h){
		redius = r;
		height = h;
	}
	//E 为圆柱体的底边的半径，和高赋值，并返回赋值的结果
	//如果底边的半径或高为<=0，赋值失败，返回false，否则返回true
	public boolean assignIf(double r,double h){
		if(r <= 0 || h <=0){
			return false;
		}else{
			assign(r,h);
			//System.out.println("redius: " + redius + "	" + "height: " + height);
			return true;
		}		
	}
}

public class CylinderTest {
	public static void main(String[] args) {
		Cylinder cylinder = new Cylinder();
		boolean flag = cylinder.assignIf(5, 0);
		if(!flag){
			System.out.println("赋值失败");
		}else{
			cylinder.getInfo();
		}
	}
}

练习4：写出运行结果

class Demo{
    public static void main(String[] args){
        show(0);
        show(1);
    }
    public static void show(int i){
        switch(i){
            default:
          		i+=2;
            case 1:
            	i+=1;
            case 4:
				i+=8;
            case 2:
            	i+=4;
        }
        System.out.println("i="+i);
    }
}

class Demo{
    public static void main(String[] args){
        int x = 1;
        for(show('a'); show('b') && x<3; show('c')){
            show('d'); 
            x++;
        }
    }
    public static boolean show(char ch){
        System.out.print(ch);
        return true;
    }
}

public class Test1 {
	public static boolean foo(char c) {
		System.out.print(c);
		return true;
	}

	public static void main(String[] args) {
		int i = 0;
		for (foo('A'); foo('B') && (i < 2); foo('C')) {
			i++;// 1 2
			foo('D');
		}
	}
}