封装 ，继承， 多态，抽象类 ，接口

封装 ，继承， 多态，抽象类 ，接口

1. 封装

个人理解： 封装类似抽取 方法，对外提供访问方式，隐藏细节，安全

定义： 是指隐藏对象的属性和实现细节，仅对外提供 公共访问方式。

1. 好处：
    将变化隔离。
    便于使用。
    提高重用性。
    提高安全性。

2. 封装原则：
    将不需要对外提供的内容都隐藏起来。
    把属性都隐藏，提供公共方法对其访问。

封装的关键字：private 

3. private 关键字：
    是一个权限修饰符。
    用于修饰成员(成员变量和成员函数)
    被私有化的成员只在本类中有效。
    将成员变量私有化，对外提供对应的set ，get 方法对其进行访问。提高对数据访问的安全性。

4. 基本数据类型对象包装类
        byte        Byte
        short       Short
        int         Integer
        long        Long
        boolean     Boolean
        float       Float
        double      Double
        char        Character

5. Java封装基本数据类型包装类常见作用：
    就是用于基本数据类型和字符串类型之间做转换。
    5.1 基本数据类型转成字符串
            基本数据类型+""
            基本数据类型.toString(基本数据类型值);
        如： Integer.toString(34);//将34整数变成"34";
    5.2 Java字符串转成基本数据类型

        int a = Integer.parseInt("123");
        double b = Double.parseDouble("12.23");
        boolean b = Boolean.parseBoolean("true");
        Integer i = new Integer("123");
        int num = i.intValue();

2. 继承

个人理解： 继承就是 对抽取的方法 放到一个类中，为了方便调用，采用 继承的方式 ，抽取的叫父类，继承的叫子类 ，关键词 extends，是多态的一种表现

定义：

多个类中存在相同属性和行为时，将这些内容抽取到 单独一个类中，那么多个类无需再定义这些属性和行 为，只要继承单独的那个类即可。

多个类可以称为子类，单独这个类称为父类或者超 类。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。
class SubDemo extends Demo{}

1. 继承作用：
    继承的出现提高了代码的复用性。
    继承的出现让类与类之间产生了关系，提供了多态的前提。

2. 继承的特点
    2.1 Java只支持单继承，不支持多继承。
    一个类只能有一个父类，不可以有多个父类。
          例：
            class SubDemo extends Demo{} //ok
            class SubDemo extends Demo1,Demo2...//error

    2.2 Java支持多层继承(继承体系)
        例：class A{}
            class B extends A{}
            class C extends B{}

   定义继承需要注意：
        不要仅为了获取其他类中某个功能而去继承
        类与 类之间要有所属( " is a " )关系，xx1是xx2的一种。


3. 函数覆盖(Override)
    3.1 定义
    子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。

    父类中的私有方法不可以被覆盖。

    在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

    3.2 重写的应用

    当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
    3.3 注意事项
     覆盖时，子类方法权限一定要大于等于父类方法权限

     静态只能覆盖静态。

    3.4 关键字 super 与 this
        super和this的用法相同
        this代表本类应用
        super代表父类引用
        当子父类出现同名成员时，可以用super进行区分
        子类要调用父类构造函数时，可以使用super语句

        如果子类中出现非私有的同名成员变量时，
        子类要访问本类中的变量，用this
        子类要访问父类中的同名变量，用super。

        super的使用和this的使用几乎一致。
        this代表的是本类对象的引用。
        super代表的是父类对象的引用。

    3.5 子类的实例化过程

        子类中所有的构造函数默认都会访问父类中空参数的 构造函数

        因为每一个构造函数的第一行都有一条默认的语句 super();

        子类会具备父类中的数据，所以要先明确父类是如何 对这些数据初始化的。

        当父类中没有空参数的构造函数时，子类的构造函数 必须通过this或者super语句指定要访问的构造函数。

    3.6 重写（override）是子类在继承父类时，重写（覆盖、覆写）了父类中的方法，重新实现和父类有所不同的功能细节。

    3.7 重写的要求和限制
    子类覆盖父类方法时要求：两同、两小、一大
    （1）方法名和参数列表必须相同：子类==父类
    （2）返回值类型和抛出异常：子类<=父类
    （3）权限修饰符：子类>=父类

    子类无法覆盖父类的
    （1）构造方法
    （2）static声明的静态方法
    （3）private声明的私有方法
    （4）final声明的最终方法

    如何确保符合覆盖的规则要求呢？
    在子类重写的方法前加@Override注解

3. 多态

定义：多态就是一个事物的多种表现形态。

==多态（Polymorphism）是同一个行为具有多个不同表现形式或形态的能力。==

多态性可以分为两类：
（1）静态的多态：方法的重载和重写          （编译期）
（2）动态的多态：对象的多态性              （执行期）
     依赖于：继承、重写、向上转型

3.1 重载

==方法的重载是指在一个类中出现多个方法名相同，但参数个数或参数类型不同的方法，这称为方法的重载。==

为什么使用重载：

使用方法重载是非常必要的，例如，在一个类中可以定义多个get Area（）方法，通过给定参数的不同，可以分别求出圆形的面积与长方形的面积，这样程序员只需要了解get Area（）方法表示的是计算图形的面积，通过给定不同的参数，就可以求出不同图形的面积。在执行具有重载关系的方法时，将根据调用参数的个数和类型来区分具体执行哪个方法。

重载的要点
（1）同一个类中
（2）方法名称相同
（3）参数列表必须不同
（4）返回值类型可以相同也可以不同

相同功能的方法统一名称，方便用户使用  

3.2 向上转型

    什么是向上转型upcasting 
    把子类对象直接赋给父类引用

    什么时候用向上转型
    为了实现多态

    向上转型后调用父类的方法
    如果子类重写过这个方法，那么执行子类重写过的代码

    子类实例 转为 父类实例 
    向上转型后，子类重写的方法会覆盖父类的原方法，调用父类的方法时，执行的是子类重写后的方法
向上转型（自动接收）

3.3 向下转型

    什么是向下转型
    什么时候必须向下转型
    instanceof关键字的使用

    父类实例  转为 子类实例
    向下转型（强制转换）
当需要调用子类的自定义方法时需要向下转型
类型必须对应

面向对象的三个基本特征：
    封装：隐藏实现细节，安全
    继承：代码重用，提供开发效率
    多态：灵活使用代码，增加功能多样性

4.final

    final可以修饰类，方法，变量。
    final修饰的类不可以被继承。
    final修饰的方法不可以被覆盖。
    final修饰的变量是一个常量。只能被赋值一次。
    内部类只能访问被final修饰的局部变量。

5.抽象类

5.1 基本概念

==抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。==

抽象的过程也是一个裁剪的过程。在抽象时，同与不同，决定于从什么角度上来抽象。抽象的角度取决于分析问题的目的。

类：众多对象提取共同的、主要的特征和行为

抽象：==abstract==

5.1.1抽象方法

抽象方法 ==仅有声明而没有方法体{ }的方法，加abstract关键字
比如：abstract String display()；==

为什么要定义抽象方法？
    1、因为这个方法体此处无法实现
    2、抽象方法相当于模板
    模板就是一个类型该包含的基本结构和内容
    模板主要起编辑引导的作用

5.1.2抽象类

     如果一个类包含抽象方法，该类必须被限定为抽象类（否则，编译器就会报错）  abstract class 修饰

    抽象类：包含抽象方法的类。    -->  模板类


    抽象类的规则

1、有抽象方法的类必须是抽象类
2、抽象类可以没有抽象方法
3、抽象类可以包含非抽象方法
4、抽象类可以有属性
5、抽象类不能被实例化
如果实例化，抽象方法无法调用
6、抽象类不能声明为final
如果声明为final，就不能被继承
7、非抽象类继承抽象类必须实现所有抽象方法

6.接口

定义 ==广义 接口是一种标准，供用户使用的统一标准==

电脑等信息机器硬件组件间的接口叫硬件接口

接口是连接口以及该连接口规定的一种标准、一组规范、一系列约定、一项协议

接口是==狭义 一个特殊的类，只提供了形式声明，而未提供任何具体实==现。

因此接口是一些方法特征的集合，是一组行为准则的集合，一组抽象方法的集合
使用interface声明
所有的方法都是抽象方法（public abstract可以省略）
特点：
    interface关键字修饰
    所有方法都是abstract抽象方法
    所有方法都是public公共的
    提示：方法前面的public abstract可以省略

为什么定义接口？
    需要约定或提供一组行为标准
    可以解决单继承限制

接口实现 ：非抽象类实现接口，必须实现所有抽象方法

7. 接口和抽象类的区别

相同点：
    不能实例化；
    包含未实现的方法声明(抽象方法)；
    非抽象派生(子)类必须实现所有的抽象方法；

不同点：
    类只能继承一个抽象类，但是可以实现多个接口。
    接口的成员变量只能是静态常量(static final )，而且必须被初始化。抽象类的成员变量多元化。
    接口内只能有抽象方法，抽象类中可以有非抽象方法。