问题： 什么是面向过程，什么是面向对象，面向对象的好处是什么？

面向过程：面向过程强调的是过程，通过第一步，第二步，一步步的自己实现功能 面向对象：强调的是对象，指挥对象中的方法，来帮我们完成具体的功能

A: 面向对象是一种更符合我们思考问题习惯的一种思想。
B: 将我们从执行者的位置变成了指挥者
C: 将复杂的问题简单化

问题：什么是类，什么是对象，类和对象的关系是什么？

类：类是一组相关属性和行为的集合，可以将类看作为一个模子，或者说是一张图纸，可以根据图纸创建出具体存在的事物。 对象：指的就是具体存在的事物。

问题：类是由什么组成的？

        属性：事物的特征，使用成员变量表示

                跟之前定义的变量写法一样，只不过位置发生了改变，类中方法外

        行为：事物可以实现的功能，成员方法表示

                跟之前定义的方法格式相同，只不过去掉了static关键字

                        问题: static加上行不行?        -> 可以,但是要考虑静态的环境问题.

成员变量和局部变量的区别

位置不同: 成员变量 : 类中方法外 局部变量 : 方法中,或者是方法的声明上(形参)

初始化值不同: 成员变量 : 有默认初始化值 局部变量 : 没有默认初始化值,使用之前必须赋值,才能使用 内存位置不同: 成员变量 : 堆内存 局部变量 : 桟内存 生命周期不同: 成员变量 : 随着对象的创建而存在,随着对象的消失而消失 局部变量 : 随着方法的调用而存在,随着方法的消失而消失 作用域不同: 成员变量 : 整个类当中 局部变量 : 仅在他所在的大括号中有效

如何调用成员? 如何创建对象?

创建对象的格式: 类名 对象名 = new 类名();

成员变量:对象名.属性名

成员方法:对象名.方法名(参数);

请叙述一下面向对象的三大特征

1. 封装

        概述:  隐藏实现细节 , 仅对外暴露公共的访问方式

        原则: 将不需要对外提供的内容都隐藏起来.

        问题: 封装指的就是private吗?

                私有仅仅是封装的一种体现形式,不能说封装就是私有.

        封装的好处和弊端:

            好处:
                    1. 提高了代码的复用性
                    2. 提高了代码的安全性

            弊端:
                    如果封装出现了弊端 , 只能说明该程序员的代码写的太烂了!

                        调用成员变量的时候,稍微麻烦了一点

                                因为我们只能通过setXxx和getXxx方法进行调用.

        结论: 封装指的是一种思想,并非是一个技术点

                将代码抽取到方法中,这是对代码的一种封装

                将属性抽取到类当中,这是对数据的一种封装.

2. 继承

    概述 : 让类与类之间产生关系, 子父类关系, 产生了子父类关系后,子类就可以直接使用父类中非私有的成员.

    问题 : 实现继承使用的是哪个关键字?

                class 子类类名 extends 父类类名{

                }

    问题: 继承的好处和弊端?

            好处: 
                1. 提高了代码的复用性
                2. 提高了代码的维护性
                3. 是多态的前提

            弊端:
                类的耦合性增强了

                开发的原则: 高内聚,低耦合

                    内聚: 自己完成事情的能力
                    耦合: 类与类的关系太过紧密

    问题: 什么时候使用继承?

             发现事物之前产生了一种is..a的关系, 谁是谁的一种

                    例如:  学生,老师 -> 人
                             苹果,香蕉 -> 水果    

    问题: Java当中的继承特点?

            Java中只支持单继承, 不支持多继承, 但是可以多层继承

                    class A{}
                    class B extends A{}
                    class C extends B{}

            如果想看一个继承体系当中,共有的功能,看最顶层的类, 想要使用体系中最全的功能,就创建最底层的对象.

    问题: Java继承中的成员访问特点:

            1. 如果子父类中出现了重名的成员变量,调用的时候用的是谁的?

                    走的是子类的,此处采用的是就近原则

            2. 如果子父类中出现了重名的成员方法,调用的时候执行的是?

                    子类的,虽然这里是就近原则的效果,但术语上称呼为方法的重写(覆盖,复写)

    问题: Override和Overload的区别?


            Overload(重载) : 在同一个类中,方法名相同,参数列表不同,与返回值无关

                        参数列表不同:
                                1. 个数不同
                                2. 类型不同
                                3. 顺序不同(没有意义)

            Override(重写) : 在子父类当中, 出现了方法声明一模一样的方法

                                    (方法名和参数列表必须完全一致)

    问题: 什么时候使用方法的重写?

            概念: 当子类需要父类的功能, 并且子类方法的功能主体又有自己特有的实现方式, 这时候就可以对父类的方法进行重写

                    这样做即沿袭了父类的功能, 又定义了子类特有的内容

            大白话理解: 当子类觉得父类的方法不好,或者说过于老旧,就可以对父类的方法进行重写

    问题: 方法重写的注意事项?

            1. 父类中私有的方法,子类不能重写
            2. 子类重写父类方法的时候,访问权限必须大于等于父类

                    private -  default  - protected  - public

3. 多态

     概述: 事物存在的多种形态



     问题: 多态的前提?

            1. 要有继承关系
            2. 要有父类引用指向子类对象

                    Fu f = new Zi();

     问题: 多态的优点和弊端?

            优点: 
                1. 提高了代码的复用性  2. 提高了代码的维护性
                1. 提高了代码的扩展性

                问题: 如何提高了代码的扩展性?

                        可以将方法的形参定义为父类类型, 该方法就可以接受这个类的任意子类对象

                        useAnimal(new Dog());
                        useAnimal(new Cat());

                        public static void useAnimal(Animal a){
                        }

            弊端:
                不能调用子类特有的属性和行为

     问题: 如何调用子类特有的属性和行为?

            必须向下转型.

            Person p = new SuperMan();
            SuperMan sm = (SuperMan)p;
            sm.fly();


            向下转型的注意事项:

                1. 必须转上去,才能转下来

                    Perosn p = new Person();
                    SuperMan sm = (SuperMan)p;  // 出现错误, ClassCastException

                2. 强转的环境必须发生在子父类关系当中

                    Animal a = new Dog();
                    Cat c = (Cat)a;             // Cat 和  Dog 不存在子父类的关系


      注意: instanceof的作用 -> 判断左边的引用是否是右边的类型.


    多态的成员访问特点:

            成员变量: 编译看左边(父类), 运行看左边(父类)

                    因为是父类的引用, 所以只能看到堆内存中super一小块区域

            成员方法: 编译看左边(父类), 运行看右边(子类)

                    原因: 在多态创建对象调用方法的时候, 编译时会检查父类中是否有此方法

                        没有: 编译失败
                        有: 编译通过, 但是运行的时候, 执行的是子类的逻辑

            静态方法:  编译看左边(父类), 运行看左边(父类)

                        因为静态跟类相关, 跟对象没有关系, 所以即使是对象名调用的方法, 编译器也会翻译成
                            类名.方法();

构造方法

问题: 构造方法的格式

1. 方法名与类名相同,大小写也要一致
2. 没有返回值类型,连void都没有
3. 没有具体的返回值

    问题: 构造方法能不能写return语句?

            可以写return语句,但是return后面不能跟具体的值.

问题: 构造方法的作用?

    用来给对象中的数据(属性)进行初始化.

问题: 构造方法什么时候执行?

    每创建一次对象的时候,由系统自动调用

            问题: 构造方法是否允许手动调用?

                    不允许手动调用     ->  Person p = new Person()
                                        p.Person();
                                        p.show();

                                        new Person().show();        -> 匿名对象

注意: 如果定义类的时候, 没有给出构造方法, 系统将会提供一个默认的空参构造 一旦手动给出了构造方法, 系统就不会再提供哪个默认的空参构造了

    建议: 今后编写类的时候, 空参有参都手动给出.

问题: 给成员变量初始化有几种方式?

    1. 有参构造方法
    2. setXxx

        两种方式的使用场景?

            一般都是配合使用的, 我们会通过有参构造对数据进行初始化, 随后通过setXxx方法修改属性值.

问题: setXxx和getXxx方法一定要成对儿出现吗?

    不一定, 需要根据具体的业务逻辑去组织.

this和super

this : 代表当前对象的引用, 谁来调用我, 我就代表谁

    简单理解: this就是本类对象的引用

super: 代表当前对象父类的引用

    简单理解: 父类的引用

成员变量:

    this可以调用本类的成员变量, 也可以调用父类的成员变量
            前提: 子父类中没有出现重名的变量
    super只能调用父类的成员变量

成员方法:

    this可以调用本类的成员方法, 也可以调用父类的成员方法
            前提: 子父类中没有出现重名你的成员方法

    super只能调用父类的成员方法

构造方法: this() 用来调用本类的构造方法

    super() 用来调用父类的构造方法

问题: 子父类之间是谁先完成初始化的?

    一定是现有的父类,才有的子类

        问题: 为什么要先完成父类的初始化?

            因为子类在创建对象的时候, 可能会使用到父类的成员, 如果父类没有完成初始化, 子类将无法正常创建对象.

        问题: 如何完成的父类初始化?

            在子类的每一个构造方法中, 都默认隐藏了一个super(), 在访问父类的空参构造进行初始化

        问题: 如果父类没有空参构造,子类怎么办?

            如果没有空参, 绝对有带参构造

                只需要手动通过super访问带参构造即可

                    结论: 子类无论怎样, 在创建对象之前, 都必须要访问到父类的构造方法.

final关键字

问题: fianl可以用来修饰什么?

变量: 被其修饰的变量就变成了常量, 只能被赋值一次

方法: 被其修饰的方法, 就不能被重写

类: 被其修饰的类,就不能被继承

问题: final修饰成员变量的初始化时机为?

1. 在创建的时候直接赋值(推荐)
2. 在构造方法结束之前完成赋值

static关键字

问题: static可以用来修饰?

    可以用来修饰成员

问题: 被其修饰的成员有哪些特点?

    1. 随着类的加载而加载, 优先于对象存在
    2. 被类的所有对象所共享
    3. 多了一种调用方式, 可以通过类名.进行调用

静态的注意事项:

    静态只能访问静态

    静态中没有this和super关键字

        原因: this和super只有在创建对象之后, 才会存在, 而静态出现的时候, 对象还没有.

问题: 什么时候使用静态修饰成员变量?

    共性用静态, 特性用非静态.      

问题: 什么时候用静态修饰成员方法?

    一般设计工具类的时候, 为了调用者调用的更加方便, 会将方法定义为静态的, 因为可以类名.直接调用

    如果一个类中所有的方法都是静态的, 往往会多做一步操作

            私有构造方法

抽象类

问题: 如何理解抽象类?

将像的部分和相似的部分抽取出来, 到一个类当中(父类)

问题: 抽象类和普通的父类有什么区别?

抽象类中可以定义抽象方法.

问题: 抽象方法又是什么?

将共性的行为向上抽取到父类中之后, 发现该行为描述不清, 但还是要强制子类去重写的方法

    抽象方法一定要存活在抽象类或者是接口当中.

问题: 如何定义抽象类和抽象方法

抽象方法: 在返回值前面加入abstract关键字,然后去掉方法体, 直接分号结束

抽象类: 在class的前面加入abstract

问题: 抽象类的成员特点

成员变量: 可以是变量, 也可以是常量

成员方法: 可以是抽象方法, 也可以是一般方法

构造方法: 有构造方法, 目的是为了给子类初始化的.

    结论: 抽象类中除了可以定义抽象方法之外, 其他的, 跟普通的类完全一致.

问题: 抽象类能否被实例化?

    抽象类不能被实例化(不能创建对象)
        原因: 如果允许创建对象, 就可以调用内部没有方法体的抽象方法, 这样做没有意义.

        问题: 非要实例化怎么办?
                可以使用多态的形式创建对象

                        Animal a = new Dog();

问题: 抽象类子类的选择?

    1. 要么重写所有的抽象方法
    2. 要么将自己也变成一个抽象类.

接口

概念: 广义上来讲, 对外暴露规则的都是接口 狭义的角度来看, 接口指的就是java中的关键字, interface

问题: 如何定义接口?

    interface 接口名{}

问题: 如何使用接口?

    因为接口不能实例化, 所以编写接口的实现类

        作为接口的实现类

            1. 要么重写所有的抽象方法
            2. 要么将自己也变成一个抽象类.

    class 实现类名 implements 接口名{}

问题: 接口中的成员特点?

    成员变量: 只能是常量, 因为默认加入了public staitc final

    成员方法: 只能是抽象方法, 因为默认加入了public abstarct

            扩展: 接口在jdk8版本之后, 允许定义带有方法体的方法.

                public default void method(){

                }

    构造方法: 没有!

问题: 类与类, 类与接口, 接口与接口的关系是?

    类与类: 继承关系, 只支持单继承, 不支持多继承, 但是可以多层继承
    类与接口: 实现关系, 可以单实现, 也可以多实现,并且可以在继承一个类的同时, 实现多个接口

            接口的出现, 打破了java中只支持单继承的局限性

    接口与接口: 继承关系, 可以单继承, 也可以多继承.

问题: 接口和抽象类的设计理念区别

    抽象类被继承体现的是一种 is..a的关系, 内部定义的功能都是[共性]的内容
    接口被实现体现的是一种like..a的关系, 内部定义的功能都是[特性]的内容

        今后只要提到接口, 就需要想到两个代名词

                1. 规则
                2. 扩展(特点)

权限修饰符

private : 本类

default : 本类, 同一个包下

protected : 本类, 同一个包下, 不同包下的子类

public : 只要不跨项目, 都能用

面试题: abstract关键字不能和那些关键字一起使用?

private : abstract修饰的方法强制要求子类去重写的方法, 而被private修饰的方法, 子类继承不到, 就更不能重写 二者冲突.

final : abstract修饰的方法强制要求子类去重写的方法, 但被final修饰的方法, 子类不能重写. 二者冲突

static : 被静态修饰的方法可以通过类名.进行调用, 而类名.调用没有方法体的抽象方法, 没有意义.