目录
一、面向对象
1、概念
（1）什么叫面向对象？
面向对象主要是把事物给对象化，这个对象含有其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程，把面向过程抽象成类，然后封装，方便使用就是面向对象。
简单举个例子：把大象装入冰箱。
这里需要三步：
第一步，打开冰箱。
第二部，把大象装入冰箱。
第三步，关上冰箱。
而面向对象是什么呢？就是我们把这三步，封装成三个方法，抽象为一个类，将其封装起来，通过这个类所映射的一个实例，也就是对象，来调用这三个方法，这就是面向对象的思想。
（2）类与对象
a、类是什么？
类是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
b、对象是什么？
对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。
它们之间简单来说就是一句话：类是对象的模板，对象是类的实例。
二、封装
1、概念
即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。”
如果上面那段化话不好理解，这里可以比喻成一句话：
我的东西你可以用，但得通过我说的方法来拿。
2、代码讲解
如果上面那段话还不好懂，下面开始看代码：
1、首先我们创建一个类，这里拿学生类进行举例。
class Student{
String name;
int age;
}注意，这里我们没有给Student类得属性加上任何限制，然后我们在测试类里面进行调用。
public class Test {
public static void main(String[] args) {
Student student = new Student();
String s = student.name;
}
}调用没有任何问题，接下来我们进行对成员属性的封装。
public class Test {
public static void main(String[] args) {
Student student = new Student();
String s = student.name; // 这里实际上是报错了，因为是私有属性，所以不可以直接访问
}
}
class Student{
private String name;
private int age;
}那么如何解决这个问题呢？很简单，就像上面的那句话，给一个对外的接口，让其能访问到这个属性
public class Test {
public static void main(String[] args) {
Student student = new Student();
String s = student.getName();
}
}
class Student{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}就这样，我们同get方法就可以访问其私有属性。
3、封装的好处
1、提高了数据的安全性
别人不能够通过 变量名.属性名 的方式来修改某个私有的成员属性。
2、操作变得更加简单
封装后，多个调用者在使用的时候，只需调用方法即可。
3、实现了隐藏
实现过程对调用者是不可见的，调用者只需调用方法即可，不知道具体实现过程
4、封装的弊端
如果没有好的注释和API，封装反有时候会取得一个适得其反的作用。所以大家当程序员一定要会好好写注释。
5、权限修饰符
三、继承
1、概念
首先，我们理解下什么是继承，就像字面意思一样，继承别人的东西，被继承的是父对象，继承的是子对象；也可以用如下的一个图进行理解：
在Java中，被继承的类我们称之为父类，也叫基类；继承的类叫子类，也称为派生类或超类；继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
在Java之中，如果要实现继承的关系，可以使用如下的语法：
class 子类 extends 父类{}2、代码讲解
a、成员变量继承
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
System.out.println(cat.age); // 结果为10
}
}
class Animal{
int age = 10;
}
class Cat extends Animal{
}b、成员方法的继承
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
cat.say(); // 运行结果：动物会叫
}
}
class Animal{
public void say(){
System.out.println("动物会叫");
}
}
class Cat extends Animal{
}这只是简单讲解了如何继承父类成员属性，实际上的继承还涉及了很多细节的地方，比如方法的重写，还有成员属性的访问提点，super关键字等；下面开始一一讲解。
3、方法的重写
什么叫做重写？重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
其他不多说，上代码！！！
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
cat.say(); // 运行结果：喵喵喵
}
}
class Animal{
public void say(){
System.out.println("动物会叫");
}
}
class Cat extends Animal{
@Override
public void say() {
System.out.println("喵喵喵");
}
}注：不是所有场景都适合重写父类方法，也不是所有父类方法都可以重写。
这里要注意几点：
A:父类中的私有方法不能被重写
B:子类重写父类方法时，访问权限不能更低
C:父类静态方法，子类也必须通过静态方法进行重写
4、成员属性访问特点
5、super关键字
super关键字的用法如下：
（1）super可以用来引用直接父类的实例变量。
（2）super可以用来调用直接父类方法。
（3）super()可以用于调用直接父类构造函数。
看不懂文字？老样子，上代码！！！
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Cat cat = new Cat();
animal.getAge(); // 打印结果为10
cat.getAge(); // 打印结果为10
cat.getAge1();
}
}
class Animal{
int age = 10;
public Animal(){}
public void getAge(){
System.out.println(age);
}
}
class Cat extends Animal{
int age = 12;
public void getAge(){
System.out.println(super.age); // 引用了父类的实例变量
}
public void getAge1(){
super.getAge(); // 调用了直接父类方法
}
public Cat() { // 调用父类构造方法
super();
}
}四、多态
1、概念
在Java中，多态性的意思是作为面向对象的程序设计语言最核心的特征，表示一个对象有着多重特征，可以在特定的情况下表现出不同的状态，从而对应着不同的属性和方法； 但体现多态的前提是，要有继承关系，有方法的重写，还有父类对象引用指向子类对象。
代码上的实现就是这样一个意思：
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
animal.say(); // 喵喵喵
}
}
class Animal{
public void say(){
System.out.println("动物会叫");
}
}
class Cat extends Animal{
@Override
public void say() {
System.out.println("喵喵喵");
}
}意思就是我们创建了一个animal对象，实际上它只知道动物会叫，当animal这个对象作为cat这种生物的时候，它的叫声就是喵喵喵，这就是多态性，它体现的是在不同情况下的状态。
2、访问特点
记住这一句话：编译看左，执行看右
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
animal.getAge(); // 运行结果：20
}
}
class Animal{
int age = 10;
public void getAge(){
System.out.println(age);
}
}
class Cat extends Animal{
int age = 20;
@Override
public void getAge() {
System.out.println(age);
}
}3、多态的利弊
好处：提高程序扩展性
坏处：不能访问子类特有的成员
4、多态的转型
文本描述起来可能不好理解，还是老样子，上代码！！！
向上转型（父类引用指向子类对象）
public class Test {
public static void main(String[] args) {
Animal animal = new Cat(); // 向上转型
}
}
class Animal{}
class Cat extends Animal{}向下转型（父类引用转为子类对象）
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
Cat cat = (Cat)animal; // 向下转型
}
}
class Animal{}
class Cat extends Animal{}