java基础——OOP面向对象

1.OOP-面向对象的编程思想

   2.1 面向对象的概念
        面向对象的编程是使用人类社会的思维方式来记性编程；面向对象是体现了人类社会的思维方式，而不是cpu的思维方式（汇编、二进制命令）
        面向对象核心：
            抽象、封装、继承、多态【面向对象的8字真言】
            注意：如果是考试面试，一般说是面向对象的三大核心：封装、继承、多态
        面向对象的扩展补充：
            static、abstract、final、interface
        面向对象围绕这8个词展开；

    编程的思维方式分为：
        面向过程的编程：思维出发点——如何去做？  思考的重心在如何？
        面向对象的编程：思维出发点——找谁去做？  思考的重心是找谁？  这个 “谁” 就是对象 
    
    如何进行面向对象的编程？ 面向对象的思维方式？ 面向对象解题步骤？
        采用面向对象的编程思想，针对一个问题：
            首先，思考找谁去做？ 这个 “谁” 就是对象；
            其次，对象从何而来？ 对象通过抽象获取对象的核心属性（成员变量、成员方法），然后使用封装手段，
                将抽象出来的核心属性进行封装，就得到了对象的定义（类）；使用类可以创建对象的实例；
            最后，调用获取的对象的实例，完成这个问题的处理；

2.2 抽象
    抽象：从个体都一般，也就是抽取一类个体的共性；抽象是面向对象编程的第一步；
    抽象对于面向对象的编程非常重要；如果抽象没有做好，后面可能会造成重头再来；
    抽象的目的：
        从所关注的每一个个体中将复合抽象视角的所有的共性；
        面向对象抽取的共性包含两种：属性（成员变量）、行为（成员方法）；
        抽象出来的属性以类的成员变量的形式进行规范定义；【写在类范围中的变量就是成员变量】
        抽象出来的行为以类的成员方法的形式进行规范定义；【写在类范围中的方法就是成员方法】
2.3 封装
    封装就是将抽象出来的内容（属性、行为）封装在Java类中；
    类：Java中的类是对对象的规范和定义；
        java中的类有以下几部分构成：成员变量（属性）、成员方法（行为）、构造方法（特殊的成员方法）、内部类等等
    封装的目的是：将抽象的内容以类的形式进行固化；然后在面向对象的编程中，使用类进行交互操作；
                【经验：面向对象的最小的编程单位就是类；可以通俗的理解为：面向对象的编程就是创建类的过程；】
    封装的手段：使用访问控制修饰符进行封装；
               访问控制修饰符【范围从大到小】： public protected 默认的 private

    封装的原则：
        在软件工程中，封装的原则：
            类中的属性（成员变量）一般封装为privte类型，并为其提供一个可以访问的方法入口【getter/setter方法】；
            类中的行为（成员方法）一般封装为public类型；
    访问控制修饰符的范围：
        public：任何类都可以访问；
        protected：同包的类和非同包的子类；
        默认的：同包的类；
        private：仅限于本类内容；  

2.4 new关键字
    new关键字：是java中用于在内存中创建对象并进行内存空间申请的操作关键字；等价于C语言的 malloc 函数
    使用new创建的对象，都会在内存堆中分配一块存储单元，并把该存储单位的访问地址赋值给该对象的变量名；

2.5 成员变量和局部变量
    成员变量：也叫作类的属性，实例变量；定义在类范围的变量叫做成员变量；【纠正一个笔误】
    局部变量：定义在方法、语句块、方法声明中的变量叫做局部变量；

    成员变量和局部变量的异同点：
        成员变量有默认值，使用之前不要求进行初始操作；局部变量没有默认值，局部变量使用之前必须显式的进行初始化操作；
        作用域范围：成员变量作用域范围是整个类；
                   局部变量的作用域范围是从其声明的位置开始到其所在的范围结束位置；
        生命周期：成员变量的生命周期和类的实例对象的声明周期是一致的；
                 局部变量的生命周期是从局部变量定义位置开始到其所在的作用域范围结束位置；
        当成员变量和局部变量名字一样的时候，不会发生编译错误，但是局部变量的值会覆盖掉成员变量的值；
            判定原则：范围最小优先原则；就近原则； 

2.6 构造方法
    构造方法是类中一类特殊的行为方法，构造方法只能使用new关键字进行调用；不能像普通方法那样调用；
    语法：
        访问控制修饰符 所在类的类名(方法参数列表){
            构造方法体；
        }
    解析：
        构造方法可以重载；
        构造方法只能在new的使用调用，并且只调用一次；
        重载的构造方法通过实参列表来决定调用那个构造方法；
        jvm在编译时会自动为没有显示提供构造方法的类附加一个不带参数的默认的构造方法；所以不带参数的默认的构造方法可以省略；
        虽然jvm会给类附加一个默认的构造方法，但是当有了其他的自定义的构造方法时，jvm提供的默认的构造方法就失效了，如果此时还想
            使用默认的构造方法，则需要显式的将不带参数的默认的构造方法显式写出；
        构造方法只能使用new关键字进行调用；不能像普通方法那样调用；
        构造方法之间可以相互调用，但是只能通过this关键字进行调用；并且只能放在第一行；
         构造方法不能被继承；
        子类可以通过super(参数列表)调用父类的狗造方法，且super只能写在第一行；
            this是类内部构造方法之间的调用方式；super是父类和子类之间的构造方法的调用方式；
        子类如果没有使用super显式的调用父类的构造方法，则jvm会默认调用父类默认的构造方法，无论使用不适用super关键字；
            所有，被继承的父类必须保证其默认的构造方法能够被访问；
        构建子类是会递归调用该子类所有父类的构造方法，先执行顶层的父类构造方法，然后依次向下执行；【也是上一条语法要求的原因】
            java世界中所有类的直接或间接父类是Object类【造物者类，上帝类】；

2.继承

 2.1 继承的概念
        继承：使子类具有父类的某些属性和功能，这种机制就是继承；
        解析：
            通过继承子类具有父类的某些属性和行为，不需要从0开始创建类，达到代码复用的效果；
            继承是有限定的，不是所有的属性和行为都为子类继承，限定通过访问控制修饰符来限定；
            访问控制修饰符限定继承的范围；
            继承通过extends关键字进行实现；
            java是单继承，也就是一个子类只能有一个直接父类；【C++是多继承】
        
    访问控制修饰符限定继承的范围：
        public：所有的子类都可以继承；
        protected：所有的子类都可以继承；
        默认的：同包的子类可以继承；
        private：不能继承；
        
 2.2 多态
    多态：就是在继承机制下产生，当子类继承了父类的某些行为方法时，
          被继承行为被子类进行了扩展，这样子类表现出来和父类不一样的行为结果时，就是产生了多态；
    解析：
        子类和父类具有同名的方法，但是子类展示的行为不同于父类；也就是子类对继承的父类的行为进行扩展；
        多态是父类和子类之间的关系；
        多态可以使用Override注解，有利于编译器进行检测；该注解也可以省略；
        在多态机制下，子类可以通过 super.方法名 调用父类被覆盖的方法；
        使用父类指代子类，调用的行为方法还是子类的方法；【变量类型虽然是父类，但是执行的方法是子类的】
        使用父类指代子类，只能调用子类从父类集成或者覆盖的父类以后的方法；而不能调用子类新增的方法；
        使用父类指代子类，变量名表面上是一个父类类型，但是内存中存储的是一个子类类型；
        
    多态产生的条件：
        方法名相同；
        参数列表相同；
        返回值相同或者父类的返回值类型可以兼容子类的类型；
        子类的访问控制修饰符的范围要大于等于父类的；
        子类抛出的异常范围要小于等于父类抛出或者处理的异常范围；

    多态的理解：
        从子类的角度：
            子类的覆盖了父类同名的方法，也叫作重写【Override】；
        从父类的角度：
            使用父类的引用执行子类的实例对象，也叫作溯型；
            【向下溯型：父类变量执行子类；向上溯型：子类变量指向父类】

    多态的价值和意义：
        继承：子类具有了父类的行为能力；
        多态：子类扩展了父类的行为能力；
        如果没有多态，子类最多具有父类全部行为能力；如果使用多态，则子类可以丰富父类已有功能，推进类的衍变；  

2.3 this和super关键字
    this：用于指代当前类的实例对象；
          this可以用于区分同名的成员变量和局部变量；当成员变量被局部变量覆盖式，可以使用this前缀用于区分；
          this(参数类表) 可以调用当前类的构造方法；
    super：用于指代当前类的父类的实例对象；    
          super可以在父类的同名方法被子类覆盖式，可以使用super前缀调用父类被覆盖的同名方法；
          super(参数列表)可以调用父类的构造方法；

1.4 四大扩展关键字
    面向对象的核心是：抽象、封装、集成、多态【四大核心关键字】
    面向对象补充：static、final、abstract、interface【四大补充关键字】
    
    static关键字：
        static关键字：静态关键字。
        static关键字：可以修饰类、方法、成员变量、语句块；
        解析：
            被static修饰的对象称之为静态的；静态的对象在创建初始化之后是一直驻留在内存中的，直到程序运行结束【jvm结束】才消亡；
            使用static修饰的类、方法、成员变量，也叫作类变量；
            使用static修饰的类、方法、成员变量，可以通过类名直接访问【推荐方式】；当然通过实例对象也可以访问【不推荐，不规范】；
            使用static修饰的方法不构成重写【静态方法没有多态】
            使用static修饰的语句块叫做静态语句块；静态语句块在类被jvm加载执行时进行执行，且只执行一次。一般用于数据初始化操作；
            如果父类和子类都有静态语句块，先执行父类的静态语句块；【从父类到子类递归调用静态语句块】
            static关键字只能修饰成员变量，不能修饰局部变量；
            使用static修饰的静态的方法、语句块只能调用静态的方法、静态变量；不能调用非静态的方法或者变量；
            不使用static修饰的方法【普通方法、普通语句块】，既可以调用静态也可以调用非静态的；

       补充：
            语句块就是写在一对 {} 中的代码；语句块的作用就是改变作用域范围；有点类似于 () 改变表达式中的运算级别和运算顺序；

          一道面试题的总结：
            在Person父类和Student子类中含有静态语句块、非静态语句块、构造方法时，执行new子类实例对象的代码时，这几部分的执行顺序如下：
                （1）执行了Person类中的静态语句块的代码
                （2）执行了Student类中的静态语句块的代码
                （3）执行了Person类中的非静态语句块的代码
                （4）执行了父类Person的默认的构造方法
                （5）执行了Student类中的非静态语句块的代码
                （6）执行了子类Student的默认的构造方法
            这个顺序一定要记住；这是面试题考点；

        static和重写结合使用时：
            当使用父类类型指代子类时，子类和父类具有同名的静态方法或者成员变量时，调用的是那个类的静态方法或者成员变量，
                取决于调用时使用的变量的类型，如果变量类型是父类类型则调用父类的，如果变量类型是子类时，调用的是子类的；
                【就近原则】  【面试点】

		final关键字：
		            final可以修饰的对象：类、方法、变量（成员变量和局部变量）；
		            被final修饰的对象表示终结、不可改变的；
		            解析：
		                被final修饰的类不可以被子类继承；【太监类】被final修饰的类没有子类；
		                被final修饰的方法不可以重写；final修饰的方法没有多态行为；
		                被final修饰的变量，一旦初始化赋值之后，不许允许在修改变量的值；
		            补充：
		                其实final是用于限定继承、多态的边界的；
		                final 和 static 一起修饰的成员变量叫做 静态常量；静态常量的命名规范：变量名全部大写且使用下划线分割；
		                静态常量需要在声明的同时进行初始化；

    abstract关键字：
        abstract关键字是抽象的关键字：表示没有实现的意思，停留在抽象概念层次上；
        abstract可以修饰：类、方法；
        解析：
            abstract是对抽象的补充；在抽象过程中有些行为方法无法具体化时，但是有需要进行抽象封装，这时可以使用abstract进行解决；
            使用abstract修饰的类叫做抽象类；使用abstract修饰的方法叫做抽象方法；
            含有抽象方法的类一定是抽象类；使用abstract修饰的类一定是抽象类；抽象类不一定含有抽象方法；
            抽象类不能使用new直接创建；【abstract表示抽象的层次，表示无法进行具体化；所有抽象类无法分配内存空间】
                【这个问题可以通过匿名内部类进行解决】
            抽象方法没有方法体，只有方法声明部分；
            如果一个类继承了抽象类，则这个类要么将父类的全部的抽象方法通过重写的方式进行实现；
                                         要么这子类继续保持为抽象类，这样可以对父类的抽象方法不用全部进行实现；
            子类实现父类的抽象方法就是给抽象方法补充 {} 的过程；
            抽象类除了含有抽象方法或者使用abstract修饰符之外，和一个普通类是一样，也具有属性、方法；另外可能含有抽象方法；

        抽象关键字存在的价值：
            当在类的抽象封装过程中，如果某个行为方法无法具体化，只能停留在抽象的概念层级上，但是有不得不对该方法进行封装，这种情况下，
                可以通过将该方法定义为抽象方法，对其进行封装；那么该方法的实现就可以推迟到子类的层次进行完成；【子类通过重写再对该方法进行实现】    

    interface关键字：
        interface关键字：接口；使用interface定义的类就是接口类；接口的子类使用 implements 继承接口；
            解析：
                接口类是一种特殊的抽象类；以至于特殊到使用interface定义，而不是使用class定义；特殊到接口中只含有抽象方法；
                接口中只含有抽象方法；在接口中定义的方法默认都是  public abstract 方法，即便省略 public abstract或者其中一个，
                    jvm还是将其解析为 public abstract 方法；      
                    接口中定义的方法都是公共的抽象方法；                     
                接口中没有成员变量；在接口中定义的变量都默认为 public static final 类型【静态常量】，即便省略 public static final 
                    或者是其中一个，jvm还是将其解析为  public static final  类型的常量；
                    接口中定义的变量是常量而不是成员变量；
                接口也不能使用new直接创建实例对象；
                接口中只有抽象方法，没有成员变量和非抽象方法；【jdk8-】【考试试题，按照这个语法规则判定】√
                【扩展】 default关键字  在接口中如果想定义一个代用方法体的普通方法，则可以使用default关键字实现。【jdk8+】
                如果一个类型实现了接口，则这个类需要把继承的父类接口中所有的抽象方法全部进行实现；【否则会报编译语法错误】

                java中类class只支持单继承；java中接口可以支持多继承；
            
            接口的多继承：
                java中接口可以实现多继承，用于弥补java类的单继承造成的一些限制；
                接口的多继承体现在两个方面：
                    类和接口之间的多继承：类 implements 接口1,接口2,接口3   
                    接口和接口之间的多继承：接口 extends 接口1,接口2,接口3

        接口interface关键字存在价值和意义：
            抽象类还一个类，具有类的特性，接口是特殊的抽象类，只具有一组抽象行为；
            接口一般用于定义一组行为规范；
            如果那个类实现某个接口表示这个类具有了某种或者某些行为能力；
            
            接口和抽象的使用场景：
                如果只是定义一组行为规范，则使用接口；其他情况使用抽象类； 
                在一定程度上，接口和抽象类是可以相互替代的；    
                接口可以多继承，具有很强的组织灵活性；抽象类只能单继承；

3.内部类

 3.1 内部类的概念
        内部类：定义在一个类内部的类叫做内部类；
        内部类根据定义的位置和使用的修饰符可以分为：
            成员内部类：
                定义在成员变量位置的内部类叫做成员内部类；因为其定义在成员变量的位置，所有具有和成员变量一样的性质；
                作用域范围和声明周期与成员变量一样；
                成员内部类的使用和成员变量是一样的；
                外部使用成员内部类时：
                    外部类.成员内部类  变量名 = 外部类实例对象变量.new  成员内部类();
                也就是成员内部类和外部类的实例对象绑定在一起的；

        静态内部类： ★★★
            使用static修饰的成员内部类就是静态内部类；静态内部类具有和静态成员变量一样的性质；
            使用方式、作用域范围、生命周期和静态成员变量一样的；

        局部内部类：
            定义在局部变量位置的内部类叫做局部内部类；使用方法和局部变量的用法是一样的；
            在局部内部类中访问外部的局部变量，jvm8- 以前，要求被访问的局部变量必须是final类型；jvm8+以后，默认为final类型
            局部内部类可以访问外部类的成员变量；

        匿名内部类：【方便编程，就是编程的一种简便方法形式】 ★★★
            没有名字局部内部类就是匿名内部类；
            匿名内部类主要是对抽象、接口进行使用的一种方式；这种方式可以搭配new操作符进行操作；
                这种方式主要是将抽象类、接口的抽象方法的实现和new操作符的操作结合在了一起，式编程编程更加便利；
            匿名内部类主要是当之关系动作行为的结果时，而不关心动作的发出者时，可以优先考虑使用匿名内部类来进行编程；

    内部类的学习要求：掌握匿名内部类的编程方式即可；

4.String和Object类

  4.1 String工具类的使用
        String工具类的常用的一些方法；
            要求：查找api，并能熟练使用api中提供的方法；
        String在内存中的存储模型；
        java中对String字符串的存储：
            字符串常量存储在字符串池（栈）；
            使用new创建的字符串对象存储在内存堆中；  
            存储在字符串池（栈）中的字符串常量不能够重复；只要值相同，就是同一个元素；
            存储在堆中的字符串可以重复，并且没进行一次new就会创建一个新的内存对象，无论内容是否相同；

4.2 Object工具类
    Object类是java世界中顶级类；是所有类的直接或者间接父类；
    Object类是所有类的直接或者间接父类；
    
    hashcode方法；
    equals方法；

    掌握： == 和 equals的区别
    == ：判定是内存地址为否相同，相同则说明是同一个存储单元；
    equals：判定是内容是否相同；如果相同则说明他们在内存中的内容是一样，但是不一定是同个内存地址；

    因为equals方法是Objcet类提供的，在Object类中 == 和 equals 的代码逻辑是一样的；
    Objcet的子类需要重写（Override）equals方法，使其业务逻辑变为之判定内容相等；可以查看 String类的 equals方法 和Object类equals方法的区别；      

4.3 instanceof关键字
    instanceof关键字是用来判定一个变量是否不是为某一个数据类型；
    instanceof关键字支持多态；

4.4 java实参和形参的传值方式
    java的方法调用的时候会将实参的值传递给形参；发生了传值；
    java中的传值可以分为两种：
        按值传参：
            实参的值会传递个形参；
            如果形参的值发生了改变，不会反向影响实参的值；
            数据类型：8种基本类型、String类型；

        按引用（地址）传参：
            实参的地址传递给形参；
            如果形参的值发生了改变，则会反向影响实参；也就是实参的值会跟着形参的值发生变化；
            数据类型：除了8种基本类型和String类型之外的所有类型；
                     即：数组、对象类型（除String外）