第一章、概述
1、封装的形式
1.1)类:封装的是对象的属性和行为
1.2)方法:封装的是具体的业务逻辑实现
1.3)访问控制修饰符:封装的是访问的权限
第二章、类
第一节、类的基本介绍
1、 概述
1.1组成：类定义了一种抽象数据类型，而类不但定义了抽象数据类型的组成（成员变量），同时还定义了对该类型可以实施的操作（方法）。
1.2好处
首先：定义了Emp类以后，提升了代码的模块化以及代码的重用性
其次：实现数据和方法（对该类数据的操作）的统一，也就是说，可以将打印信息的方法也放在Emp中定义，这样方法中的变量和类中的变量实现了统一，可直接对成员变量进行操作；
最后：将功能模块化，方便管理；
1.3概念理解
类是一种引用数据类型。类为对象的模板，简单的说就是分类。
2、 使用
2.1定义一个类
2.1.1定义类的成员变量
（一）作用：“成员变量”用于描述一类对象共同的数据结构
（二）语法：修饰符 数据类型 变量名 = 变量值；
注意：修饰符可以不写；
（三）调用
对象引用.变量名；
2.1.2定义类的方法
（一）作用：用于描述对象的形为，封装对象的功能；
（二）语法
- 返回值类型 方法名称(参数列表) {
- 方法体………
- }
（三）使用---调用
其他类中通过：对象引用.方法名（有参数就传参数）；
本类中：方法名（有参数就传参数）
第二节：对象
1、 对象的概述
2、 对象的使用
2.1、声明对象
类名 引用；
引用概念：为了能够对实例化的对象进行访问控制，需一个特殊的变量，即引用。
引用工作原理：引用类型变量可以存储该类对象的地址信息，通常称为“指向该类的对象”，当一个引用类型变量指向该类的对象，就可以通过这个变量对对象实施访问。
引用类型：除8种基本类型之外，用类、接口、数组等声明的变量都称为引用类型变量，简称“引用”。
2.2创建对象（此创建对象的过程也通常称为实例化）
可以使用new关键字来创建对象。new运算的语法为： new 类名（）；
定义好类之后，可以创建该类的对象；对象创建之后，其成员变量在加载类的时候就可以按照默认的方式初始化；对象成员变量的默认初始化值规则如下图 - 5所示：
2.3赋值对象
（一）new 类名();
（二）相同类型的引用类型变量之间相互赋值
注意的是：引用类型变量之间的赋值不会创建新的对象，但有可能会使两个以上的引用指向同一个对象；简单的理解就是一个人有两个名字；每个引用操作的对象数据，都是同一个数据；
- Emp e1 = new Emp();
- Emp e2 = e1; //将e1的值（对象的地址信息）赋给e2，e2和e1指向相同的对象。
（三）对其赋值为null。null的含义为“空”，表示还没有指向任何对象
注意：使用的时候必须将该引用指向一个对象，不然会报空指针异常
- Emp emp = null; //引用emp中的值为null，没有指向任何对象；
- emp = new Emp(); //引用emp指向了一个Emp对象；
1． JFrame frame = null;
2． 2.frame.setSize(200,300);
第三节、方法
一、概述
方法的种类：普通方法和构造方法；
普通方法的使用：方法的重载和重写
二、方法的重载
1、意义
（1）可以降低用户的负担，用户使用不同方式去付款时不需要去找对应的窗口，只需要到同一个收款窗口就可以了
（2）减少了用户使用时的错误
（3）代码更加优雅一些。
2．代码运行相关
（1）编译器在编译时会根据方法的签名自动绑定方法
3．代码定义注意
（1）发生在同一个类中，方法名称相同，参数列表不同
三、构造方法
1．作用
对于业务：为了在创建对象的时候，就要为对应的属性设置固定值，所以需要构造方法；
对于代码：用于实现对对象成员变量的初始化：放在创建的对象的new后面；可以理解为：“new”创建了对象，而构造方法对该对象进行了初始化
2．定义
（一）规则
- 构造方法的名称必须与类名相同。
- 构造方法没有返回值，没有返回值类型
（二）代码格式
- 【访问修饰符】类名(参数列表可以没有) {
- //构造方法体
- }
3、使用
A、创建构造方法
任何一个类都必须含有构造方法，假如源程序中没有定义，则编译器在编译时将为其添加一个无参的空构造方法（此方法称之为“默认的构造方法”）。；但是如果自定义了构造方法，则不会创建默认的构造方法；
B、用于new后面，对对象的初始化
用于实现对对象成员变量的初始化：放在创建的对象的new后面；可以理解为：“new”创建了对象，而构造方法对该对象进行了初始化
c：构造方法的调用
使用了this关键字，在构造方法中可以通过this关键字来调用另外的一个重载的构造方法。this(row,row)调用了第一段声明Cell(int row, int col)构造方法。
4、特性
A：构造方法的重载
很多时候，为了使用的方便，可以对一个类定义多个构造方法，这些构造方法都有相同的名称（类名），只是方法的参数不同，称之为构造方法的重载
B：构造方法是可以被private修饰的，作用：其他程序无法创建该类的对象。
C：父子类中：
（1）在创建子类对象时，父类的构造方法会先执行，为什么？
因为子类中所有构造方法的第一行有默认的隐式super();语句。
（2）子类中的构造方法为什么会有一句隐式的super()呢？
原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。
当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。
5、构造方法和一般方法的区别
5.1定义格式
5.2创建方式
构造方法：如果程序员没有写，系统会默认创建一个无参构造方法；如果写了，就不会默认创建；
方法：程序员自己创建
5.3作用
构造方法：创建对象的时候，为对象初始化；
方法：需要用该方法算法的时候，由对象调用
三、方法的重写
1.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
2.4重写与重载的区别:---------面试题
1)重写(Override): 1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同 1.2)遵循"运行期绑定"，看对象的类型来调用方法 2)重载(Overload): 2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同 2.2)遵循"编译期绑定"，看引用的类型来绑定方法
第四节、变量
成员变量与局部变量的差别如下：
区别一：定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二：在内存中的位置不同
成员变量存储在对内存的对象中
局部变量存储在栈内存的方法中
区别三：声明周期不同
成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
成员变量因为在堆内存中，所有默认的初始化值
局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。
第三章、类的种类
第一节、内部类
一、概述
l 什么是内部类
将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
l 什么时候使用内部类
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。
class 汽车 { //外部类
class 发动机 { //内部类
}
}
l 内部类的分类
内部类分为成员内部类与局部内部类。
我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
二、 成员内部类
成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
l 定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
l 访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
l 成员内部类代码演示
定义类
class Body {//外部类，身体
private boolean life= true; //生命状态
public class Heart { //内部类，心脏
public void jump() {
System.out.println("心脏噗通噗通的跳")
System.out.println("生命状态" + life); //访问外部类成员变量
}
}
}
访问内部类
public static void main(String[] args) {
//创建内部类对象
Body.Heart bh = new Body().new Heart();
//调用内部类中的方法
bh.jump();
}
二、 局部内部类
局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
l 定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
l 访问方式
在外部类方法中，创建内部类对象，进行访问
l 局部内部类代码演示
定义类
class Party {//外部类，聚会
public void puffBall(){// 吹气球方法
class Ball {// 内部类，气球
public void puff(){
System.out.println("气球膨胀了");
}
}
//创建内部类对象，调用puff方法
new Ball().puff();
}
}
访问内部类
public static void main(String[] args) {
//创建外部类对象
Party p = new Party();
//调用外部类中的puffBall方法
p.puffBall();
}
三、 内部类的实际使用——匿名内部类
1、匿名内部类概念
内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。
最常用到的内部类就是匿名内部类，它是局部内部类的一种。
定义的匿名内部类有两个含义：
n 临时定义某一指定类型的子类
n 定义后即刻创建刚刚定义的这个子类的对象
2、定义匿名内部类的作用与格式
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口(){
//进行方法重写
};
l 代码演示
//已经存在的父类：
public abstract class Person{
public abstract void eat();
}
//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person p = new Person(){
public void eat() {
System.out.println(“我吃了”);
}
};
//调用eat方法
p.eat();
使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：
new Person(){
public void eat() {
System.out.println(“我吃了”);
}
}.eat();
第四章、修饰符
一、应用
类:- 权限修饰符:默认的、public
- 状态修饰符:final
- 抽象修饰符:abstract
- 用的最多的就是:public
- 成员变量:
- 权限修饰符:private、默认的、protected、public
- 10. 状态修饰符:static、final
- 11.
- 12. 用的最多的就是:private
- 13.
- 14. 构造方法:
- 15. 权限修饰符:private、默认的、protected、public
- 16.
- 17. 用的最多的就是:public
- 18.
- 19. 成员方法:
- 20. 权限修饰符:private、默认的、protected、public
- 21. 状态修饰符:static、final
- 22. 抽象修饰符:abstract
- 23.
- 24. 用的最多的就是:public
除此以外的组合规则:- 成员变量:public static final
- 成员方法:public static
- public final
- public abstract
二、种类
限修饰符:private、默认的、protected、public
状态修饰符:static、final
抽象修饰符:abstract
1public:公开的，任何类
2protected:受保护的，本类、子类、同包类
3默认的:什么也不写，本类、同包类
4private:私有的，本类
5.static:静态的
（1）为什么需要静态
1)静态变量:
1.1)由static修饰
1.2)特性：属于类的，存储在方法区中，只有一份；某一个对象修改，其他对象的数据也变化；
1.3)如何用：常常通过类名点来访问；
1.4)何时用:所有对象所共享的资源(图片、音频、视频等)
2)静态方法:
2.1)由static修饰
2.2)属于类的，存储在方法区中，只有一份
2.3)常常通过类名点来访问
2.4)静态方法没有隐式this传递的，
静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)由static修饰
3.2)属于类的，在类被加载时自动执行，因为类中被加载一次，所以静态块也只执行一次
3.3)何时用:加载/初始化静态资源(图片、音频、视频等)
4）注意事项
4.1）静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区
4.2）同一个类中，静态成员只能访问静态成员（属性或者方法）
4.3）main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。
6.final:最终的、不可改变的------单独应用的机率小
1)修饰变量:只能赋值一次；
引用类型的变量：值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改；
成员类型变量：需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
7.static final:常量，应用率高
1)必须声明同时初始化
2)通过类名点来访问，不能被改变
3)建议:常量名所有字母都大写，多个单词用_分隔
4)编译器在编译时直接将常量替换为具体的值，效率高
8、参考链接
https://blog.csdn.net/l1585931143/article/details/52894234
第五章、代码块
a) 局部代码块
局部代码块是定义在方法或语句中
特点：
l 以”{}”划定的代码区域，此时只需要关注作用域的不同即可
l 方法和类都是以代码块的方式划定边界的
class Demo{
public static void main(String[] args) {
{
int x = 1;
System.out.println("普通代码块" + x);
}
int x = 99;
System.out.println("代码块之外" + x);
}
}
结果：
普通代码块1
代码块之外99
b) 构造代码块
构造代码块是定义在类中成员位置的代码块
特点：
l 优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
l 每创建一个对象均会执行一次构造代码块。
public class Person {
private String name;
private int age;
//构造代码块
{
System.out.println("构造代码块执行了");
}
Person(){
System.out.println("Person无参数的构造函数执行");
}
Person(int age){
this.age = age;
System.out.println("Person（age）参数的构造函数执行");
}
}
class PersonDemo{
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person(23);
}
}
c) 静态代码块
静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
l 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
l 该类不管创建多少对象，静态代码块只执行一次。
l 可用于给静态变量赋值，用来给类进行初始化。
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println("静态代码块执行了");
}
}