第二章：面向对象：三条主线

package com.atguigu.java;

/*
 * 学习Java面向对象的三条主线（第4-6章）
 * 
 * 	主线1.Java类以及类的成员：属性、方法、构造器；代码块、内部类
 * 	
 *  主线2.面向对象的三大特征：封装性、继承性、多态性、抽象性
 * 
 * 	主线3.其他关键字：this、super、static、final、abstract、interface、package、import等
 * 
 * 二、“人把大象装进冰箱”
 * 1.面向过程（POP）:强调的是功能行为，以函数作为最小单位，考虑怎么做
 *   1.把冰箱门打开
 *   2.抬起大象，塞进冰箱
 *   3.关闭冰箱门
 *   
 * 2.面向对象（OOP）:强调了具备功能的对象，以类/对象为最小单位，考虑谁来做。
 * 
 * 人{
 * 		打开（冰箱）{
 * 			冰箱.开开（）;
 * 		}
 * 
 * }
 * 
 * 冰箱{
 * 		开开（）{}
 * }
 * 
 * 三、面向对象的两个要素：
 * 		类：对一类事物的描述，是抽象的，概念上的定义
 * 		对象：是实际存在在该类事物的每个个体，因而也称为实例（instance）
 * >面向对象程序设计的重点是类的设计
 * >设计类，就是设计类的成员。
 */
public class OOPTest {
	public static void main(String[] args) {

	}
}

package com.atguigu.java;

import javax.swing.plaf.synth.SynthOptionPaneUI;

/*
 * 一、设计类，就是设计类的成员：
 * 
 *  属性 = 成员变量 = field = 域、字段
 *  方法= 成员方法 = 函数= method
 * 
 * 
 *  创建类的对象 = 类的实例化 = 实例化一个类 
 * 
 * 二、 类和对象的使用（面向对象思想落地的实现）
 * 1.创建类，设计类的成员
 * 2.创建类的对象
 * 3.通过对象.属性 或者 对象.方法 调用类的结构
 * 
 * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static的）
 * 意味着：如果我们修改一个对象的属性a,则不影响另一个对象属性a的值
 * 
 * 四、对象的内存解析
 * 
 */
//测试类
public class PersonTest {
	public static void main(String[] args) {
		// 测试Person对象
		Person p1 = new Person();// 2.创建一个对象
		// Scanner scan = new Scanner(System.in);

		// 3.调用对象的结构：属性、方法

		// 调用属性：“对象.属性”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);

		// 调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("China");

		// *************************
		Person p2 = new Person();
		System.out.println(p2.name);// null
		System.out.println(p2.isMale);// false

		// 将P1变量保存的地址值赋给p3，会导致p1和p3指向了堆空间中的同一个实体。
		Person p3 = p1;
		p3.age = 10;
		System.out.println(p2.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);
	}
}

package com.atguigu.java;
/*
 * 类中属性的使用
 * 
 * 属性（成员变量） vs 局部变量（方法下的变量都是局部变量）
 * 1.相同点：
 * 		1.1定义变量的格式：数据类型 变量名 = 变量值（三要素，缺一不可）；
 * 		1.2变量一定是先声明后使用；
 * 		1.3变量都有其所对应的作用域；
 * 
 * 2.不同点：
 * 		2.1在类中声明的位置不同
 * 		属性（成员变量）：直接定义在类的一对{}里面；
 * 		局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量；
 * 		
 * 		2.2关于权限修饰符的不同
 * 		属性（成员变量）：可以在声明属性时，指明其权限，使用权限修饰符
 * 		常用的权限修饰符：public、private、缺省、protected--->封装性
 * 		目前直接使用缺省就可以了。
 * 		
 * 		局部变量：是不可以使用权限修饰符的！
 * 
 * 		2.3默认初始化值的情况：
 * 			2.3.1属性（成员变量）：根据其类型，都有默认初始化值
 * 				整型（byte short int long）:0
 * 				浮点型（float double）:0.0
 * 				字符型（char）:0(或'\u0000')
 * 				布尔型（boolean）:flase
 * 			
 * 			引用数据类型(类、数组、接口)：null
 * 			2.3.2局部变量：没有默认初始化值
 * 				意味着，我们在调用局部变量之前，一定要显式赋值
 * 				特别的：形参在调用时我们赋值即可！
 * 		
 * 		2.4在内存中加载的位置
 * 		属性（成员变量）：加载到堆空间中(非static)
 * 		局部变量：加载到栈空间
 * 			
 * 
 */
public class UserTest {
	public static void main(String[] args) {
		
		User u1 = new User();
		System.out.println(u1.age);
		u1.eat();
		u1.talk("China");
		
	}
}

class User{
	//属性（成员变量）
	private String name;
	public int age;
	boolean isMale;
	
	public void talk(String language){//方法形参，属于局部变量
		System.out.println("我们使用" + language + "进行交流");
	}
	public void eat(){
		String food = "烙饼";//定义在方法内部，属于局部变量
		System.out.println("北方人喜欢吃" + food);
	}
}

package com.atguigu.java;

/*类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：Math类：sqrt()...
 * 		Scanner类：nextXxx...
 * 		Arrays类：sort()...
 * 
 * 1.举例：
 * 		public void eat(){} 无返回值无形参
 * 		public void sleep(int hour){} 无返回值有形参
 * 		public String getName(){} 有返回值（String类型）无形参
 * 		public String getNation(String nation){} 有返回值（String类型）有形参
 * 
 * 2.方法的声明： 权限修饰符 返回值的类型 方法名(形参列表){
 * 				 	方法体；
 * 				}
 *    注意：static、final、abstract来修饰的方法，后面再讲。
 *    
 * 3.说明：
 * 		3.1关于权限修饰符：默认方法的权限修饰符暂时都使用public
 * 			Java规定的使用4种权限修饰符：private、public、缺省、protected--->封装性再讲
 * 		3.2返回值类型：有返回值 vs 没有返回值
 * 			3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中需要使用return
 * 				关键字来返回指定类型的变量或常量：“return 数据”；
 * 				如果方法没有返回值，则在方法声明时，使用void来表示。通常，没有返回值的方法中，就不使用
 * 				return，但是如果使用的话，只能是“return;”,表示结束此方法的意思。
 * 			3.2.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) {

	}
}

class Customer {
	// 属性
	// 方法
}

package com.atguigu.exer;

public class StudentTest {
	public static void main(String[] args) {
		// 声明Student类型的数组：
		Student[] stus = new Student[20];
		// String[] s1 = new String[]{"ww","www"};
		// int[] i1 = new int[]{3,4,4};
		// 以前的时候定义一个String类型的数组，
		// 也就是说数组的元素都是String类型的，String本身也是一个类，所以我们自己定义的
		// 类也可以放在数组里，而这个数组的类型就是自己定义时的类名！
		for (int i = 0; i < 20; i++) {
			// 给数组元素赋值
			stus[i] = new Student();
			// 给对象的属性赋值
			stus[i].number = i + 1;
			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
			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].score + "," +
			// stus[i].state);
			System.out.println(stus[i].info());
		}
		System.out.println("**********");
		for (int i = 0; i < stus.length; i++) {
			if (3 == stus[i].state) {
				System.out.println(stus[i].number);
			}
		}
		System.out.println("**************");
		// 按照成绩冒泡排序：
		for (int i = 0; i < stus.length - 1; i++) {
			Student temp;
			for (int j = 0; j < stus.length - 1 - i; j++) {
				if (stus[j].score < stus[j + 1].score) {
					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;
	}
}

package com.atguigu.exer;

public class StudentTest1 {
	public static void main(String[] args) {
		Student1[] stus = new Student1[20];
		for (int i = 0; i < 20; i++) {
			stus[i] = new Student1();
			stus[i].number = i + 1;
			stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
			stus[i].score = (int) (Math.random() * (100 - 0 + 1));
		}
		//新建一个测试对象：
		StudentTest1 test = new StudentTest1();
		test.print(stus);
		test.searchState(stus, 3);
		test.popo(stus);
		test.print(stus);
	}

	/**
	 * 遍历
	 * 
	 * @param stus
	 */
	public void print(Student1[] stus) {
		for (int i = 0; i < stus.length; i++) {
			System.out.println(stus[i].info());
		}
	}

	/**
	 * 
	 * @param s
	 * @param ate
	 */
	public void searchState(Student1[] s, int ate) {
		for (int i = 0; i < s.length; i++) {
			if (ate == s[i].state) {
				System.out.println(s[i].number);
			}
		}
	}

	/**
	 * 冒泡排序
	 * 
	 * @param stus
	 */
	public void popo(Student1[] stus) {
		for (int i = 0; i < stus.length - 1; i++) {
			Student1 temp;
			for (int j = 0; j < stus.length - 1 - i; j++) {
				if (stus[j].score < stus[j + 1].score) {
					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;
	}
}