一.
        1.面向对象思想的特点
                (1)是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
                (2)可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
                (3)角色发生了转换，将我们从执行者变成了指挥者
                (4)就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
        2.面向对象的特征
                (1)封装
                (2)继承
                (3)多态
        3.类与对象的关系
                (1)类是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
                (2)对象是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
                (3)类是抽象(抽取出同类事物中相同的、相似的部分就叫抽象)的具体的或者是类是一般的，对象是特殊的
                (4)类中可以包含成员变量、类变量、成员方法、类方法、构造函数、构造代码块、静态代码块等
        4.成员变量和局部变量的区别？
                (1)在类中的位置不同
                        a.成员变量：在类中方法外
                        b.局部变量：在方法定义中或者方法声明上
                (2)在内存中的位置不同
                        a.成员变量：在堆内存(成员变量属于对象,对象进堆内存)
                        b.局部变量：在栈内存(局部变量属于方法,方法进栈内存)
                (3)生命周期不同
                        a.成员变量：随着对象的创建而存在，随着对象的消失而消失
                        b.局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
                (4)初始化值不同
                        a.成员变量：有默认初始化值
                        b.局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
        5.private关键字的特点
                (1)封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，private是实现封装的一种形式
                (2)private是一个权限修饰符，可以修饰成员变量和成员方法
                (3)被private修饰的成员，只能在本类中访问
                (4)当成员变量被private关键字修饰后，需要提供对应的get和set方法供外部访问
        6.谈谈你对this的理解？
                (1)this只能代表本类对象
                (2)this代表所属函数(方法)的所属对象
                (3)谁来调用我，我就代表谁
                (4)this可用于区分成员变量和局部变量同名的情况
               
二.
        1.构造方法的特点？
                (1)构造方法主要作用是给对对象的属性进行初始化
                (2)方法名与类名完全一致，没有返回值类型，连void都没有
                (3)构造方法也是方法，只是比较特殊，是在创建对象后马上调用，后期不能单独调用，既然是方法，就可以重载
                        a.方法名相同
                        b.参数列表不同(数量不同，顺序不同，类型不同)
                        c.与返回值类型无关
                (4)如果自定义类中没有提供构造方法，系统将自动提供一个无参构造方法，如果我们给出了构造方法，系统将不再提供默认的无参构造方法，要想再使用空参构造，必须显示给出
        2.java中创建一个对象的过程？
                (1)将类的字节码文件加载进内存
                (2)声明一个该类类型引用s
                (3)在堆内存创建对象,
                (4)给对象中属性默认初始化值
                (5)属性进行显示初始化
                (6)构造方法进栈,对对象中的属性赋值,构造方法弹栈
                (7)将对象的地址值赋值给s
        3.谈谈你对static关键字的理解？
                (1)被static关键字修饰的成员，属于该类中所有对象的共享内容可以直接用类名调用，也可以用对象调用，但是建议用类名调用
                (2)随着类的加载而加载,优先于对象存在：随着字节码文件的加载而加载的，那时候还没有对象呢
                (3)静态修饰的内容一般我们称其为：与类相关的，类成员（静态变量：类变量，静态方法：类方法）
                (4)在静态方法中是没有this关键字的(因为this指的是一个具体的对象,而静态在加载到内存时还没有具体的对象)
                (5)静态方法只能访问静态的成员变量和静态的成员方法,非静态的成员方法既可以方法静态的成员方法和成员变量，又能访问非静态的成员方法和成员变量
                        简单记忆：静态不能访问非静态
        4.静态变量和成员变量的区别？
                (1)所属不同
                        a.静态变量属于类，所以也称为为类变量
                        b.成员变量属于对象，所以也称为实例变量(对象变量)
                (2)内存中位置不同
                        a.静态变量存储于方法区的静态区
                        b.成员变量存储于堆内存
                (3)内存出现时间不同
                        a.静态变量随着类的加载而加载，随着类的消失而消失
                        b.成员变量随着对象的创建而存在，随着对象的消失而消失
                (4)调用不同
                        a.静态变量可以通过类名调用，也可以通过对象调用
                        b.成员变量只能通过对 象名调用
三.
        1.代码块的分类？
                (1)构造代码块：每次执行构造方法之前执行
                (2)静态代码块：随着类的加载而执行，而且只执行一次
                (3)局部代码块：方法内部定义的代码块叫局部代码块，随着方法的执行而执行
                (4)同步代码块：在多线程中为了解决线程安全问题
        2.谈谈你对继承的理解？
                (1)继承让类与类之间产生关系,子父类关系
                (2)继承提高了代码的复用性和维护性，单同时增加了类与类之间的耦合性
                (3)java只支持单继承，不支持多继承,但是Java支持多层继承
                (4)继承中的注意事项：
                        a.子类只能继承父类所有非私有的成员(成员方法和成员变量)
                        b.子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
                        c.不要为了部分功能而去继承
                (5)在创建对象时，子类中所有的构造方法默认都会访问父类中空参数的构造方法
                        a.因为子类会继承父类中的数据，可能还会使用父类的数据,所以，子类初始化之前，一定要先完成父类数据的初始化。                       
                        b.其实:每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
                (6)父类没有无参构造方法,子类怎么办?
                        a.super解决:用super(....)显式调用父类的有参构造,如:super(name,age);->super("zs",30);
                        b.this解决:通过this调用本类的有参构造,然后在本类的有参构造里,又调用了父类的有参构造,相当于间接调用父类的有参构造.
                        c.super(…)或者this(….)必须出现在构造方法的第一条语句上,只能出现其一
                (7)继承中成员方法关系?
                        a.不同名的方法:直接调用就可以
                        b.同名的方法:称为方法的重写,用子类对象直接调用的是子类已经重写的方法   
            c.要想调用父类的方法,可以在子类重写的方法中添加super();
               
        3.谈谈你对this和super关键字的理解？
                (1)this:代表当前对象的引用,谁来调用我,我就代表谁
                (2)super:代表当前对象父类的引用
                (3)this和super的使用区别
                        a.调用成员变量
                                * this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
                                * super.成员变量 调用父类的成员变量
                        b.调用构造方法
                                * this(...)        调用本类的构造方法
                                * super(...)        调用父类的构造方法
                        c.调用成员方法
                                * this.成员方法 调用本类的成员方法,也可以调用父类的方法
                                * super.成员方法 调用父类的成员方法
        4.什么是方法的重载和重写？
                (1)重载：在同一个类中，方法名相同、参数列表不同(数量不同、类型不同、顺序不同)、与返回值类型无关的多个方法构成重载
                (2)重写：在继承中，子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲) ，当子类需要父类的功能，
                        而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容
                (3)重写的注意事项：
                        a.父类中私有方法不能被重写,因为父类私有方法子类根本就无法继承,既然子类无法继承,就谈不上重写了
                        b.子类重写父类方法时，访问权限不能更低,最好就一致
                        c.父类静态方法，子类也必须通过静态方法进行重写
                                * 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
                        d.子类重写父类方法的时候，最好声明一模一样。
        5.final关键字的特点？
                (1)修饰类，类不能被继承
                (2)修饰变量，变量就变成了常量，只能被赋值一次
                (3)修饰方法，方法不能被重写(有时所有方法都很重要，都不需要被重写，需要将类定义成final的)
                (4)final修饰局部变量：基本类型，是值不能被改变，引用类型，是地址值不能被改变,对象中的属性可以改变
                (5)final修饰变量的初始化时机？
                        a.未被static关键字修饰
                                * 可以显示初始化
                                * 可以在构造方法中初始化
                        b.被static修饰
                                * 可以显示初始化
                                * 可以在静态代码块中初始化
                                * 不能在构造方法中初始化
                               
                               

四.
        1.谈谈你对多态的理解？
                (1)多态就是事物存在的多种形态
                (2)多态的前提
                        a.要有继承关系。
                        b.要有方法重写。
                        c.要有父类引用指向子类对象。
                (3)多态中的成员访问特点
                        a.成员方法：编译时看父类(左边)，运行时看子类(右边)
                        b.成员变量：编译时看父类(左边)，运行时看父类(右边)
                        c.静态方法：编译看左边(父类)，运行看左边(父类)。
                                (静态和类相关，算不上重写，所以，访问还是左边的)
                                只有非静态的成员方法,编译看左边,运行看右边
                (4)多态的好处和弊端
                        a.好处
                                * 提高了代码的维护性(继承保证)
                                * 提高了代码的扩展性(由多态保证)，可以当作形式参数,可以接收任意子类对象
                        b.弊端
                                * 不能使用子类的特有属性和行为
        2.谈谈你对抽象类的理解？
                (1)抽象类的概述？
                        a.在某些情况下,父类只知道子类包含怎样的方法,无法准确知道这些子类如何实现该方法
                        b.多个具有相同特征的类中抽取一个抽象类,以这个抽象类为子类的模板,从而避免子类设计的随意化
                        c.限制子类必须有哪些方法,不关注实现细节.
                (2)抽象类特点
                        a.抽象类和抽象方法必须用abstract关键字修饰
                                * abstract class 类名 {}
                                * public abstract void 方法名();//当不知道该方法具体是怎么实现的                                               
                        b.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
                        c.抽象类不能实例化那么，抽象类如何实例化呢?
                                * 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
                        d.抽象类的子类
                                * 要么是抽象类
                                * 要么重写抽象类中的所有抽象方法
                (3)抽象类的成员特点
                        a.成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
                        b.构造方法：必须有。
                                * 用于子类访问父类数据的初始化。
                        c.成员方法：既可以是抽象的，也可以是非抽象的。
                                * 抽象方法 强制要求子类做的事情。
                                * 非抽象方法 子类继承的事情，提高代码复用性。
        3.abstract关键字不能与哪些关键字共同使用
                (1)abstract和static
                        被abstract修饰的方法没有方法体
                        被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
                (2)abstract和final
                        被abstract修饰的方法强制子类重写
                        被final修饰的不让子类重写,所以他俩是矛盾
                (3)abstract和private
                        被abstract修饰的是为了让子类看到并强制重写
                        被private修饰不让子类访问,所以他俩是矛盾的
        4.谈谈你对接口的理解？
                (1)接口概述
                        a.从狭义的角度讲就是指java中的interface
                        b.从广义的角度讲对外提供规则的都是接口
                (2)接口特点
                        a.接口用关键字interface表示       
                                * interface 接口名 {}
                        b.类实现接口用implements表示
                                * class 类名 implements 接口名 {}
                        c.接口不能实例化
                                * 那么，接口如何实例化呢?
                                * 按照多态的方式来实例化。
                        d.接口的子类
                                * a:可以是抽象类。但是意义不大。
                                * b:可以是具体类。要重写接口中的所有抽象方法。
                (3)接口成员特点
                        a.成员变量只能是常量，并且是静态的并公共的。
                                * 默认修饰符：public static final
                                * 建议：自己手动给出。
                        b.构造方法：接口没有构造方法。
                        c.成员方法：只能是抽象方法。
                                * 默认修饰符：public abstract
                                * 建议：自己手动给出。
        5.简述类与类,类与接口,接口与接口的关系？
                (1)类与类：
                        a.继承关系,只能单继承,可以多层继承。
                (2)类与接口：
                        a.实现关系,可以单实现,也可以多实现。
                        b.并且还可以在继承一个类的同时实现多个接口。
                (3)接口与接口：
                        a.继承关系,可以单继承,也可以多继承。
        6.谈谈你对抽象类和接口的理解？
                (1)成员区别
                        a.抽象类：
                                * 成员变量：可以变量，也可以常量
                                * 构造方法：有
                                * 成员方法：可以抽象，也可以非抽象
                        b.接口：
                                * 成员变量：只可以常量
                                * 成员方法：只可以抽象       
                (2)关系区别
                        a.类与类
                                * 继承，单继承
                        b.类与接口
                                * 实现，单实现，多实现
                        c.接口与接口
                                * 继承，单继承，多继承
                (3)设计理念区别(面试时最好最初例子来)
                        a.抽象类 被继承体现的是：”is a”（属于）的关系。抽象类中定义的是该继承体系的共性功能。
                        b.接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
                                * 对事物本质的抽象用抽象类，对事物功能的扩展用接口
五.
        1.java中哪几种权限修饰符，其对应的访问权限是什么？
                                                本类         同一个包下(子类和无关类)        不同包下(子类)        不同包下(无关类)
                private                              Y               
                默认                                    Y                         Y
                protected                            Y                         Y                      Y
                public                                 Y                         Y                      Y               Y
               
        2.谈谈你对内部类的理解？
        3.谈谈你对匿名内部类的理解？
       

好用功啊，榜样