继承与多态

Math:是属于java.lang包下的，所以将来使用的时候不需要导包

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数

注意：

        Math类没有构造方法，因为它的成员变量和成员方法都是被static修饰

        可以直接通过类名.静态成员的方式进行访问

        random() 获取随机数

        返回值double值为正号，大于等于0.0，小于1.0[0.0,1.0]

代码块：

        在java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，

        可以分为局部代码块，构造代码块，静态代码块，同步代码块

局部代码块：

        在方法中出现，限定变量的生命周期，及早释放，提高内存的利用

        在同一个类中的同一个方法中，如果存在多个代码块，执行顺序是自上而下的

构造代码块：

                在类中，方法外，使用大括号括起来的代码，称之为构造代码块，当一个类中既存在构造代码块也存在构造方法，在创建对象时，会先执行构造代码块，后执行构造方法

                无论类中有多少个构造代码块，构造代码块之间会先进行自上而下的顺序执行，然后执行构造方法

静态代码块：

        在类中方法外，需要用static修饰

        静态代码块优先于其他代码块

        静态代码块---局部代码块---构造代码块---构造方法

        在加载的时候执行，并且只执行一次

继承：

        格式：class 子类 extends 父类

                要实现一个继承至少需要两个类

        如果我们需要把相同的内容放入一个独立的类中，并且让其他的类与独立的类之间有关系，我们就用继承

继承的好处：

        1、提高代码的复用性

        2、提高了代码的维护性 只需要修改父类的内容

        3、让类与类之间产生继承关系，为后面多态铺垫

继承的坏处：

        1、类的耦合性增强了(内聚)

开发的原则：

        低耦合 高内聚

        耦合：类与类之间的关系

        内聚：类自己本身可以完成的事情

java继承的特点：

        1、java中的类class只支持单个继承，不允许多个继承

        2、java中的类支持多层继承（形成了一个继承体系）

使用继承的注意事项：

        1、要想初始化子类，必须先初始化父类

        2、子类只能继承父类的非私有的成员(成员变量和成员方法)

        3、子类不能继承父类的构造方法，但可以通过super关键字访问父类的构造方法 因为要想初始化子类就要初始化父类，是通过构造方法进行初始化的

        4、不要为了部分的功能而去使用继承

什么时候用继承？

        当满足什么是什么的时候就可以用继承

继承的使用注意事项2：

        类的组成：

                成员变量

                构造方法

                成员方法

继承与成员变量之间的关系：

        1、当子类中的成员变量与父类中的成员变量名字一样时

查找：（就近原则）

        1、先在方法的局部范围内进行查找，如果找到就返回

        2、如果在方法中找不到就去本类中的成员位置上找，找到就返回

        3、如果在类中的成员位置上找不到，就到父类中的成员找

        4，找不到就报错

2、当子类中的成员名字与父类不一样，使用什么变量就找谁

        面试题：this关键字与super关键字的使用区别？

                this代表的是调用该类的当前对象

                super代表的是父类存储空间的标识（父类的引用，可以操作父类的成员）

继承与构造方法的关系：

        1、要想初始化子类，必须先初始化父类

        子类会继承父类的数据，甚至会使用父类的数据

        在子类初始化之前，一定会先完成父类的初始化

注意：

        每一个子类的构造方法的第一句话默认是super（）

        当父类中没有无参构造方法 怎么办？

        1、使用super关键字带参数的形式访问父类的带参数构造方法

        2、子类通过this关键字调用本类的其他构造方法

        注意，其他构造方法也必须访问父类拥有的构造方法

        使用this关键字间接的调用父类的构造方法

        3、super（....）或者this（）必须出现在第一条语句上

        否则就会出现父类的数据进行了多次初始化

        每个类只能初始化一次

继承与成员方法的关系：

        1、当子类的成员方法名与父类成员方法名不一样的时候，该调用谁就调用谁

        2、当子类中成员方法与父类成员方法一样时，就近原则

        1、先在本类中查找，没有就去父类找，父类没有就报错

        子类的方法名能不能和父类方法的声明一样？

        如果子类的方法声明与父类的方法声明一样，就叫重写

        重写是发生在继承的关系中,在原有的基础上加入新的东西会覆盖以前的老的东西

面试题：

重写与重载的区别：

        重写是发生在继承的关系中，重载是发生在本类中

        重载是方法名一致，参数列表不一致

        重写是方法名，参数列表，返回值都不一样，实现不一样，叫做方法的重写

        重载的英文单词：overload

        重写的英文单词：override

方法重写的注意事项：

        1、父类中私有的方法不能被重写

        2、子类重写父类的方法时候，访问权限不能更低

        要么子类重写的方法访问权限比父类的访问权限要高或者一样

        建议：以后子类重写父类的方法的访问权限要一样

        3、父类中静态的方法不能被重写，不能被override修饰，因为静态的是类本身的东西

        this关键字和super关键字分别代表什么？以及他们各自的使用场景和作用

        this:代表当前类对象的引用

        super：代表父类存储空间的标识（父类的引用，通过super关键字可以访问父类的成员）

成员变量：

        super.父类的成员变量

        this.本类的成员变量

构造方法：

        super（...）

        this（...）

成员方法：

        super.父类的成员方法

        this.本类的成员方法

                将父类中的静态成员看作一个全局共享的，被所有子类共享，改一个全改

不想让子类覆盖父类的方法，java提供了一个关键字：final

final的特点：

final：最终的，它可以修饰类，成员变量，成员方法

特点：

        1、修饰类，类不能被继承

        2、修饰成员变量，变量变常量，并且只能赋值一次，在构造方法完毕之前赋值即可

常量：

        字面值常量

        自定义常量：被final修饰的常量变成自定义常量

        3、final修饰成员方法：方法不能被重写

面试题：

        final可以修饰局部变量

                1、在方法内部。修饰基本数据类型的变量，变量值只能赋值一次，不能再发生改变

                2、final修饰引用数据类型的变量的时候，引用的地址值发生了改变，但是可以调用该类的成员变量，也可以修改成员变量的值

多态：

        1、多态的前提要有继承

        2、要有方法的重写

        其实没有重写也是可以的，但是不重写就没有意义

        3、要有父类的引用指向子类对象

        父类 f=new 子类();

多态访问成员的特点：

        1、成员变量

        编译看左，运行看左

        2、构造方法

        创建子类对象的时候先访问父类中的构造方法，父类的数据先进行初始化

        3、成员方法

        编译看左，运行看右

        因为成员方法存在重写，所以看右边

        4、静态成员变量

        编译看左，运行看左

        由于被static修饰的成员都是与类相关的，这里不是重写，所以运行的时候访问的还是左边的

多态的好处：

        1、多态可以使代码的扩展性很好（这是由继承所保证的）

        2、多态可以使代码的维护性很好（这是由多态保证的）

多态的弊端：

        多态无法访问父类中方法名一样的方法

        使用子类中的特有方法，还必须用多态

        将子类看成一个小的类型，将父类看成一个大的类型，现在想要小的类型中的方法，我们应该强制转换，称为向下转型

        将父类的引用强制转换成子类的引用

格式：子类类名 变量名=（子类类名）父类的引用

对象之间转型的问题：

        1、向上转型：

        Fu f=new Son();

        2、向下转型：

        Son s=(Son)f;

向下转型注意的一个问题：

        要求转型的类与父类引用存在继承关系，并且一开始创建多态用的该类

抽象类：

        一个不具体的功能，叫做抽象方法，一个类中有抽象方法就叫抽象类

抽象类的特点：

        1、抽象类和抽象方法都要用到一个关键字：abstract

        修饰一个类 放在class前面

        举例：abstract class Animal{}

        修饰一个方法 一般是放在修饰权限之后

        定义一个抽象的show方法,不方法体

        举例：public abstract show();

        2、有抽象方法的类一定是抽象类，抽象类不一定有抽象方法，具体的类中不能有抽象方法

        3、抽象类不能被实例化

写在抽象类中的方法怎么调用？

抽象类如何创建？

通过多态的形式使用具体的子类去实例化，然后调用方法，抽象多态

                4、如果继承抽象类的是一个具体的子类，需要重写抽象类中的所有抽象方法

                5、抽象类继承抽象类，可以不用重写父类中抽象方法，也可以选择去写，抽象类中可以存在抽象方法，也可以是方法体的方法

抽象类的成员特点：

        成员变量：

        既可以是变量也可以是常量

构造方法：

        可以存在构造方法，

成员方法：

        可以是抽象方法，但是具体的子类要重写该方法

        java中的所有的类都有一个公共的父类，叫做：Object

                abstract可以和public关键字共存

                private和abstract关键字冲突

                static和abstract关键字冲突

                final和abstract关键字冲突