一,类的封装
思维导图:
面向对象类封装的模块化和可维护性比面向过程作的好。而面向对象的最主要的特征可扩展性是C语言本身所不具有的。
所以在处理复杂的、用户需求多变（要求可维护、可扩展）的系统开发时，面向对象Java语言是主要的技术手段。
二,实例方法中的隐式形参this
思维导图:
三,方法可以重载
当方法名相同，而参数签名不同（参数的类型、顺序、个数）时，方法可以重载（overload）。
当类的实例字段被直接访问，就说该类的封装性遭到了破坏。
每一个封装类可以看作是一种扩展数据类型。
四,类封装代码
程序1:
//类对数据结构和对数据结构操作的方法进行了封装，是面向对象中最小的模块。
//模块化是解决"复杂系统"的技术手段。
//面向对象的封装类具有"可维护性"
//面向对象思想的核心是“可扩展性”
//用户需求的多变性要求软件系统具有"可维护性"和“可扩展性”
//面向对象思想的"可维护性"和“可扩展性”是解决用户需求的多变性的技术手段
//所以纯面向对象Java语言具有"模块化"、"可维护性"和“可扩展性”特征，是解决复杂的、用户需求多变性的系统的技术手段
//类定义,Student类名是类的数据结构的入口地址
class Student {
//类成员定义
//1、类的静态成员，类中声明使用static修饰符的成员。
//就是说这个成员的拥有者不是对象而是类
//1-1、Student类的静态代码块(静态构造方法)
//定义：这个方法没有方法名，没有形参，没有返回值，不能进行方法调用。
//调用：静态代码块在类初次被加载到JVM中时，会按照static块的顺序来执行每个static块，
// 并且每个static块只会执行一次。
//作用：静态代码块通常用于初始化静态变量，也可以进行其它初始化操作。
static{
System.out.println("静态字段默认初始化 className = " + Student.className);
System.out.println("静态字段默认初始化 classID = " + Student.classID);
//静态代码块初始化
classID = 1;
System.out.println("静态代码块1 classID = " + Student.classID);
}
static{
classID = 2;
System.out.println("静态代码块2 classID = " + Student.classID);
}
//1-2、静态字段（相当于C语言的全局变量），默认初始化、静态块初始化、声明初始化
//初始化过程：默认初始化 ---〉 静态块初始化 ---〉 声明初始化
//默认初始化
public static int classID = 1;
//声明初始化
public static String className = "班级";
//1-3、静态方法（相当于C语言的全局函数）
public static void showClassID(){
System.out.println("调用Student.showClassID()，班级ID号是：" + classID);
}
//2、类的实例成员，类中声明不使用static修饰符的成员。
////就是说这个成员的拥有者不是类而是对象
// 2-1、实例构造方法（方法名与类名相同），只能由new调用,this引用刚创建的实例对象，不能进行方法调用。
//如果访问一个变量只有一个名称，编译器首先假定它是局部变量/形参变量，
//其次假定它是实例变量this.变量，最后假定它是全局变量类名.变量
public Student(int studentID,int age,String name) {
System.out.println("实例字段默认初始化 studentID = " + this.studentID);
System.out.println("实例字段声明初始化 age = " + this.age);
System.out.println("实例字段默认初始化 name = " + this.name);
this.studentID = studentID;
this.age = age;
this.name = name;
System.out.println("实例字段实例构造方法初始化");
}
//2-2、实例字段集合定义了一个新的实例数据结构
//实例字段
//初始化过程：默认初始化 ---〉 声明初始化 ---〉 实例构造方法初始化
//默认初始化
int studentID;
//声明初始化
int age = 18;
String name;
// 2-3、实例方法，对于该类创建的实例对象和该类派生类创建的实例对象的数据结构中的数据进行操作。
//this引用实例对象
public void study(){
System.out.println(this.name + "正在学习");
}
// 2-3、重载实例方法
//方法名相同，形参的类型、数量、顺序不同
public void study(String partner){
System.out.println(this.name + "正在与" + partner + "一起学习");
}
}
//
public class Application {
public static void main(String[] args) {
System.out.println("----------------------------------------------类的静态成员");
//1、类的静态成员
//1-1、Student类的静态代码块在JVM类加载器加载Student类时被自动调用
//1-2、操作Student类（静态数据结构）中的静态字段
//声明初始化
System.out.println("main代码块 classID = " + Student.classID);
System.out.println("main代码块 className = " + Student.className);
// 1-3、调用Student类的静态方法
Student.showClassID();
System.out.println("----------------------------------------------类的实例成员");
//2、类的实例成员
System.out.println("-----------------------张珊实例成员");
// 2-1、实例化一个类对象，调用实例的构造方法
Student p = new Student(1,21,"张珊");
//2-2、操作实例对象（实例数据结构）中的实例字段
System.out.println("studentID = " + p.studentID + ",age = " + p.age + ",name = " + p.name);
// 2-3、调用Student类的实例方法
p.study();
p.study("比尔盖茨");
System.out.println("-----------------------李斯实例成员");
// 3-1、实例化一个类对象，调用实例的构造方法
Student p1 = new Student(2,22,"李斯");
//3-2、操作实例对象（实例数据结构）中的实例字段
System.out.println("studentID = " + p1.studentID + ",age = " + p1.age + ",name = " + p1.name);
//3-3、调用Student类的实例方法
p1.study();
p1.study("马云");
}
}
//1、Java源程序---〉编译器编译---〉class字节码文件
//2、字节码文件---〉JVM扫描---〉生成方法区的类对象
//3、方法实现代码---〉解释器解释执行/编译器编译执行---〉栈区的局部变量和形参、堆区的实例对象
JVM方法调用：
1）创建方法的执行环境
2）扫描方法代码，加载新类
3）取指令
4）执行
5）退出方法的执行环境，垃圾回收
执行:
- 加载类Application
- 为执行main方法建立栈帧
- 扫描main方法，加载新Student类
- 执行main方法
- 退出main方法的执行环境，垃圾回收
- Java中static静态变量的初始化
程序2:
//初始化过程：
//1）默认初始化：静态变量会按照声明的顺序先依次设置为该类型的默认值
//2）静态块初始化：按静态块的顺序依次设置静态字段的值
//3）声明初始化：按声明的顺序依次设置为初始化的值，如果没有初始化的值就跳过。
public class Test
{
public static Test1 t = new Test1();
public static int a = 0;
public static int b;
public static void main(String[] arg)
{
System.out.println(Test.a);
System.out.println(Test.b);
}
}
class Test1
{
public Test1()
{
Test.a++;
Test.b++;
}
}
//输出：0 1