java面向对象(1)

一.面向对象的思想概述

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

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

2.“万事万物皆对象”

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

---

二.Java类和对象

类: 类是一个模板，它描述一类对象的行为和状态。
对象: 对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

常见的类的成员有：
属 性：对应类中的成员变量
行 为：对应类中的成员方法
Field = 属性 = 成员变量，Method = (成员)方法 = 函数

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

/*
 * 一、设计类,其实就是设计类的成员
 * 
 * 属性=成员变量=field=域、字段
 * 方法=成员方法=函数=method
 * 
 * 创建类的对象 = 类的实例化 = 实例化类
 * 
 * 二、类和对象的使用(面向对象思想落地的实现):
 * 	1.创建类,设计类的成员
 * 	2.创建类的对象
 * 	3.通过"对象.属性" 或 "对象.方法"调用对象的结构
 */

//测试类
public class PersonTest {
	public static void main(String[] args) {
		//创建Person类的对象
		Person p1=new Person();
		
		//调用对象的结构:属性、方法
		//调用属性:"对象.属性"
		p1.name="张三";
		p1.isMale=true;
		System.out.println(p1.name);
		System.out.println(p1.age);
		
		//调用方法:"对象.方法"
		p1.eat();
		p1.sleep();
		p1.talk("中文");
		
	}
}


输出结果为:
张三
1
人可以吃饭
人可以睡觉
人可以说话,使用的是中文

三.对象的内存解析

---

四.类中属性的使用

/*
 * 类中属性的使用
 * 
 * 属性(成员变量) 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 user=new User();
		System.out.println(user.name);//null
		System.out.println(user.age);//0
		System.out.println(user.isMale);//false
		
		user.talk("英语");
		user.eat();
	}
}

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

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

---

五.类中方法的声明和使用

/*
 * 类中方法的声明和使用
 * 
 * 方法:描述类应该具有的功能.
 * 比如:Math类:sqrt()\random() \...
 * 		Scanner类:nextXxx()...
 * 		Arrays类:srot() \ 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 没有返回值
 * 			1.	①如果方法有返回值,则必须在方法声明时,指定返回值得类型.同时,在方法中需要
 * 				使用return关键字来返回指定类型的变量或常量:"return 数据"
 * 				②如果方法没有返回值,则方法声明时,使用void来表示.通常,没有返回值的方法中
 * 				就不需要使用return.但是,如果使用的话,只能"return;"来表示结束此方法的意思
 * 
 * 			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 customer=new Customer();
		
		customer.eat();
		customer.sleep(3);
	}
}


//客户类
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 + "个小时");
	}
	
	public String getName() {
		return name;
	}
	
	public String getNation(String nation) {
		String info = "客户的国籍是:" + nation;
		return info;
	}
}

六.练习题

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

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

public class Person {
	//属性
	String name;
	int age;
	/**
	 * sex:1表示男
	 * sex:2表示女
	 */
	int sex;
	
	//方法
	public void study() {
		System.out.println("studying");
	}
	
	public void showAge() {
		System.out.println("age:"+ age);
	}
	
	public int addAge(int i) {
		age+=i;
		//age=age+i;
		return age;
	}
}

//测试类
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);
	}
}


输出结果为:
studying
age:18
Tom的新年龄为:20

---

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

//圆
public class Circle {
	//属性
	double radius;
	
	//求圆的面积
	public double findArea() {
		double area=Math.PI * radius * radius;
		return area;
	}
}

//测试类
public class CircleTest {

	public static void main(String[] args) {
		Circle circle=new Circle();
		
		circle.radius = 2.1;
		
		double area = circle.findArea();
		System.out.println("圆的面积为:"+area);//13.854423602330987
		
	}

}

---

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

/*
 * 3.1编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，
	在main方法中调用该方法。
 */
public class Test1 {
	public static void main(String[] args) {
		Test1 test1=new Test1();
		test1.method();
		
		
	}
	
	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 修改上一个程序，在method方法中，除打印一个10 * 8的 * 型矩形外，再
计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，
接收返回的面积值并打印。

public class Test2 {
	public static void main(String[] args) {
		Test2 test2=new Test2();
		System.out.println(test2.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;
	}
}

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

public class Test3 {
	public static void main(String[] args) {
		Test3 test3=new Test3();
		int area= test3.method(12, 10);
		System.out.println(area);
	}
	
	public int method(int m,int n) {
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 8; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		return m * n;
	}
}

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

//学生类
public class Student {
	int number;//学号
	int state;//年级
	int score;//成绩
	
	public String info() {
		return "学号为:" + number + ",年级为:" + state + ",成绩为:"  + score;
	}
	
	//遍历Student[]数组的操作
	public void print(Student[] students) {
		for (int i = 0; i < students.length; i++) {
			System.out.println(students[i].info());
		}
	}
	
	//查找Student数组中指定年级的学生信息
	public void searchState(Student[] students,int state) {
		for (int i = 0; i < students.length; i++) {
			if (students[i].state == state) {
				System.out.println(students[i].info());
			}
		}
	}
	
	//给Student数组排序
	public void sort(Student[] students){
		for (int i = 0; i < students.length -1; i++) {
			for (int j = 0; j < students.length -1 -i; j++) {
				if (students[j].score > students[j+1].score) {
					//如果需要换序,交换的是数组元素:Student对象!!!
					Student temp =students[j];
					students[j] = students[j+1];
					students[j+1] = temp;
				}
			}
		}
	}	
}

public class StudentTest {
	//测试类
	public static void main(String[] args) {
		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) +0);
		}
		
		Student student=new Student();
		
		//遍历学生数组
		student.print(stus);
		
		System.out.println("**********************************");
		
		//问题一:打印3年级(state值为3)的学生信息
		student.searchState(stus, 3);
		
		System.out.println("**********************************");
		
		//问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息
		student.sort(stus);
		
		//遍历学生数组
		student.print(stus);
	}
}

---