面向对象三大特征（封装、继承、多态）

1.面向对象特征之封装

一、访问修饰符

访问修饰符:public、protected、default、private

访问范围（public > protected > default > private）

1.public:项目中任何位置都可以访问。
2.protected:同包中当前类、其他类都能访问。不同包类，子类继承了父类的当前类中，可以访问父类的protected变量。
3.default:在同一个包下可以访问。
4.private:只有在本类中可以访问。

二、封装

1.封装的概念

封装是指将类中的成员变量私有化，防止该类的代码和数据被外部类定义的代码随机访问

2.封装的优点

1.保证了类内部的完整性，无法轻易直接操作类的内部数据，提高代码安全性
2.良好的封装可以降级代码的耦合，提高代码的可维护性

三、this关键字

this在类中使用，表示当前对象.可用于在类中调用成员变量、构造方法（调用构造方法需要放在首行）、成员方法。
例：

public class Fox {
   private int age;
   private String color;
   public Fox() {
       this(10,"red");  //this调用类中其他构造方法
   }
   public Fox(int age, String color) {
       //this 调用成员变量复制
       this.age = age;      //这一对象 age = 传入参数 age
       this.color = color; //这一对象 color = 传入参数 color
   }
   public void exercise(){
       this.run(); //this调用类中其他方法
       System.out.println("捕食");
   }
   public void run(){
       System.out.println("跑");
   }
}

2.面向对象特征之继承

1.继承

1.继承的概念

继承就是子类继承父类的特征和行为（子类 extends 父类），使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

2.继承的语法（extends）

访问修饰符+class+子类类名+extends+父类类名
例：

public class Animal {
   private int age;
   private String  color;
   public void eat(){

   }
}
class Cat extends Animal{
   public void sleep(){
   }
}

3.继承的特点

1.一个类可以有多个子类
2.一个类只有一个父类
3.JAVA只允许单继承，不允许多继承，但是可以多层继承

4.子类继承父类的内容

1.子类继承父类,就会继承父类中的所有成员变量和成员方法。子类可以直接访问父类中 非私有的成员变量和方法
2.子类不能继承父类的构造方法和私有方法，因为子类有自己的构造方法。
（Java官方文档的解释：子类不能继承父类的私有属性，但是如果子类中公有的方法影响到了父类私有属性，那么私有属性是能够被子类使用的。）

2.继承的优缺点

优点：
（1）代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；
（2）提高代码的复用性；
（3）提高代码的可扩展性。
缺点:
（1）只要继承，就必须拥有父类的所有属性和方法 ；
（2）降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束；
（3）增强了耦合性。

2.super关键字

1.super关键字只存在父子类继承关系的子类中
2.子类构造方法中使用调用父类的构造方法必须在第一行使用
3.super可以调用父类的非私有成员变量、实例方法和构造方法。（不能调用私有的成员）

3.继承中成员访问的特点

当调用成员变量，成员方法时，子类中有则使用子类中的成员，若子类中没有则调用父类中的成员。子类的构造方法中第一行默认存在父类中的无参构造方法 （super（））。

4.继承关系中各成员加载顺序

父子类关系的执行排列:
父类静态代码块 -> 子类静态代码块 -> 父类代码块 -> 父类构造 -> 子类代码块 -> 子类构造
代码实现：

public class Demo1 {
    public static void main(String[] args) {
        Baby s = new Baby();
    }
}

class Student{
    {
        System.out.println("父类代码块");
    }
    static {
        System.out.println("父类静态代码块");
    }
    public Student(){
        System.out.println("父类构造器");
    }
}
class Baby extends Student{

    {
        System.out.println("子类代码块");
    }
    static {
        System.out.println("子类静态代码块");
    }
    public Baby(){
        System.out.println("子类构造器");
    }
}

实现结果：
父类静态代码块
子类静态代码块
父类代码块
父类构造器
子类代码块
子类构造器

5.方法的重写

存在条件：子类中存在有和父类中相同方法名，返回值类型，参数称之为方法的重写
注意事项:
a.子类访问修饰符必须大于等于父类访问修饰符
b.静态方法不能被重写,如果子类也有相同的方法名,并不是重写父类中的方法
c.私有方法不能被重写(父类私有成员只能被继承不能被使用)

3.面向对象特征之多态

1.多态的概念

指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
比如：一个人在学校学习是以学生的身份，在家里则是儿子或女儿，上班的时候则是员工，这样在不同的场景下有不同的状态就是多态。

2. 多态的特点:

1.类与类之间必须有继承关系
2.子类必须重写父类中的成员方法
3.父类引用指向子类对象,如：Animal a = new Cat();
4.编译看左边，运行看右边

3. 向上转型和向下转型

1.向上转型（自动类型转换）：

语法格式：
父类类型 对象名 = new 子类构造方法（）。
Animal a = new Cat();
优缺点：
优点：可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
缺点：把子类对象当成父类对象，只能调用父类的功能，不能调用子类自己的功能，如果子类重写了父类中声明过的方法，使用的是重写的方法。但是此时对象是把自己看做是父类类型的，所以其他资源使用的还是父类型的。（编译看左边，运行看右边）

2.向下转型（强制类型转换）：

语法格式：
子类类型 对象名 = （子类类型）对象名
Animal a = new Cat();(向上转型)
Cat c = （Cat）a;（向下转型）
注意事项：
向下转型过程中，出现两种类型没有父子类关系（和多层父子关系），则会出现类型转换异常，则在向下类型转换之前，需要使用 instanceof 关键字进行判断

3.instanceof：

语法：
obj instanceof Class
注意点
1.instanceof关键词不能比较基本数据类型的数据。obj必须为引用类型，不能是基本数据类型。
2.instanceof关键字的比较是基于多态的
3.instanceof关键字右边比较的类型只能为类和接口

4. 多态的好处

1.多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
2.提高了程序的可扩展性和可维护性