前言
资料来源：
- 开课吧视频学习
- 部分百度资料
- 个人学习笔记
一 面向对象思想
1.1 面向对象概念
面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现
实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向对象是相对于面向过程来讲的，指的是把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系
统建模，更贴近事物的自然运行模式。（个人理解面向对象是把碎片化的行为，认知等可拆分的常理形态组装成一个整体，从而更容易进行顺应法则的运用）
面向过程到面向对象思想层面的转变：
面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。
面向过程到面向对象，是程序员思想上从执行者到指挥者的转变。
举个栗子：
问：
把大象装进冰箱 ， 需要分几步？
回答：
面向过程回答：
3步：1把冰箱门打开， 2把大象装进去 ， 3把冰箱门关闭
面向对象回答：
2步：1招一个能操作冰箱的工人（对象），2指挥工人装大象
思考：
如果问题改成： 把100只大象依次关进冰箱，共分为几步？
面向过程的回答： 此处需要省略N字。。。
面向对象的回答还是2步：
1招一个能操作冰箱的工人（对象） ， 2指挥工人把大象依次装进去。
结论：
从上述的栗子中， 我们发现面向过程很死板 ，是很难适应变化的，面对一些复杂的逻辑处理极为繁琐。 而面向对象更灵活，可复用性更高。
1.2 三大思想（暂时做个标记，日后机会研究）
面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP
OOA：面向对象分析（Object Oriented Analysis）
OOD：面向对象设计（Object Oriented Design）
OOP：面向对象程序（Object Oriented Programming）
1.3 三大特征
封装性：所有的内容对外部不可见
继承性：将其他的功能继承下来继续发展
多态性：方法的重载本身就是一个多态性的体现（灵活）
二、类、对象、方法
2.１类、对象、方法基本定义
类必须通过对象才可以使用，对象的所有操作都在类中定义。
类由属性和方法组成：
- 属性：就相当于人的一个个的特征
- 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉
// 类的定义格式
class 类名称 {
成员属性
成员方法
}
// 属性与方法
属性定义格式：
数据类型 属性名;
属性定义并赋值的格式：
数据类型 属性名 = 初始化值;
方法定义格式：
权限修饰符 返回值类型 方法名(形式参数列表){
//方法体
return 返回值；
}
// 对象的创建与使用
一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:
类名称 对象名称 = new 类名称() ;
如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：
访问类中的属性： 对象.属性 ;
调用类中的方法： 对象.方法(实际参数列表) ;
2.2 构造方法
作用：
用于对象初始化。
执行时机：
在创建对象时,自动调用
特点：
所有的Java类中都会至少存在一个构造方法
如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代
码！
如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。
定义的格式:
与普通方法基本相同, 区别在于: 方法名称必须与类名相同, 没有返回值类型的声明。
2.3 重载
2.3.1 方法的重载
/**
* 一个类中定义的方法， 是允许重载 （相同的方法名称）
*
* 1、方法名称相同
* 2、参数列表长度 或 参数列表类型 或 （参数类型顺序不同）
*
* 注意： 与返回值类型无关
*
*/
int sum(int x, int y) {
int z = x + y;
return z;
}
double sum(double x, double y) {
double z = x+y;
return z;
}
double sum(int x,double y) {
double z = x+y;
return z;
}
double sum(double y,int x) {
double z = x+y;
return z;
}
2.3.2 构造的重载
class Person {
String name;
int age;
Person(String name2){
name = name2;
}
Person(String name2, int age2) {
name = name2;
age = age2;
}
}
2.4 匿名对象
没有对象名称的对象 就是匿名对象。
匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被G·C回收。
只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。
public class Test {
/**
* 匿名 : 没有名字
*/
public static void main(String[] args) {
int num = new Math().sum(100, 200);
}
}
class Math{
int sum(int x,int y) {
return x+y;
}
}
三、面向对象进阶
3.1 封装
概述：
封装的意义在于保护或者防止代码（数据）被我们无意中破坏；
保护成员属性，不让类以外的程序直接访问和修改。
封装的原则
隐藏对象的属性和实现细节，仅对外公开访问方法，并且控制访问级别。
在代码开发中，建议对所有属性进行封装，提供get和set方法。
3.2 this
在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：
· 调用类中的属性
· 调用类中的方法或构造方法
· 表示当前对象
3.3 static
static表示“静态”的意思，可以用来修饰成员变量和成员方法。
static的主要作用在于创建独立于具体对象的域变量或者方法。
简单理解：
被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问，并且不会因为对象的多次创建而在内存中建立多份数据。
静态成员 在类加载时加载并初始化。
无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
在访问时： 静态不能访问非静态 , 非静态可以访问静态
3.4 代码块
普通代码块
在执行的流程中出现的代码块，我们称其为普通代码块。
// 编写在顺序执行的代码流程中的代码块
public static void main(String[] args) {
{
System.out.println("编写在顺序执行的代码流程中的代码块");
}
}
构造代码块
在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。
class Robot {
{
System.out.println("构造代码块");
}
}
静态代码块
在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会执行一次的代码块。
class Robot {
static {
System.out.println("静态代码块");
}
}
同步代码块(后续补充)
在后续多线程技术中学习。
面试题：
构造方法 与 构造代码块 以及 静态代码块的执行顺序：
静态代码块 -> 构造代码块 -> 构造方法
3.5 权限修饰符
| 修饰符 | 类 | 包 | 子类 | 其他包 |
|---|---|---|---|---|
| public | ∨ | ∨ | ∨ | ∨ |
| protected | ∨ | ∨ | ∨ | × |
| default | ∨ | ∨ | × | × |
| private | ∨ | × | × | × |
开发常用的是private和public修饰符。
3.6 main方法解释
public static void main(String args[])
以上的各个参数的含义如下：
· public：表示公共的内容，可以被所有操作所调用
· static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09
· void：表示没有任何的返回值操作
· main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main
· String[] args：字符串数组，接收参数的
3.7 单例设计模式整理
单例设计模式是我们学习的第一个设计模式，也是比较重要的一个设计模式，单例设计模式会伴随这你的开发生涯，不管你是初级程序员，还是以后晋级到高级程序员，你都会接触到单例设计模式，今天我们就学习单例设计模式的两种实现方式。
单例设计模式：保证程序在内存中只有一个对象存在（被程序所共享)
单例设计模式的两种实现方式：
一、懒汉式：随着类的加载在内存中对象为null，当调用 getInstance 方法时才创建对象（延迟加载）
二、饿汉式：随着类的加载直接创建对象（推荐开发中使用）
单例设计模式的实现步骤：
1．保证一个类只有一个实例，实现方式：构造方法私有化
2．必须要自己创建这个实例，实现方式：在本类中维护一个本类对象（私有，静态）
3．必须向整个程序提供这个实例，实现方式：对外提供公共的访问方式（getInstance方法，静态）
懒汉式实现如下：
class Single{
private Single(){}
private static Single s1 = null;
public static Single getInstance(){
if(s1 == null){
s1 = new Single();
}
return s1;
}
}
饿汉式实现如下：
class Single2{
private Single2(){}
private static Single2 s = new Single2();
public static Single getInstance(){
return s;
}
}
四、面向对象高级
4.1 抽象类
抽象类使用abstract class声明。
一个抽象类中可以没有抽象方法。
抽象方法必须写在抽象类或者接口中
// 抽象类
abstract class 类名{
}
只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。
abstract class 类名{
// 抽象方法，只声明而未实现
public abstract void 方法名() ;
}
在抽象类的使用中有几个原则：
- 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
- 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法。
抽象类常见问题
1、 抽象类能否使用final声明？
不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。
2、 抽象类能否有构造方法？
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。
抽象类和普通类的区别
1、抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。
默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类
4.2 接口（开发常用）
如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
interface 接口名称 {
全局常量 ;
抽象方法 ;
}
面向接口编程思想：这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。
优点：
- 降低程序的耦合性
- 易于程序的扩展
- 有利于程序的维护
接口本身都是由全局常量和抽象方法组成 ， 所以接口中的成员定义可以简写：（个人不建议简写，但是需要了解）
1、全局常量编写时， 可以省略public static final 关键字，例如：
public static final String INFO = “内容” ;
简写后：
String INFO = “内容” ;
2、抽象方法编写时， 可以省略 public abstract 关键字， 例如：
public abstract void print() ;
简写后：
void print() ;
接口可以多实现和多继承接口：
class 子类 implements 父接口1,父接口2...{
}
interface C extends A,B{
}
注意：一个接口要想使用，必须依靠子类。 子类（如果不是抽象类的话）要实现接口中的所有抽象方法。
接口和抽象类的区别：
1、抽象类通过子类继承来使用，但是无法多继承。 接口通过类可以多实现来使用。
2、抽象类可以有构造方法，接口不能有。
3、抽象类中既可以用抽象方法，也可以使用非抽象方法，接口只能用抽象方法。
4、抽象类中的变量可以是普通变量，接口里定义的变量只能是公共的静态的常量。
5、抽象类中可以包含静态static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）。
4.3 多态
多态：顾名思义就是对象的多种表现形式（多种体现形态）。
对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。
ps: 方法的重载和重写也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现
重写： 子父类中方法的多态性体现。
对象的类型转换也是一种多态。
向上转型：将子类实例变为父类实例;
格式：父类 父类对象 = 子类实例 ;
向下转型：将父类实例变为子类实例;
格式：子类 子类对象 = （子类）父类实例;
4.4 instanceof
作用：
判断某个对象是否是指定类的实例，则可以使用instanceof关键字。
格式：
实例化对象 instanceof 类 。//此操作返回boolean类型的数据。
类似：
类1.getClass = 类2.getClass
4.5 Object类
4.5.1 Object类概念
Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object
类并且使用Object可以接收任意的引用数据类型。
我们定义一个类：
public class User{
}
其实它被使用时 是这样的：
public class User extends Object{
}
4.5.2 toString
如果是没有重写toString方法的类默认调用Obect的toString方法，返回的是对象的内存地址。
建议重写Object中的toString方法。 此方法的作用：返回对象的字符串表示形式。
4.5.3 equals
建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否等于此对象。
Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。
equals方法重写时的五个特性：
自反性 ：对于任何非空的参考值x， x.equals(x)应该返回true 。
对称性 ：对于任何非空引用值x和y， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
传递性 ：对于任何非空引用值x， y和z ，如果x.equals(y)回报true个y.equals(z)回报true，然后x.equals(z)应该返回true 。
一致性 ：对于任何非空引用值x和y，多次调用x.equals(y)始终返回true或始终返回false，前提是未修改对象上的equals比较中使用的信息。
非空性 ：对于任何非空的参考值x， x.equals(null)应该返回false 。
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
类名 c = (类名) o;
return Objects.equals(属性, c.属性);
}
4.6 内部类
在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
广泛意义上的内部类一般来说包括这四种：
1、成员内部类
2、局部内部类
3、匿名内部类
4、静态内部类
4.6.1 成员内部类
成员内部类是最普通的内部类，位于另一个类的内部。
class Outer {
private double x = 0;
public Outer(double x) {
this.x = x;
}
class Inner { //内部类
public void say() {
System.out.println("x=" + x);
}
}
}
特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问。
的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
// 外部使用成员内部类
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();
4.6.2 局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
class Person{
public Person() {
}
}
class Man{
public Man(){
}
public People getPerson(){
//局部内部类
class Student extends People{
int age =0;
}
return new Student();
}
}
4.6.3 匿名内部类
匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：
new 实现接口（）{
// 匿名内部类的类体部分
}
new 父类构造器（参数列表）
{
//匿名内部类类体部分
}
在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。
在使用匿名内部类的过程中，我们需要注意如下几点：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
6、只能访问final型的局部变量。
4.6.4 静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。
public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
4.7 包装类（基础回忆）
在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。
| 序号 | 基本数据类型 | 包装类 |
|---|---|---|
| 1 | int | Integer |
| 2 | char | Character |
| 3 | float | Float |
| 4 | double | Double |
| 5 | boolean | Boolean |
| 6 | byte | Byte |
| 7 | short | Short |
| 8 | long | Long |
以上的八种包装类，可以将基本数据类型按照类的形式进行操作。
但是，以上的八种包装类也是分为两种大的类型的：
- Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。
- Object：Character、Boolean都是Object的直接子类。
装箱和拆箱操作
将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。
将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作。
因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作。
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | public byte byteValue() | 用于Byte->byte |
| 2 | public abstract double doubleValue() | 用于Double->double |
| 3 | public abstract float floatValue() | 用于Float->float |
| 4 | public abstract int intValue() | 用于Integer->int |
| 5 | public abstract long longValue() | 用于Long->long |
| 6 | public short shortValue() | 用于Short->short |
装箱操作：
在JDK1.4之前 ，如果要想装箱，直接使用各个包装类的构造方法即可，例如：
int temp = 10 ; // 基本数据类型
Integer x = new Integer(temp) ; // 将基本数据类型变为包装类
在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。例如：
Float f = 10.3f ; // 自动装箱
float x = f ; // 自动拆箱
System.out.println(f * f) ; // 直接利用包装类完成
System.out.println(x * x) ; // 直接利用包装类完成
4.8 可变参数
一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。
返回值类型 方法名称(数据类型… 参数名称){
// 参数在方法内部 , 以数组的形式来接收
}
// 例如
String test(String... args) {
}
注意：可变参数只能出现在参数列表的最后。
4.9 递归（简单理解）
递归还是比较重要的，很多算法的基础，从归并到分治，到DFS，以及深搜 + 缓存解决动态规划问题。还有尾递归优化，能减少 弹栈 压栈 的消耗。开发不常用，算法面试运用多。
个人理解递归方法里面调方法。==
4.10 final 关键字
final关键字用于修饰属性、变量。
变量成为了常量，无法再次进行赋值。
final修饰的局部变量，只能赋值一次（可以先声明，后赋值）。
final修饰的是成员属性，必须在声明时赋值。
全局常量（public static final）。
final修饰的类不可以被继承，final修饰的常量，不能被子类重写。
4.11 super 关键字
通过super，可以访问父类构造方法，属性，普通方法。
调用super的构造方法的代码，必须放在子类构造方法的第一行。
五、面向对象的内存基本分析
5.1 栈
Java栈的区域很小 , 大概2m左右 , 特点是存取的速度特别快。
栈存储的特点是, 先进后出。
存储速度快的原因:
栈内存, 通过 ‘栈指针’ 来创建空间与释放空间。
指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存。
这种方式速度特别快 , 仅次于PC寄存器。
但是这种移动的方式, 必须要明确移动的大小与范围 ,明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序的灵活性 ~所以我们把更大部分的数据 存储到了堆内存中
存储的是:
基本数据类型的数据 以及 引用数据类型的引用!
// 10 存储在栈内存中 , 第二句代码创建的对象的引用p 存在栈内存中.
int a =10;
Person p = new Person();
5.2 堆
堆存放的是类的对象，所有类的对象都是通过new关键字创建。
Java是一个纯面向对象语言, 限制了对象的创建方式。
new关键字, 是指告诉JVM , 需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间。
堆内存与栈内存不同, 优点在于我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长 。
堆内存中内存的释放是由GC(垃圾回收器)完成的。
垃圾回收器 回收堆内存的规则:
当栈内存中不存在此对象的引用时,则视其为垃圾 , 等待垃圾回收器回收。
// 无引用，视为垃圾，等待回收
Person p0 = new Person();
Person p1 = p0;
Person p2 = new Person();
5.3 方法区
方法区存放的是
- 类信息
- 静态的变量
- 常量
- 成员方法
方法区中包含了一个特殊的区域 ( 常量池 )(存储的是使用static修饰的成员)。
5.4 PC寄存器
PC寄存器保存的是 当前正在执行的 JVM指令的 地址。
在Java程序中, 每个线程启动时, 都会创建一个PC寄存器。
5.5 本地方法栈
保存本地(native)方法的地址 。
总结
人生无限，缓缓起航，修正改错，在满足完成任务的条件下，追求完善，全身而退。
185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
