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;*/
}
}