面向对象的总结：

   什么叫面向对象：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。
   面向对象的好处：基于对象的编程更符合人的思维模式，使人们更容易编写程序。
      第一，封装性
      第二，继承性
       第三，多态
   什么叫做类：对同类对象抽象出其共性，形成类。
       面向对象的三大特性：
           封装：封装:是指隐藏对象的属性和实现细节,仅对外提供公共的访问方式
                 封装的原则:1.将不需要对外提供的内容隐藏起来
                            2.对外提供公共的访问方式 ,getXXX(访问器) setXXX(修改器)
           继承：
           多态： 一类事物的多种形态
             多态的前提:需要继承或者实现关系,需要有覆盖操作，需要父类的引用指向子类的对象
             多态的好处 提高类的扩展型
             多态的代码描述：
             多态:父类型的引用指向子类型的对象,或者是接口执行他的实现类的对象或者实现类的子类对象
             自动类型提升(向上转型),但是子类型的特有功能无法访问.限制了对特有功能的访问
             对于转型来说,自始至终都是发生在父子类之间的，如果不是就会就会抛ClassCastException 类型转化异常
             
             多态的一些注意点：
             1.成员变量 编译和运行都参照等号左边(静态绑定)
             编译时:参考引用变量所属的类型,如果该类型存在调用的成员变量那么编译通过,否则编译失败
             运行时:参考引用变量所属的类型,如果该类型存在调用的成员变量那么运行该类所属的成员变量
             2.成员方法:编译看左边,运行看右边(动态绑定)
             3.静态方法:编译和运行都参照等号左边
                 局部代码块
                  声明在局部位置上的局部代码块可以限制变量的作用域
                  声明在成员位置上局部代码块叫做构造代码块,作用是给对象初始化,在创建对象的时候调用,并且是先于对象调用的

              static关键字:静态的,修饰符,可以修饰成员(成员变量,成员方法,构造代码块)
                  被static 修饰的成员的特点:1.随着类的加载而加载2,可以直接被类名调用3,被所有的对象共享4,先于对象存在
             成员变量和静态变量的差别:
                  1.两个变量的生命周期不同
                  成员变量随着对象的创建而存在,随着对象被回收而释放
                  静态变量随着类的加载而存在,随着类的消失而消失
                  2.调用方式不同
                  成员变量只能被对象调用
                  静态变量既可以被类名调用,也可以被对象调用,被对象调用的时候底层仍然是被类名调用
                  3,名称不同
                  成员变量叫做全局变量或者实例变量
                  静态变量也叫做类变量
                  4.数据的存储位置不同
                 全局变量存在堆内存的对象中,所以也叫做对象的特有数据
                 静态变量存在方法区中的静态池中,所以也叫做对象的共享数据

      static
            1.static修饰成员方法:静态方法
             特点:1.随着类的加载而加载,优先于对象存在的,既可以被对象调用,也可以被类名调用,但底层都是被类名调用的,被所有的对象共享
              2.只能访问静态变量和静态方法
          为什么要定义静态方法:如果一个方法不需要访问对象的特有数据,那么该方法就可以定义为静态的.

        2.static修饰构造代码块:静态代码快
         作用:给类初始化,可以给静态的变量初始化,或者是记录类加载的时间
        特点:随着类的加载而加载,并且只加载一次,只能访问静态变量和静态的方法
    
        static不和什么关键字一起使用:this,super

     继承:通过关键字 extends让类和类之间产生继承关系,被继承的类叫做父类,而继承的类叫做子类,子类会继承父类非私有的属性和行为
     继承的原则:不能为了获取某个功能或属性盲目的继承,父类和子类之间必须要有"is a"的关系
    java只支持单继承,不支持多继承,但是可以多层继承
    继承的好处:继承提高了代码的复用性,并且让类和类之间产生了继承关系,提供了多态的前提
    父类的来源:子类抽取共性得来的

     继承下方法的重写:重写也叫覆盖.当子类和父类之间出现了一模一样的方法(同名同参同返回),创建子类的对象去调用会默认运行子类的方法,
    这种现象称为方法的重写或者覆盖,如果希望在子类去使用父类的方法可以super.调用方法

    重写和重载的差别:
    1.重写发生在父子类之间,而重载发生在本类
    2.重写要且同名同参同返回,重载同名不同参

     @Override这是重写的标志,有该标志的方法,必须是重写的父类的方法
    作用:避免重写的时候出错

    什么时候需要使用重写的操作:当子类需要父类的功能,而功能主体有自己特有的内容时,可以重写父类的方法,这样既有了父类的功能
    又有了子类特有的内容

    什么样的方法不能被重写1.父类的私有方法不能以被重写2.父类被static不可以被重写3,被final修饰的方法不可以被重写
     fianl关键字:修饰符,最终的,可以修饰类,方法,变量
     被final修饰的变量是常量,常量不能被重新赋值
     被final修饰的方法不能被重写
    被final修饰的类不能被继承

    重写的时候子类方法的权限一定要大于等于父类的方法

 继承下的构造函数 :当子类的构造函数执行的时候,父类的构造函数一定会被调用,因为在子类的构造函数中有一个默认的隐式语句super()
 如果想调用父类的有参构造函数可以显示的定义super(参数列表).
     super 表示父类的对象
        什么叫抽象方法：在我们分析某一类事物的特性的时候，我们发现这些事物之间有相同的行为，但这些行为实现的细节不同，比如：狗和马都有睡觉的功能，但狗是躺着睡的，而马是站着睡的，在我们抽取这两个动物之间的共性时我们只抽取方法的定义，不抽取方法的实现体。像这种只有方法的定义，没有方法的实现体的方法，我们就叫做抽象方法。抽象方法只关注事物有什么样的功能，并不关注方法的实现细节。抽象方法都要被abstract修饰,抽象方法的实现必须通过继承进行重写来实现的。
        什么叫抽象类：含有抽象方法的类就是抽象类，抽象类也要被abstract修饰。抽象类不能实例化，抽象类只能被另一个类继承，当另一个类继承了抽象类并重写了抽象类中所有的抽象方法，那么这个抽象类中的所有抽象方法都被实现了。如果没有被全部重写，那么这个类就要被其他类继续继承，知道重写所有的抽象方法。
        什么叫接口：
          接口：
             接口的定义：当一个抽象类中方法全部都是抽象方法的时候,这个抽象类就可以用另外一种形式表示,就是接口
             怎么定义一个接口：通过interface关键字实现一个接口的定义，接口中的方法都是抽象方法，都要被abstract修饰，但在接口中也可以不用显示声明，变量都是常量，也就是被public static final修饰的变量。
             接口中的成员权限必须是公开的。
             怎么使用一个接口：接口是在一个类和接口之间通过implements关键字实现了接口的使用，这时我们就说这个接口被实现了。
             接口的作用是什么：接口是为了改变java单继承的局限性，一个类在继承的同时可以实现多个接口
        什么叫内部类：
          内部类是定义在另一个类里面的类，那么这个类就是内部类。
          内部类的应用场景：
          在我们分析一个事物的时候发现在这个事物的内部还有其他的事物时，而且外部的这个事物需要用到内部事物的内容，那么在进行代码实现的时候，我们就可以把内部的这个事物定义为内部类。
          内部类的分类：
     
          按内部类在外部类中的位置，我们可以把内部类分为成员内部类、静态内部类、方法内部类;
          匿名内部类。
          1.成员内部类：成员内部类是定义在成员位置上的内部类，成员内部类不能直接创建对象，因为成员内部类可以看做是外部类的一个成员，一个类中的成员只有在创建对象后才能被访问，因此，我们可以通过创建外部类的对象，然后通过外部类的对象（引用）调用内部类的对象，进而创建内部类的对象。成员内部类可以访问外部类的属性和行为。在一个类中使用另一个类中的内部类有两种实现方式
          1.进行导包
          2.    InnerClass out = new InnerClass();//InnerClass 外部类
          InnerClass.In in = out.new In();  //In 内部类
          // 因为内部类In不能直接访问,所以该类型需要定义为InnerClass.In,或者进行导包
        
          2.静态内部类：静态内部类和成员内部类一样是定义在成员位置上的，只不过被static修饰的，静态内部类可以直接创建对象，静态内部类可以直接访问外部类的静态属性和行为，不能直接访问外部类的非静态属性和行为，要想访问外部类的非静态属性和行为，可以通过创建内部类的对象进行访问。如果内部类中定义了静态成员,那么该内部类必须也是静态的。访问其他类的静态内部类，如果内部类定义为静态的,那么相当于定义了外部类
    
          3.方法内部类：方法内部类是定义在一个方法的内部（局部位置上的内部类），方法内部类中不能有静态的属性和行为。
          方法内部类可以直接访问外部类的属性和行为，方法内部类可以直接访问该方法的属性，但该属性必须要被final修饰。在jdk1.8中可以省略，但该属性默认是个常量。
    
          4.匿名内部类：匿名内部类也就是没有名字的内部类,正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写,但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
          什么时候使用匿名内部类:需要的重写方法不超过三个.(超过三个会降低可读性)