一、OOA OOD OOP
和C语言的面向过程编程不同，Java是面向对象编程的语言。即在分析业务的时候，将业务中的元素用一个个对象去代替，然后再根据这些对象去设计程序，最后面向这些对象编程。
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
二、面向对象的三大特性
封装
1、封装的概念
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来对隐藏的信息进行操作和访问。
2、好处
（1）只能通过规定的方法访问数据
（2）隐藏类的实例细节，方便修改和实现。
3、封装的实现步骤
（1）修改属性的可见性设为（private）
（2）创建getter/setter方法（用于属性的读写）（通过这两种方法对数据进行获取和设定，对象通过调用这两种发方法实现对数据的读写）
（3）在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）
4、Java中的包
（1）作用：管理java文件，解决同名文件的冲突
（2）定义包：package 包名
必须放在java源程序的第一行，包名间可以使用“.”号隔开例如：com.zzr.Myclass
5、包的使用。
（1）可以通过import关键字，在某个文件中使用其他文件中的类。
import.com.zzr.music.MyClass
（2）java中，包的名字规范是全小写的字母拼写
（3）使用时，不仅可以加载某个包下的所有文件 比如：com.zzr.*
也可以加载某个具体子包下的所有文件 比如：com.zzr.music.*
6、java中的访问修饰符
private:只能在本类中使用（正因为private中的元素不能在外面直接访问，所以才利用调用getter/setter方法访问）
默认：本来和同包中使用
protected：本类，同包，子类中使用
public：本类，同包，子类，其他中都可以使用
7、java中的this关键字
this关键字代表当前对象
this.属性：操作当前对象的属性
this.方法：调用当前对象的方法
封装对象的属性的时候，经常会使用this关键字
例如：
8、内部类
（1）定义：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
（2）作用：内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据(是在内部类的方法内使用)
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
（3）分类：
成员内部类（外部类中的一个类，直接public class 定义）
静态内部类（比成员内部类多了个static，成员变量的访问以及类的实例化都有变化）
方法内部类（在外部类的方法内部的类，不能在别的方法使用）
匿名内部类
实例：
注意内部类对象的创建。
9、内部类之成员内部类
定义：定义在一个类中的类似于这个类的一个成员变量的内部类成为***成员内部类***
成员内部类的使用方法：例如：
（1） Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等
（2） Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a
（3） 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
（4） 编译上面的程序后，会发现产生了两个 .class 文件
其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class
（5）外部类是不能直接调用内部类的变量和方法的，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
（6）如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：
10、静态内部类
定义：被static修饰的内部类成为静态内部类
使用方法：
（1）静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问，静态成员还是可以继续直接访问的
（2）如果外部类的静态成员与内部类的成员名称相同，可通过***“类名.静态成员”访问外部类的静态成员***（这里和成员内部类是不同的，成员内部类是通过类名.this.变量名来调用的）；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
（3） 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
11、方法内部类：
定义：方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。例如：
注意：（1）因为是方法内部类不能被除了方法之外所使用，所以不能直接mo.print().应该是mo.show().因为这个内部类是定义在show这个方法中的。
（2）由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
12、总结
（1）只有是成员内部类创建内部类对象时候才需要通过外部类对象来创建。其他都是可以直接创建的。
（2）当外部类和内部类变量重名的话，想要调用外部变量。成员内部类需要（类名.this.变量名）。静态内部类需要是（类名.变量名）
2、继承
1、Java的继承通过extends关键字实现.
2、实现继承的类被称为子类.
3、被继承的类被称为父类.
父类和子类的关系, 是一种一般和特殊的关系.
例如水果和苹果的关系, 苹果继承了水果, 苹果是水果的子类, 水果是苹果的父类.
Java里子类继承父类的语法格式如下:
从上面的语法格式来看, 定义子类的语法非常简单, 只需要在原来的类定义上增加 extends SuperClass 即可.
即表明该类是 SuperClass 的子类.
为什么国内把 extends 翻译为 继承 而不是 扩展呢?
除了历史原因, 还有一点.子类继承了父类, 也将获得父类的全部成员变量和方法.这与我们现实中子辈从父辈那里获得一笔财富的继承关系很像.但是, Java的子类不能继承父类的构造器.
子类包含与父类同名方法的现象称为方法重写(Override). 也被称为方法覆盖.
可以说子类重写了父类的方法, 也可以说子类覆盖了父类的方法, 都行.
方法的重写要遵循两同两小一大规则.
两同: 方法名相同 / 形参列表相同
两小: 子类方法返回值类型应比父类方法返回值类型小或相等. / 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等.
一大: 子类方法的访问权限应比父类方法的访问权限大或相等.
尤其需要指出, 覆盖方法和被覆盖方法要么都是类方法, 要么都是实例方法.不能一个是类方法, 一个是实例方法,
当子类覆盖了父类方法后, 子类的对象将无法访问父类中被覆盖的方法.但可以在子类方法中调用父类中被覆盖的方法.如果需要在子类方法中调用父类中被覆盖的方法, 则可以使用super(被覆盖的是实例方法) 或者 父类类名(被覆盖的是类方法) 来作为调用者, 调用父类中被覆盖的方法.
如果父类方法具有 private 访问权限, 则该方法对其子类是隐藏的.因此子类无法访问该方法, 也就无法重写该方法.
如果子类中定义了一个与父类 private 方法具有相同的方法名 / 相同的形参列表 / 相同的返回值类型的方法,依然不是重写.这只是在子类中重新定义了一个新的方法.
涨姿势:
方法重载和方法重写在英文中分别是 overload 和 override
重载和重写 并不是同一种东西, 虽然二者都是发生在方法之间, 并要求方法名相同之外, 并没有太大相似之处.
因为重载主要发生在同一个类的多个同名方法之间.
而重写发生在子类和父类的同名方法之间.
当然, 父类方法和子类方法之间也有可能发生重载, 因为子类会获得父类方法.
如果子类定义了一个与父类方法有相同方法名, 但参数列表不同的方法, 就会形成父类方法和子类方法的重载.
super限定
如果需要在子类方法中调用父类被覆盖的实例方法. 则可以使用 super 限定来调用父类被覆盖的实例方法.
super 是 Java提供的一个关键字, super 用于限定该对象调用它从父类继承得到的实例变量或方法.
正如 this 不能出现在 static 修饰的方法中一样, super 也不能出现在 static 修饰的方法中.
static 修饰的方法是属于类的.
该方法的调用者可能是一个类, 而不是对象, 因而 super 限定也就失去了意义.
如果在构造器中使用 super
则 super 用于限定该构造器初始化的是该对象从父类继承得到的实例变量, 而不是该类自己定义的实例变量.
如果子类定义了和父类同名的实例变量.
则会发生子类实例变量隐藏父类实例变量的情形.
在正常情况下, 子类里定义的方法直接访问该实例变量默认会访问到子类中定义的实例变量.
无法访问到父类中被隐藏的实例变量.
在子类定义的实例方法中可以通过 super 来访问父类中被隐藏的实例变量.
涨姿势:
当程序创建一个子类对象时.
系统不仅会为该类中定义的实例变量分配内存.
也会为它从父类继承得到的所有实例变量分配内存.
即使子类定义了与父类中同名的实例变量.
也就是说, 当系统创建一个 java 对象时.
如果该 java 类有两个父类(一个直接父类 A / 一个间接父类 B)
假设 A 类中定义了 2 个实例变量, B 类中定义了 3 个实例变量.
当前类中定义了 2 个实例变量, 那么这个 java 对象会保存 2 + 3 + 2 个实例变量.
因为子类中定义与父类中同名的实例变量并不会完全覆盖父类中定义的实例变量, 它只是简单的隐藏了父类中实例变量, 所以会出现如下特殊情况:
调用父类构造器
子类不会获得父类的构造器.
但子类构造器里可以调用父类构造器的初始化代码.
类似于前面所介绍的一个构造器调用另一个重载的构造器.
在一个构造器中调用另一个重载的构造器使用 this 调用来完成.
在子类构造器中调用父类构造器使用 super 调用来完成.
使用 super 调用和使用 this 调用也很像.
区别在于 super 调用的是其父类的构造器, 而 this 调用的是同一个类中重载的构造器.
因此, 使用 super 调用父类构造器也必需出现在子类构造器执行体的第一行.
所以 this 调用 和 super 调用不会同时出现.
不管是否使用 super 调用来执行父类构造器的初始化代码.
子类构造器总会调用父类构造器一次.
子类构造器调用父类构造器分如下几种情况:
子类构造器执行体的第一行使用 super 显式调用父类构造器.系统将根据 super 调用里传入的实参列表调用父类对应的构造器.
子类构造器执行体的第一行代码使用 this 显式调用本类中重载的构造器,系统将根据 this 调用里传入的实参列表调用本类中的另一个构造器.执行本类中另一个构造器时即会调用父类构造器.
子类构造器执行体中既没有 super 调用, 也没有 this 调用, 系统将会在执行子类构造器之前, 隐式调用父类无参数的构造器.
3、多态
我们用一个例子进行说明。
这无非就是一个简单运行时多态问题，众所周知，Java的多态分为编译时多态和运行时多态两种。其中， 编译时多态主要指方法的重载，运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定。 运行时多态有三个条件：如List<String> list=new ArrayList<>();
1、继承
2、方法重写（覆盖）
3、向上转型
main函数中，base指向的实际上是Impl对象，因此在调用sayHi()方法时，会执行Impl对象的sayHi()方法而非Base对象的sayHi()方法，因此，输出的内容显然是Impl:Hi。
实际上是这样的吗？然而很不幸，输出的却是 Base:Hi。问题出在哪儿？难道这不满足运行时多态的条件？不应该啊，首先，Impl类继承了Base类，其次，Impl类重写了Base类的sayHi()方法，最后，调用时进行了向上转型。三个貌似条件都满足，但是等等，回忆一下方法重写的要求：
子类方法的访问权限必须大于等于父类方法；
子类方法的返回类型必须是父类方法返回类型或为父类方法返回类型的子类型。
上述问题的原因在于父类的方法是由private修饰，所以子类的方法并不是对父类的重写，而是一个全新的方法，因为父类的private方法是对子类隐藏的。所以并没有符合重写，所以也就不是多态了。
总结：要想实现多态，一定要完全符合多态的三个条件，缺一不可。
