java_day06： 面向对象（基础版）快速掌握

1.面向对象概念

1.1 面向过程：封装（功能的封装，函数）

**典型语言：**C语言
特点：以线性思维来思考解决问题，强调一步一步
强调程序员是一个执行者
**优点：**执行效率高
**缺点：**代码的扩展性、复用性和可维护性都很差！
**使用场合：**适用于小型项目（例如：计算器，嵌入式开发）

1.2 面向对象：封装（数据field和功能method的封装），继承，多态

典型语言：java,c++,C#,Object-c
特点：以非线性思维来思考解决问题，强调宏观上的把控
强调程序员是一个指挥者
**优点：**代码的扩展性、复用性和可维护性都很高！
**缺点：**执行效率低

1.3 面向过程和面向对象举例

如何开汽车？
—面向过程分析 —面向对象分析
1.踩离合 * 驾驶员
2.挂挡 * 汽车
3.踩油门，放离合 * 驾驶员开汽车
4.车开了 car.start();
如何修建房子？
—面向过程分析 —面向对象分析
1.设计房子 * 设计师
– 修建几层楼，几间卧室等 – 负责房屋设计
2.购买材料 * 采购员
– 建筑材料、装修材料等 – 负责材料购买
3.修建毛坯房 * 建筑工人
– 憨实地基，修建房屋等 – 负责房屋建设
4.房屋装修 * 装修工人
– 卫生间先防水后贴地板等 – 负责房屋装修
5.入住 * 入住

2. 类和对象

2.1 对象

从**编程思维方式：**万物皆对象！
例如：
教室里的同学，每个桌子凳子，窗户

2.2 类

从**编程思维方式：**是对一类事物的抽象，抽象就是提取这一类事物的共同属性和行为。
例如：班上的同学都有姓名、年龄、身高、性别等相同属性，也有吃饭、睡觉、学习等相同行为，那么我们就可以把班上的同学抽象提取出来一个Student类（学生类）

2.3 类和对象的关系

从编程的角度上分析我们可以通过类为模板，从而创建出一个一个的对象
关系：对象是类的实例，类是对象的模板
例如：汽车厂通过图纸（类）为模板，然后创建出一辆辆的小汽车（对象）

3. 面向对象编程

**核心：**有类和对象，然后以面向对象思维解决问题

3.1 如何声明一个类？？

语法：[权限修饰符]class类名{}
注意事项：
a)"权限修饰符"可选的，要么使用“public”，要么省略
b)使用“class”修饰的就是一个类
c)在Java编程中，所有的代码（数据和功能）都必须写在类中（大括号中）

3.2 类中包含的内容有哪些

a)属性（数据），定义在类中，方法体之外
1)成员变量，又称为实例变量
2)静态变量，又称之为类变量
b)方法（功能），定义在类中，方法体之外
1）成员方法，又称之为非静态方法
2）静态方法，又称之为类方法

3.3 成员变量

定义位置：在类中，方法体之外（也就是全局作用域中）
定义语法：[修饰符]数据类型 变量名；
“修饰符”中不包含static关键字
操作成员变量语法：对象.成员变量名
赋值和取值
补充：在成员方法中操作当前类中的成员变量，那么直接通过“成员变量名”操作即可

3.4 成员方法

定义位置：在类中，方法体之外（也就是在全局作用域中）
定义语法：【修饰符】返回值类型 方法名（形参类表）{}
“修饰符”中不包含static关键字
操作成员变量方法：对象.成员方法名（实参列表）
调用成员方法
补充：在成员方法中调用当前类中的成员方法，那么直接通过“方法名（实参列表即可）”调用即可

3.5 创建对象

核心：通过类中为模板，然后实例化对象
例如：Student stu = new Student();

主程序

class Test {}
public class Test01 {
	
	public static void main(String[] args) {		
		// 创建学生对象
		Student stu1 = new Student();
		// 给成员变量赋值
		stu1.name = "张三";
		stu1.age = 38;
		stu1.sex = '男';
		stu1.weight = 130;
		// 成员变量取值操作
		System.out.println("name:" + stu1.name + " age:" + stu1.age + 
							" sex:" + stu1.sex + " weight:" + stu1.weight);
		// 操作成员方法
		stu1.eat("小龙虾");
		/*stu1.study();
		stu1.sleep(11);*/
	}
}

Studen学生类

package com.whsxt.p2.object;
/**
 * Student类中包含的属性和行为：
 * 	     成员变量(属性)：姓名、年龄、性别、体重、...
 * 	     成员方法(行为)：吃饭、睡觉、学习	
 *
 */
public class Student {
	// 成员变量，此处建议省略修饰符
	String name; // 姓名
	int age; // 年龄
	char sex; // 性别
	double weight; // 体重
	
	// 成员方法，此处建议省略修饰符
	// 吃饭
	void eat(String food) {
		System.out.println(name + "用筷子吃" + food);
		// 调用当前中的成员方法
		study();
	}
	// 睡觉
	void sleep(int time) {
		System.out.println(time + "点钟睡觉！");
	}
	// 学习
	void study() {
		System.out.println(name + "说: 好好学习，天天向上！");
		sleep(11);
	}
}

问题1：局部变量没有默认值，所以我们不能对只声明未赋值的变量做读取操作。
问题2：请问成员变量有没有默认值呢？？？
1.属性的默认值
属性包含：成员变量和静态变量
整数类型（byte、short、int和long）的默认值为：0
小数类型（float和double）的默认值为：0.0
字符型（char）的默认值为：\u0000，代表一个空格
布尔型（boolean）的默认值为：false
引用数据类型的默认值全部为：null
补充：局部变量没有默认值，但是属性（成员变量和静态变量）有默认值！
2.面向对象编程的内存分析
Student stu1 = new Student();
等号右边：先创建对象，然后执行设置默认值，紧接着执行显示初始化操作！
3.成员变量和局部变量的区别
定义位置区别：
成员变量：定义在在类中，方法体外（在全局作用域），通过对象来操作成员变量（对象名.成员变量名）。
存储位置区别：
成员变量：存储在堆内存中
局部变量：存储在栈内存中
生命周期区别：
成员变量：随着对象的创建而出生，随着对象的销毁而死亡。作用范围：在当前类中（成员方法和构造代码块）都可使用！
局部变量：随着声明变量的时候出生，随着当前作用域执行结束而死亡。作用范围：在当前局部作用域中！
默认值区别：
成员变量：有默认值，不同数据类型的默认值不一样。
局部变量：没有默认值，只声明未赋值的变量不能执行取值操作！
修饰符区别：
局部变量不能被public、protected、private、static修饰，只能被final修饰。
补充：在某一个成员方法中，当局部变量和成员变量同名的时候，那么在方法体中执行的是哪一个？？？“局部变量”
原则：当 局部变量和成员变量同名时，执行的原则是：就近原则！
主方法

public class Test01 {
	public static void main(String[] args) {
		Student stu1 = new Student();
		System.out.println(stu1.name);
		stu1.name = "张三";
		stu1.age = 18;
		stu1.sex = '男';
		System.out.println("name:" + stu1.name + 
			" age:" + stu1.age + " sex:" + stu1.sex);
		stu1.eat("小龙虾");
		stu1.study();
		stu1.show("李四");
		
		Student stu2 = new Student();
		stu2.name = "张三";
		stu2.age = 18;
		stu2.sex = '男';
		System.out.println("name:" + stu2.name + 
			" age:" + stu2.age + " sex:" + stu2.sex);
		stu2.eat("小龙虾");
		stu2.study();
	}
}

学生类Student

package com.whsxt.p3.object;
/**
 * Student类中包含的属性和行为：
 * 	     成员变量(属性)：姓名、年龄、性别、体重、...
 * 	     成员方法(行为)：吃饭、睡觉、学习	
 *
 */
public class Student {
	// 成员变量，此处建议省略修饰符
	// 显示初始化操作！也就是在声明成员变量时并做了赋值操作！
	String name = "王麻子"; // 姓名
	int age; // 年龄
	char sex; // 性别
	
	// 成员方法，此处建议省略修饰符
	// 吃饭
	void eat(String food) {
		System.out.println(name + "用筷子吃" + food);
		// 调用当前中的成员方法
		study();
	}
	// 学习
	void study() {
		System.out.println(name + "说: 好好学习，天天向上！");
	}
	
	void show(String name) {
		System.out.println(name);
	}
}

3.6 匿名类

匿名对象
1.对象分类
匿名对象，就是在堆内存中创建了一个对象，但是栈内存中没有变量指向该堆内存中的对象。
例如：new Student();
非匿名对象，不但在堆内存中创建了一个对象，并且栈内存中有一个变量指向了该堆内存中的对象。
例如：Student stu = new Student();
2.匿名对象的作用
a)当对象中的成员方法只调用一次时，我们可以使用匿名对象来实现
b)当对象只作为方法的实参时，我们可以使用匿名对象来实现！
主方法

public class Test {
	public static void main(String[] args) {
		/*Student student = new Student("小花");
		method(student);*/
		
		method(new Student("小花"));
	}
	
	public static void method(Student stu) {
		System.out.println(stu);
	}

	public static void test01() {
		/*Student student = new Student("小花");
		student.show();*/
		new Student("小花").show();
	}

学生类Student

public class Student {
	String name;
	Student() {}
	Student(String name) {
		this.name = name;
	}
	void show() {
		System.out.println(name + "秀成绩！");
	}
}

4.构造方法（构造器）

1.1 构造器方法的引用

Student stu = new Student();==>Student（）
Scanner input = new Scanner(System.in); --> Scanenr(System.in)

2.1 构造方法的语法

语法：【权限修饰符】类名（形参列表）{}
注意事项：
1)构造方法没有“返回值类型”，所以无需return任何数据
2)构造方法的方法名必须和类名保持一致，也就意味着构造方法名应该遵守“大驼峰”命名规范！
3)构造方法是一个特殊方法，只能通过new关键字来调用
4)在构造方法中，我们可以直接操作当前类中的成员变量

3.1 执行new Student（） 需要的操作

a)先实例化一个对象
b)执行对象中成员变量的默认初始化工作
c)执行对象中成员变量的显示初始化工作
d)执行构造方法，也就是执行“Student()”方法

4.1 构造方法的作用

1)创建对象时，该给对象中的成员变量做指定初始化工作。
2)配合new关键字来创建数组对象！不能单独存在，只能和new关键字一起使用

5.1 无参构造方法

如果在一个类中，我们没有显示的声明构造方法，那么系统会默认给我们提供一个无参构造方法。

6.1 有参构造方法

解决了无参构造方法给成员变量赋值的局限性，我们调用有参构造方法可以指定的给成员变量做赋值操作！
注意事项：
1)当成员变量和局部变量同名时，我们可以使用this关键字来区分，this.name操作的就是成员变量
2)当给某个类显示声明了构造方法以后，那么系统就不会给我们提供默认的无参构造方法。只有当前类中没有声明任何构造方法的时候，系统才会给我们提供默认的无参构造方法
3)建议每一个类都应该有一个无参构造方法
显示声明有参构造方法之后，一定要在声明一个无参构造方法！

7.1 构造方法的重载

构造方法也支持方法重载！
重载构造方法的调用：根据实参类型来动态的选择调用合适的构造方法！

8.1 对象创建完全是由构造方法实现的吗？

new关键字负责创建对象，构造方法负责给对象中的成员变量做指定初始化工作。
创建对象必须由new和构造方法一起来完成！
Student stu1 = new Student(“张三”, 38);
1)先在栈内存中开辟一个内存空间，该存储空间名字叫做stu1。
2)通过new关键字在堆内存中开辟一块存储空间，也就是创建一个对象。
3)对象创建完毕，立刻执行对该对象中的成员变量做默认初始化工作
4)紧接着给新创建对象中的成员变量做显示初始化工作。
5)执行构造方法，给新创建的对象中的成员变量做指定初始化工作。
6)此时等号右边执行完毕，然后把等号右边执行堆中的首地址赋值给等号左边的变量保存！

9.1 构造方法和成员方法的区别

定义方式区别：
构造方法：没有返回值类型，也就是方法体中不需要返回数据。
构造方法名字必须和类名保持一致， 所以构造方法名采用“大驼峰”命名规范。
成员方法：有返回值类型，也就是方法体中可以返回数据。
方法名字自拟，方法名做到见名知意，并且采用“小驼峰”命名规范。
调用方式区别：
构造方法：必须通过new关键字来调用
成员方法：通过“对象”来调用，因为成员方法从属于“对象”。
调用时期区别：
构造方法：创建对象时调用，配合new关键字创建对象的时候调用
成员方法：对象创建完毕后调用，因为需要通过“对象”来调用
调用次数区别：
构造方法：每创建一个对象，那么就需要调用一次构造方法
成员方法：对象创建完毕后可以调用任意多次！
补充：在构造方法中可以直接调用当前类中的成员变量和成员方法。
主方法

public class Test01 {
	public static void main(String[] args) {
		/*Student stu1 = new Student();
		stu1.name = "张三";
		stu1.age = 38;*/
		Student stu1 = new Student("张三", 38);
		stu1.show();
		
		Student stu2 = new Student();
		stu2.show();
	}
}

学生类Student

public class Student {
	String name = "小花";
	int age;
	// 无参构造方法
	Student() {
		name = "小明";
		age = 18;
		System.out.println("name:" + name);
		System.out.println("Student");
	}
	
	// 有参构造方法
	Student(String name, int age) {
		// this调用的就是成员变量，this指的就是新创建出来的对象
		this.name = name;
		this.age = age;
		show();
	}
	
	/*Student(String _name, int _age) {
		name = _name;
		age = _age;
	}*/
	
	

10.1 基本数据类型和引用数据类型

10.2 基本数据类型

结果：无法实现两个变量值的变化。

10.3 引用数据类型

结果：可以实现两个变量值的交换。

10.4 数据类型传递的核心

**基本数据类型：**数据传递属于值传递，也就是传递的是数据值。
引用数据类型：数据类型属于“值传递”，也就是传递的是地址值。此处的值传递指的就是把栈内存中存放的数据直接传递。

public class Test01 {
	public static void main(String[] args) {
		int a = 10, b = 20;
		// 输出：交换之前：a:10 b: 20
		System.out.println("交换之前：a:" + a + " b: " + b);
		// 交换变量a和b的值
		swap(a, b);
		// 输出：交换之后：a:10 b:20
		System.out.println("交换之后：a:" + a + " b: " + b);
	}

	// 交换两个变量的值
	public static void swap(int num1, int num2) {
		int temp = num1;
		num1 = num2;
		num2 = temp;
	}
}

public class Test02 {
	public static void main(String[] args) {
		// 创建一个坐标对象
		Point point = new Point(10.0, 20.0);
		// 输出：交换之前：x: 10.0 y:20.0
		System.out.println("交换之前：x: " + point.x + " y:" + point.y);
		// 交换point中x和y的值
		swap(point);
		// 输出：交换之后：x: 20.0 y:10.0
		System.out.println("交换之后：x: " + point.x + " y:" + point.y);
	}
	// 交换坐标对象中x和y的值
	public static void swap(Point point) {
		double temp = point.x;
		point.x = point.y;
		point.y = temp;
	}
}

5. this 关键字

5.1 this关键字是怎么来的？？

当一个对象创建成功（执行构造方法之前，对象已经创建成功）后，虚拟机会默认生成一个引用，该应用指向的新创建的那个对象，并且这个引用的名字就叫做this。
核心：
1)对象创建完毕动态生成this的引用。
2)虚拟机
3)this指的就是新创建出来的对象

5.2 this在不同场合中指的是什么？？

在构造方法中：this指的就是新创建出来的对象
在成员方法中：谁调用该成员方法，该成员方法中的this就是指谁！

5.3 this 关键字的使用

**操作成员变量：**对象.成员变量名，如果成员变量和局部变量同名时，必须通过this.成员变量名来区分。（操作成员变量时，我们省略this，java虚拟机会为我们加上）

**操作成员方法：**通过对象.成员方法名（实参列表）
我们可以通过this关键字来调用当前类中的别的成员方法，也可以省略this关键字来调用！操作成员方法时，我们省略了this关键字，在程序执行的时候虚拟机会自动帮我们加上！

我们可以通过this（实参列表）来操作当前类中的别的构造方法，实现代码复用。
注意：
1)this（实参列表）只能存在于构造方法中，用于调用当前类中别的构造方法。
2)this（实参列表）必须放在构造方法体中有效代码的第一行。
3)在构造方法中，this（实参列表）不可递归调用，防止死循环。

public class Test01 {
	public static void main(String[] args) {
		Student stu = new Student("张三", 18);
		stu.show();
		System.out.println("stu:" + stu);
		
		System.out.println("-------------------");
		
		Student stu1 = new Student("张三", 18);
		stu1.show();
		System.out.println("stu:" + stu1);
	}
}

public class Student {
	String name;
	int age;
	public Student() {}
	public Student(String name, int age) {
		System.out.println("Student:" + this);
		this.name = name;
		this.age = age;
		// 省略写调用写法
		// study(); // 完整：this.study();
	}
	void show() {
		// 此处的this是什么呢？？谁调用该成员方法，那么this指向的就是谁!
		System.out.println("show:" + this);
		// 完整型操作成员变量
		System.out.println("name:" + this.name + " age:" + this.age);
		// 省略型操作成员变量，此处直接使用name来操作成员变量属于省略型写法，完整写法：this.name
		System.out.println("name:" + name + " age:" + age);
		// 完整调用写法
		this.study();
	}
	void study() {
		System.out.println(name + "在学习java课程！");
	}
}

public class Test02 {
	public static void main(String[] args) {
		Teacher t1 = new Teacher("王麻子", "体育老师", 18);
		System.out.println("name:" + t1.name + " title:" + t1.title + " age:" + t1.age);
		
		Teacher t2 = new Teacher("王麻子", 18);
		System.out.println("name:" + t2.name + " title:" + t2.title + " age:" + t2.age);
	}
}

public class Teacher {
	String name;
	String title;
	int age;
	Teacher() {}
	Teacher(String name, int age) {
		// this(name, "语文老师", age); 错误，进入了死循环！
		this.name = name;
		this.age = age;
	}
	
	Teacher(String name, String title, int age) {
		/*this.name = name;
		this.age = age;*/
		// new Teacher(name, age); 此处不符合题意，有新建了一个对象
		// 需求：只调用“Teacher(String name, int age)”方法，而须新创建对象
		this(name, age); // 此处就调用了当前类中的别的构造方法
		this.title = title;
	}
	
	void show() {
		// this("name", 18);
	}
	
}

6. static 关键字

6.1 静态方法的定义

语法：[修饰符]static 返回值类型 方法名（形参列表）{
// 方法体
return [数据];
}

6.2 静态方法的定义位置

位置：在类中，方法体之外(在全局作用域中)

6.3 静态方法的特点

1)静态方法优先于对象存在，当第一加载类的时候已经存在该静态方法中了！
2)调用方式：a)类名.静态方法名（实参列表）>(建议)
b)对象.静态方法名（实参列表）>(不建议)
3)main方法是一个特殊的静态方法，写法固定，能被虚拟机识别并执行。
从语法上：此处的main方法从属Test01类
从逻辑上：main方法和Test01类联系，因为main被虚拟机调用，作为程序的入口使用。

public class Test01 {
	public static void main(String[] args) {
		int[] arr = new int[]{1, 2, 3, 4};
		//String str = ArrayUtil.toString(arr); // 建议
		ArrayUtil util = new ArrayUtil();
		String str = util.toString(arr); // 不建议
		System.out.println(str);
	}
}

public class ArrayUtil {
	/**
	 * 把数组中的元素取出并且转化为字符串返回
	 * @param arr 数组
	 * @return 返回字符串！
	 */
	public static String toString(int[] arr) {
		// 1.定义一个字符串，用于保存数组中的元素
		String str = "[";
		// 2.遍历数组中的每一个元素
		for(int i = 0; i < arr.length; i++) {
			// 3.把数组中的元素拼接到字符串中
			if(i == arr.length - 1) {
				str += arr[i] + "]";
			}
			else {
				str += arr[i] + ", ";
			}
		}
		return str;
	}
}

6.4 成员方法和静态方法的区别

6.4.1 操作成员变量和静态变量的区别

成员方法：不但可以操作当前类中中的成员变量，还可以操作当前类中的静态方法!
静态方法：只能操作当前类中的静态的变量，不能操作当前类中的成员白变量。
原因：静态方法优先于对象存在，执行静态方法时，对象可能还没有创建。
思考：在构造方法中，是否能够操作当前类中的成员变量和静态变量？？？？可以

6.4.2操作成员方法和静态方法的区别

成员方法：不但可以调用当前类中的成员方法，还可以调用当前类中的静态方法！
静态方法：只能调用当前类中的静态变方法，不能调用当前类中的成员方法！
原因：静态方法优先于对象存在，执行静态方法的时候，对象都还可能为创建，所以不能调用成员方法！
思考：在构造方法中，是否能够调用当前类中的成员方法和静态方法？？？？可以

6.4.3操作this的区别

成员方法：可以操作this
静态方法：不能操作this
思考：在构造方法中，是否能够操作this关键字？？？可以

6.4.4 什么时候使用静态方法呢？？？

当方法体中无需操作当前类中的成员变量时，这时建议使用静态方法。
使用场合：工具类！
当方法体中需要操作当前类中的成员变量时，这时建议使用成员方法。

public class Test02 {
	public static void main(String[] args) {
		Student.classRoom = "教室三";
		Student.study();
		
		/*Student.classRoom = "教室三";
		Student stu = new Student("王麻子");
		stu.eat("馒头");*/
	}
}

public class Student {
	// 成员变量
	String name;
	// 静态变量
	static String classRoom;
	
	// 构造方法
	public Student() {}
	public Student(String name) {
		this.name = name;
	}
	
	// 成员方法
	void eat(String food) {
		// 操作成员变量和静态变量
		System.out.println("eat:" + name);  // this.name
		System.out.println("eat:" + classRoom); // Student.classRoom
		// 调用成员方法和静态方法
		method(); // this.method();
		staticMethod(); // Student.staticMethod();
		// this.eat(); 这样会照成死循环！
		System.out.println(this);
	}
	void method() {
		System.out.println("method");
	}
	
	// 静态方法
	static void study() {
		// 操作成员变量和静态变量
		// 在静态方法中不能操作当前类中的成员变量，因为执行静态方法是对象都可能还未创建！
		// System.out.println("study:" + name); // 
		System.out.println("study:" + classRoom);
		// 调用成员方法和静态方法
		// method(); // 等效于：this.method(); 
		staticMethod();
		// System.out.println(this);
	}
	
	static void staticMethod() {
		System.out.println("staticMethod");
	}
}

6.5 静态变量的语法

语法：[修饰符] static 数据类型 变量名;

6.5.1.声明静态变量的位置？？？

位置：在类中，方法体之外（在全局作用域中）。

6.5.2.静态变量的注意事项

1)静态变量优先于对象存在，当我们第一次加载类时，静态变量就在方法区中开辟的内存空间。
2)静态变量和成员变量一样，开辟存储空间的时候都会设置默认值！
3)操作静态变量的方式： a)类名.静态变量名 —> 建议使用该方式来操作 b)对象.静态变量名 —> 不建议使用对象来操作静态变量，会有警告！
4)一个类中的某个静态变量只有一份 ，该静态变量为类和对象所共享

6.5.3 静态变量和成员变量的区别

存储位置区别：
静态变量：存储于方法区，为类和对象的共享数据。
成员变量：存储于堆内存，为对象的特有数据。
定义语法区别：
静态变量：必须使用static来修饰
成员变量：不能使用static来修饰
调用方式区别：
静态变量：类名.静态变量名 或 对象.静态变量名
成员变量：对象.成员变量名
生命周期区别：
静态变量：当类第一次加载的时候，静态变量就被创建（出生），当程序结束时，静态变量就被销毁（死亡）。
成员变量：当对象创建的时候，成员变量就出生，当对象被销毁的时候，成员变量就死亡
创建次数区别：
静态变量：当第一次加载类的时候，就创建静态变量并且只创建一次！
成员变量：每次创建对象，那么对应的成员变量也被创建。
补充：方法区就是在堆内存中的，方法区中用于存储：类的信息、静态变量、静态方法等。

public class Test01 {
	public static void main(String[] args) {
		System.out.println(Student.classRoom);
		Student.classRoom = "教室三"; // 建议的方式
		
		Student stu1 = new Student("张三", 18);
		stu1.show(); // 不建议
		System.out.println(stu1.classRoom); // "教室三"
		
		Student stu2 = new Student("李四", 28);
		stu2.show();
		System.out.println(stu2.classRoom); // "教室三"

		Student stu3 = new Student("王麻子", 20);
		stu3.show();
		System.out.println(stu3.classRoom); // "教室三"
	}
}

public class Student {
	// 成员变量
	String name; // 姓名
	int age; // 年龄
	// 静态变量
	static String classRoom; // 班级
	
	// 构造方法
	public Student() {}
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	// 成员方法
	void eat(String food) {
		System.out.println(this.name + "在吃" + food);
	}
	void show() {
		// 完整写法：Student.classRoom
		System.out.println("教室：" + classRoom); // 省略写法，此处省略了“Student.”
		System.out.println("姓名：" + name + " 年龄：" + age);
	}
}

6.6 代码块分类

1.局部代码块

定义位置：在局部作用域中定义的代码块，我们称之为局部代码块
定义个数：任意多个
执行顺序：顺序执行

**注意：**在局部代码块中定义的变量都是局部变量。出生：声明变量的时候，死亡：代码块执行完毕就死亡

public class Test01 {
	public static void main(String[] args) {
		{
			int num = 10; // 出生
			System.out.println("block1");
			System.out.println(num);
		} // 死亡
		// System.out.println(num);
		{
			System.out.println("block2");
		}
		{
			System.out.println("block3");
		}
	}
}

2.静态代码块

3)定义位置：在类中，方法体和代码块之外（全局作用域），使用static修饰的代码块，我们称之为静态代码块。
定义个数：任意多个
执行顺序：顺序执行
注意事项：
1)静态代码块随着类的第一次加载而执行，并且永远只执行一次！
执行时间：加载类的时候执行
执行次数：永远值执行一次
2)在静态代码块中，不能直接操作当前类中的成员变量，但是可以操作当前类中的静态变量！
在静态代码块中，不能直接操作当前类中的成员方法，但是可以操作当前类中的静态方法！
为什么不能操作成员变量或成员方法？？？因为执行静态代码块的时候，对象还未创建！
3)静态变量和静态代码块在类中属于从上而下顺序执行，如果想要静态代码块中操作静态变量，那么静态变量必须声明在静态代码的前面！
4)在静态代码块中声明的变量，依旧属于局部变量，只能在当前作用域中使用！
静态代码块的使用场合（很常见）：
给静态变量赋初始值，实际开发中使用比较多，一般用于执行一些全局性的初始化操作。
例如：创建工厂、加载数据库初始信息等等

public class Test02 {
	// 成员变量
	String name = "张三";
	// 静态变量
	static String classRoom = "教室三";
	static {
		// 核心操作
		classRoom = "教室五";
		
		// 演示操作
		int num = 10; // 出生
		// System.out.println(name); // 编译错误
		System.out.println(classRoom); // 正确
		System.out.println("block1");
		// method();// 编译错误
		staticMethod();
		System.out.println(num);
	} // 死亡
	// 成员方法
	void method() {
		System.out.println("method");
	}
	// 静态方法
	static void staticMethod() {
		System.out.println("staticMethod");
	}
		
	static {
		System.out.println("block2");
	}
	public static void main(String[] args) {
		new Test02();
	}
	static {
		System.out.println("block3");
	}
}

3.构造代码块 又称之为非静态代码块

定义位置：在类中，方法体和代码块之外（全局作用域），没有使用static修饰的代码块，我们称之为构造代码块。
定义个数：任意多个
执行顺序：顺序执行
注意事项：
1)构造代码块随着对象的创建而执行，对象创建多少次那么构造代码块就执行多少次。
执行时间：创建对象的时候
执行次数：每创建一个对象，那么就执行一次构造代码块
2)在构造代码块中，可以直接操作当前类中的成员变量，但是可以直接操作当前类中的静态变量！
在构造代码块中，可以直接操作当前类中的成员方法，但是可以直接操作当前类中的静态方法！
3)构造代码块优先于构造方法执行，创建对象是先执行完毕当前类中的构造代码块，然后再执行构造方法。
4)类中的成员变量和构造方法是从上而下顺序执行的，如果想要在构造代码块中调用成员变量，那么一定把成员变量声明在构造代码块前面
5)在构造代码块中声明的变量，依旧属于局部变量，只能在当前作用域中使用！

public class Test03 {
	// 成员变量
	String name = "张三";
	// 静态变量
	static String classRoom = "教室三";
	Test03() {
		System.out.println("Test03");
	}
	
	{
		System.out.println("block1");
		System.out.println(name);
		System.out.println(classRoom);
		method();
		staticMethod();
	}
	// 成员方法
	void method() {
		System.out.println("method");
	}
	// 静态方法
	static void staticMethod() {
		System.out.println("staticMethod");
	}
	{
		System.out.println("block2");
	}
	public static void main(String[] args) {
		new Test03();	
		System.out.println("-----");
		new Test03();
	}
	{
		System.out.println("block3");
	}
}

public class Test04 {
	String name = "旺财";
	{
		System.out.println("构造代码块");
	}
	static {
		System.out.println("静态代码块");
	}
	public Test04() {}
	public Test04(String name) {
		this.name = name;
		System.out.println("构造方法");
	}
	public static void main(String[] args) {
		new Test04("小明1");
		new Test04("小明2");
	}
}

5.包（package）

5.1. package 的作用是什么？？

**核心：**用于管理类。
好处：给java中的类提供了多层命名空间。
注意：同一个包中，不能拥有相同名的类。

5. 2. 如何定义一个包？？

1)一般是公司域名反着写，再加上模块名，便于内部管理类。
2)报的命名必须是符合标识符规则，并且满足单词全部小写的规范。
3)com.whsxt.student和com.whsxt.student.demo完全没有半毛钱关系。

5.3.如何使用一个包？？

在源文件中有效代码的第一行（注释不算）来声明包。例如：package com.whsxt.p2.packagedemo;
注意：当前包中的类可以直接使用！

5.4 常见的包介绍

java.lang包含一些Java语言的核心类，如;String,Math,System.
java.awt包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
java.net 包含执行与网络相关的操作的类。
java.util 包含了一些实用工具类，如定义系统特性，使用于日期日历相关的函数。

5.5 包种类的使用

1)简化访问：访问当前包和java.lang包中的类时，我们可以省略包名，直接使用该类。
2)带包名访问：访问当前包之外的类时，我们必须带包名来操作该类。
**注意：**一个类完整的类名应该包含：“包名+类名”

6.6.通过import来导入类

如果想操作当前包和java.lang包之外的类，同时我们也不想通过带包名的方式来访问，那么我们可以通过import导入某个来来实现！
例如：使用Scanner类
第一步：import java.util.Scanner;
第二步：Scanner input = new Scanner(System.in);
注意事项：
1)我们可以使用通配符“”来导入某个包中的所有的类！例如，导入java.util包中所有的类：import java.util.;
建议：尽量少用通配符来导入某个包中的所有的类！
2)需要使用两个包中同名的类时，其中一个必须带包名访问，另外一个可以通过import导入。
例如：需要使用java.util.Date和java.sql.Date
3)JDK1.5以后，新增了静态导入，其作用是用于导入指定类的静态变量或静态方法，这样我们可以直接使用静态变量或静态方法。
例如：import static java.lang.Math.PI; --> 导入java.lang包中Math类的静态常量PI(static修饰)
ystem.out.println(PI);
例如：import static java.lang.Math.*; --> 导入java.lang包中Math类的所有静态数据和静态方法
system.out.println(E);
System.out.println(random());

public class Test01 {
	public static void main(String[] args) {
		// 需求：获取圆周率PI的值
		System.out.println(Math.PI);
		// 简化访问实现：import static java.lang.Math.PI;
		System.out.println(PI); // 要求等效于：Math.PI
		// 简化访问实现：import static java.lang.Math.E;
		System.out.println(E);
		// 简化访问实现：import static java.lang.Math.*;
		System.out.println(random());
		/*// 操作java.util.Date
		Date date1 = new Date();
		// 操作java.sql.Date
		java.sql.Date date2 = new java.sql.Date(1111111);*/
		/*Scanner input = new Scanner(System.in);	
		System.out.println(Arrays.toString(new int[]{1, 2, 3}));
		List list;
		Map map;*/
		/*new Scanner(System.in);
		new Student();
		String str;*/
	}
}