1.面向对象和面向过程
(1) 面向过程注重结果，以线性的思维去解决问题
(2) 面向对象以线性的思维无法解决问题，强调具备了功能的对象，考虑谁来做
2. 面向对象的优点
(1) 和人的思维习惯一致
(2) 信息隐藏，提高了程序的可维护性和安全性
(3) 提高了程序的可重用性
3. 类和对象
(1) 类（class）是对象（Object，instance实例）的一个抽象（类是对象的具有方法的类型），对象是类的一个 具体，由一组属性和方法构成
(2) 类是对象的类型，对象是类的实例
(3) 面向对象中，整个程序的基本单位是类（class），方法是从属于类的
(4) 对象和类的关系是：特殊到一般，具体到抽象
(5) 类定义了对象将会拥有的特征（属性）和行为（方法）。对象是用来描述客观事物的一个实体
4.类的定义
(1) 定义类的步骤：定义类名——编写类的属性——编写类的方法
(2) 属性 fieId ：
① （成员变量）
② 定义在类中，作用范围是整个类，可以加修饰符
③ 对象具有的各种特征——每个对象的每个属性都有特定值
④ 定义格式：[修饰符] 属性类型 属性名 = [默认值];
⑤ 在定义时可以进行初始化，不进行初始化时使用Java默认的初始值
(3) 方法 method ：
① （局部变量）：
② 定义在方法中，作用范围是此方法，不能加修饰符
③ 是对象执行的操作
④ 方法定义格式：[修饰符] 返回值类型 方法名（形参列表）{//语句}
⑤ 方法五要素：修饰词，返回值，方法名，参数列表(形参)，方法体；必须要有：返回值，方法名，方法体
⑥ Java中的方法参数传递是：值传递
(4) 构造方法construtor**
(5) 其他： 代码块 静态代码块 内部类
5. 创建对象(实例)
类名 对象名 =new 类名();
6. 调用属性和方法
(1) 对象名.成员变量
(2) 对象名.成员方法
7. 构造器
(1) 如果不创建构造器 ，系统会默认为我们创建一个空参构造器
(2) 在new 对象的时候默认调用的是空参构造器
(3) 如果手动创建了一个有参构造器，那么系统就不会为我们创建无参构造器
(4) 书写格式：
修饰符 类名 (形参数){ }
(5) 作用
创建对象、初始化对象属性
(6) 有返回值 返回当前类的对象
(7) 一个类中定义的多个构造器，彼此构成重载。
8. 封装
(1) 为什么要封装？
① 程序设计追求“高内聚，低耦合”
② 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
③ 低耦合：仅对外暴露少量的方法用于使用。
(2) 封装的作用
隐藏对象内部的复杂性，只对外公开简单的接口。
(3) 封装的体现
将类的属性私有化（private），同时提供公共的（public）方法来获取（getXxx）和设置（setXxx）
9.权限修饰符
10. 匿名对象的使用
(1) 没有对象的对象 叫做匿名对象
(2) 只能够调用一次
(3) 匿名对象就是创建对象时，只通过new的动作在堆内存开辟空间，却没有把堆内存空间的地址值赋值给栈内 存的某个变量用以存储
11. this 关键字
(1) this：当前正在调用或者创建的对象
(2) this可以用来修饰：调用属性 方法 构造器
(3) 使用方法：this.属性或this.方法 调用当前对象属性和方法
(4) 通常省略。如果方法的形参和类的属性同名时必须显式使用this，表明此变量时属性不是形参
12. package关键字
(1) 用来声明类或接口所属的包，声明在源文件的首行
(2) 每“.”一次，代表一层文件目录
(3) 同一个包下，不能命名同名接口或同名类
(4) JDK中常见的包：
① Java.lang：包含Java语言的核心类，如String、MString、Math、Integer、System 和 Thread，提供常 用功能。
② Java.util：包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
③ Java.awt：包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应 用程序的图形用户界面(GUI)
④ Java.io：包含能提供多种输入/输出功能的类
13. import关键字
(1) 用来在源文件中显式的使用import结构导入指定包下的类、接口
(2) 如果导入的类、接口是Java.lang下的或是当前包下的，则可以省略此import语句
14. 继承
(1) 为什么要有继承？
① 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行 为，只要继承那个类即可。
② 格式
class A类 extends B类{}
其中A类是子类，B类是父类
(2) Java 中关于继承性的规定
① 一个类可以被多个类继承 (一个爸爸可有多个孩子)
② 单继承性：一个类只能有一个父类*（一个孩子 只能有一个亲生父亲）
③ 继承特性：
1) 子类继承父类后，子类就获取了父类中声明的属性和方法
2) 父类中声明为private的属性和方法，子类继承父类后，仍获取到了父类中私有的结构，但是由于封 装，子类不能直接调用父类的结构（可以通过get/set方法调用）
3) 子类继承父类以后，可以对父类中的方法进行覆盖操作
④ Object
1) 如果没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2) 所有java类(除java.long.Object类之外)都直接或间接地继承于java.lang.Object类
⑤ 继承的好处：
1) 减少代码的冗余，提高代码的复用性
2) 便于功能的扩展：子类继承父类后，还可以声明自己特有的属性或方法
3) 为之后多态性的使用，提供了前提
15. 方法重载和方法重写
(1) 构成方法重载的前提：
① 在同一个类当中
② 方法名必须要相同
③ 方法的参数不同：个数不同/类型不同/个数相同，类型不同/不同类型参数顺序不同
④ 和返回值、方法的修饰符没有关系
⑤ 方法重载是编译时行为
(2) 方法重写
① 重写是子类对父类中允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。
② 父类的private方法 子类不能够去重写
③ 重写方法的返回值类型不能够变 ，void不能变。基本数据类型 也不能变
④ 如果返回值类型是引用数据类型，那么子类中返回值类型必须是当前类型或者当前类型的子类
⑤ 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
⑥ 子类继承父类后，对父类中的方法进行的覆盖操作
⑦ 好处：重写的好处在于子类可以根据需要，定义特定属于自己的行为。也就是说子类能够根据需要实 现父类的方法。
(3) 异同：
① 重写和重载都是Java中多态的表现
② 重写是多个类中多态的表现（继承前提下），重载是一个类中多态的表现
(4) toString 、equals 都是Object类中的方法，所有类都可以调用和重写
16. super关键字
(1) 用于在子类对象中去访问父类的：属性、方法、构造器
(2) 使用方式：super. (属性，方法)；
(3) 可以在子类的方法或构造器中，通过"super.属性"或"super.方法"，显式的调用父类中声明的属性或方法。但 是，通常情况下，习惯省略这个"super."
(4) 特殊情况：
① 当子类和父类中定义了同名的属性时，要想在子类中调用父类中声明的属性，则必须显式的使用"super.属 性"，表明调用的是父类中声明的属性。
② 当子类重写了父类中的方法后，想在子类的方法中调用父类中被重写的方法时，必须显式的使用"super.方 法"的方式，表明调用的是父类中被重写的方法。
(5) super调用构造器
① 默认情况下调用的是父类的无参构造器，显示调用super()；
② super(形参列表)的使用，必须声明在子类构造器的首行!
③ 在构造器的首行，既没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认的调用的是父类中的空 参构造器
④ 如果父类中只提供了一个有参构造器，那么子类必须要去调用一下有参构造器。
17. 多态
(1) 是方法或对象具有多种形态，多态的前提是两个对象（类）存在继承关系，多态是建立在封装和继承基础上 的。
(2) 若编译时类型和运行时类型不一致，就出现了对象的多态性。——多态是运行时行为
(3) 对象的多态性：
① 父类的引用指向子类的对象（子类的对象赋值给父类的引用）：Person p1 = new Student();
② 只适用于方法，不适用于属性
③ 属性的调用在编译和执行时都看左边
④ 有了对象的多态性之后，内存中实际加载的是子类的属性和方法，但是由于变量声明为父类的类型，导致 编译的时候只能调用父类声明的方法和属性，子类的方法和属性则不能调用。
(4) 虚拟方法的调用
① 有了对象多态性以后，在编译期只能调用父类声明的方法
② 但在执行期实际执行的是子类重写父类的方法
③ 简称：编译时，看左边；运行时，看右边
(5) 多态情况下，“看左边”：看的是父类的引用。“看右边”：看的是子类的对象
(6) 向上转型：多态本身是子类向父类向上转换（自动转换）的过程，这个过程是默许的，当父类引用指向一个 子类对象时，就是向上转型
(7) 向下转型：
① 是父类向子类转换的过程，这个过程需要强制转换，一个可以将父类对象转换为子类对象，可以使用强制 类型转换的格式
② 向下转型容易出现ClassCastException——类型转换异常
使用 instanceof 可以判断这种异常：格式：对象名 instanceof 需要转换的类名
18.Object类
(1) Java.lang.Object类，是所有类的根父类
(2) 如果在类的声明中没有用extends指明其父类，则默认其父类是Java.lang.Object类
(3) 方法:
equals() / toString() / getClass() / hashCode() / clone() /finalize() wait() 、notify()、notifyAll()
19. ==操作符和equals()
(1) ==运算符
① 可以在基本数据类型和引用数据类型中使用
② 基本数据类型变量在比较时（类型不必须相同），是比较两个变量存储的数据是否相等
③ 引用数据类型在比较时（类型必须相同），比较的是两个对象的地址值是否相等（两个引用是否指向同一 个对象实体）
(2) equals()
① 是一个方法，只能用于引用数据类型
② Object类中定义的equals()和==的作用是相同的，都是比较地址值
③ String能进行内容比较是因为重写了equals()
20. Static
(1) 编写⼀个类时，就是在描述其对象的属性和⾏为，并没有产⽣实质上的对象，只有通过 new 关键字才会产⽣ 出对象，这时系统才会分配内存空间给对象，其⽅法才可以供外部调⽤。有时候希望⽆论是否产⽣了对象或⽆ 论产⽣了多少对象的情况下，某些特定的数据在内存空间⾥只有⼀份。
(2) 使用：用来修饰：属性、⽅法、代码块、内部类。
(3) 实例变量和静态变量
① 实例变量：⽆论创建了⼏个对象，每⼀个对象都拥有⼀套⾃⼰的实例变量，当⼀个对象进⾏修改，不会影 响其他对象的属性
② 静态变量：⽆论创建⼏个对象，多个对象共享⼀个静态变量，当进⾏修改后，所有的对象调⽤这个静态变 量都是修改之后。
(4) 修饰变量说明
① 静态变量是随着类的加载而加载，可以通过类.静态变量的方式取到
② 静态变量的加载早于对象的创建
③ 静态变量只加载一次，放在jvm方法区中的静态域中
(5) 静态修饰方法
① 随着类的加载而加载，可以通过类.静态变量的方式取到
② 在静态方法中，只能调用静态属性、静态方法。在非静态方法中可以调用静态属性、方法和非静态属性、 方法。
③ 静态方法中，不能使用this和super关键字。因为静态方法是随着类的加载而加载，而this和super关键字 是在new对象的时候调用。
21. 单例模式
(1) 就是采取一定的方法，保证在整个软件系统中，对某个类只能存在一个对象实例（只在堆内存中开辟一个类 的实例化对象空间）
(2) 分为饿汉式和懒汉式
(3) 饿汉式：
① 私有化构造函数
② 在类的内部创建对象（new），用private static 修饰
③ 对外提供公共静态的方法（通常命名为getInstance），返回当前类的对象
④ 优点：是线程安全的。缺点：对象加载时间过长
(4) 饿汉式：
① 私有化构造函数
② 在类的内部声明对象，用private static 修饰，不进行初始化（不new）
③ 对外提供公共静态的方法（通常命名为getInstance），返回当前类的对象
④ 判断当前类的对象是否为空，为空就new对象
⑤ 优点：延迟对象的创建。缺点：会线程不安全——在多线程中，会改进。
22. 代码块
(1) 又称初始化块，是类的成员之一
(2) 作用：用来初始化类、对象
(3) 一个类中可以有多个代码块
(4) 分为：静态代码块、非静态代码块
(5) 静态代码块：
① 内部可以有输出语句
② 随着类的加载而执行，而且只执行一个，用于初始化类的信息
③ 如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行
④ 静态代码块的执行优先于非静态代码块
⑤ 静态代码块内只能调用静态的属性、方法
(6) 非静态代码块：
① 内部可以有输出语句
② 随着对象的创建而执行，每创建一个对象就执行一次非静态代码块
③ 作用：可以在创建对象时，对对象的属性进行初始化
④ 如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行
⑤ 非静态代码块内能调用静态或非静态的属性、方法
23. 程序中变量赋值的顺序（从上至下，从先到后）
(1) 声明变量时的默认初始化
(2) 显示初始化，代码块，同级别从上往下依次执行
(3) 构造器对成员变量初始化
(4) 通过对象 . 属性、对象 . 方法对属性赋值
24. 子类和父类之间，代码块和构造器的调用顺序（从上到下依次）
(1) 父类的静态代码块
(2) 子类的静态代码块
(3) 父类的代码块
(4) 父类的构造器
(5) 子类的代码块
(6) 子类的构造器
25.Final——最终的
(1) 可以修饰：类、方法、变量
(2) 修饰类：被修饰的类不能被继承。
(3) 修饰方法：被修饰的方法不能被子类重写。
(4) 修饰变量：被修饰的变量变成常量，只能赋值一次，并且要求变量名全部为大写，单词之间用下划线隔开
(5) 修饰形参：被修饰的形参是一个常量。当此方法被调用，给常量形参赋一个实参，一旦赋值，就只能在方法 体中使用此形参，并且不能重新赋值。
26. 抽象类
(1) 将一个父类设计的非常抽象，没有具体的实例，这样的类叫做抽象类。
(2) 抽象类是用来被继承的
(3) 抽象类不能被实例化
(4) 抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)
(5) 在开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作
(6) 抽象类不能实例化，但可以通过多态的形式，使用父类的引用指向子类的对象创建
(7) 匿名子类创建方式
//匿名⼦类 ⽅式创建对象
Employee e1 =new Employee() {
@Override
public void work() {
System.out.println(“我在⼯作”);
}
}
格式：
抽象类 对象名 = new 抽象类（）{
重写方法
}；
27.Abstract
(1) abstract 可以用来修饰：类、方法
(2) abstract 修饰类——抽象类
(3) abstract 修饰方法——抽象方法
① 只有方法的声明，没有方法体
② 子类必须重写父类的抽象方法
③ 包含抽象方法的类一定是一个抽象类，抽象类中可以有抽象方法和普通方法
(4) abstract 注意：
① 不能修饰构造器、代码块、变量
② 不能修饰private修饰的方法
③ 不能修饰final方法、final修饰类
(5) abstract 与final冲突
28. 模板设计模式
(1) 抽象类体现的就是一种模板模式的设计，抽象类是多个子类的通用模板，子类可以在抽象类的基础上进行扩 展、改造，但子类总体上会保留抽象类的行为方式
(2) 当功能内部一部分实现是确定的，一部分实现是不确定的。可以把不确定的部分暴露出去，让子类去重写实 现。
(3) 案例：到银行取钱，固定的是来了取票和办理完评价。不固定的是具体办理什么业务
29. Interface 接口
(1) 接口是抽象方法和常量值定义的集合
(2) 特点：
① 用interface定义
② 接口中所有的成员变量都默认是public static final 修饰的
③ 接口中所有的抽象方法都默认是由public abstract修饰的
④ 接口中没有构造器
⑤ 接口采用多继承机制（多实现）
(3) 创建接口实现类对象方式：
① 创建实现类对象：
1) 接口实现类 对象名 = new 接口实现类（）；
② 创建匿名实现类对象
1) 类对象名.类方法（new 接口（）{
重写接口方法
}）；
(4) 在jdk8之前 接⼝只⽀持抽象⽅法，8.0之后 ⽀持静态⽅法（static）和默认⽅法（default），默认⽅法可以 选择不重写，那么调⽤的就是接⼝当中的⽅法
30. 内部类
(1) Java中允许将一个类A声明在另一个类B中,则类A就是内部类,类B就是外部类
(2) 内部类可以
① 调用外部类的结构
② 被static修饰
③ 被4中不同的权限修饰符修饰
④ 类中可以定义属性、方法、构造器
⑤ 被final修饰，表示此类不能被继承。不用final可以被继承
⑥ 可以被sbstract修饰
(3) 分为成员内部类和局部内部类
① 成员内部类：在类中创建类
1) 静态成员内部类对象的创建方式
外部类.内部类 对象名 = new 外部类.内部类（）；
2) 非静态成员内部类对象的创建方式
a. 外部类 对象名1 = new 外部类（）；
内部类 对象名2 = 外部类对象名.new 内部类（）；
b. 外部类 . 内部类[] 对象名 = new 外部类.内部类[长度];
对象名[索引] = new 外部类（）.new 内部类（）；
② 局部内部类：在方法、构造器、代码块中创建类
1) 局部内部类对象的创建方式
方法{
局部内部类
内部类 对象名 = new 内部类（）；
}
2) 在⽅法体内，如果对外想返回当前类的对象，可以使⽤继承的⽅式 返回值类型为⽗类的类型 （多态）
(4) 匿名内部类
① 匿名内部类中不能定义任何静态成员、方法、类
② 只能创建匿名内部类的一个实例
③ 一定在new后面，用其隐含一个接口或实现一个类
④ 格式：
new 父类构造器（实参列表）|实现接口（）{
（重写接口中的方法）
}
(5) 如果外部类和内部类中有了同名的属性、方法，在内部类中默认使用的是内部类的属性、方法。如果想要在 内部类中使用外部类的属性、方法可以通过：外部类.this.属性/方法。
4853
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
