Java_面向对象

面向对象：

       面向对象是相对于面向过程的一种编程思想，它是基于面向过程的。

           面向过程：侧重于完成功能的过程。

           面向对象：侧重于完成功能的结果，强调的是对象。

 

        三个思想特点：

              a:更符合人思考习惯的一种思想。

              b:把复杂的事情简单化。

              c:把程序员从执行者变成指挥者。

 

类与对象：

      编程语言都是为了把现实世界的事物给体现出来的，所以编程语言就应该和现实世界的事物对应。

        现实的事物分为两种：

               内在的特征：对应类的成员变量。

               外在的行为：对应类的成员方法。

      类：

          是一组相关的属性和行为的抽象。

          类的组成：

                 成员变量：名词

                        来自于现实世界的中的属性的一种抽象描述。

                 构造方法：

                        用于创建对象，对对象进行初始化

                        特点：

                              a :方法名于类名相同。

                        b:方法没有返回值类型。

                        c:方法没有返回值。

                  注意：

                        a:系统默认给出一个无参构造方法。

                        b:自己给出构造方法，系统将不在提供。

                        c:可以通过构造方法，给成员变量赋值。

                 成员方法：名词+动词    

                   完成一些功能。       

     对象：

         对象是类事物的具体的个体，也被称为实例。

         首先把事物的特征和行为体现出来，把事物转换成Java中的类，最后创建对象调用。

            应用场景：

                   创建对象：类名 变量名 = new 类名();

                   调用对象：对象名.方法();    对象名.变量;

           匿名对象：

                  没有名字的对象。

                  应用场景：

                          a:调用方法只用一次的时候（可提升效率）。

                          b:作为实际参数传递。

      局部变量与成员变量的区别：

            在类中的位置：

                       成员变量：在类中，方法外。

                       局部变量：在类的方法中。

          在内存中的位置：

                  成员变量：在堆中。heap

                  局部变量：在栈中。stack

          生命周期：

                  成员变量：随着对象创建而存在，随着对象消失而消失。

                  局部变量：随着方法调用存在，随着方法调用完毕而消失。

          初始化值：

                  成员变量：有默认初始值。

                      基本数据类型：

                           整型:0

                           浮点:0.0

                           char:’\u0000’

                      引用类型:null

                  局部变量：必须先声明，再赋值，最后才能被使用。

             

面向对象三大：

      1，封装：

             隐藏实现的细节，仅对外提供公共的访问方式。

                  体现形式：

                        a:类

                        b:方法

                        c:被private修饰也是封装的体现。

      2，继承：

             在已知类的基础上扩充新的内容。

             extends表示继承的关系。class B extends A{}

             父类的定义：

                  是多个类中相同的成员变量和成员方法抽取出来的。

                  特点：

                              a：java中只能单继承。

                              b：java中可以多层继承（体系）。

                      优点：

                              a：提高了代码的复用性。

                              b：让类与类产生了联系，是多态的前提。

                      应用场景：

                              a：继承表达的是一种关系：is  a 。

                              b：不要为了部分功能而去继承。

                     继承后父子之间的成员关系：

                             成员变量：

                                    a：如果名字不同，直接调用本类的。

                                    b：如果名字相同的变量，在方法中使用的时候：

                                               先在局部范围查找，有就使用，

                                               然后成员位置查找，有就使用，

                                               最后在父类成员查找，有就使用，

                                               再没有就报错。

                             构造方法：

                                   a：子类并没有继承父类的构造方法。

                                   b：子类的构造方法执行前，会先执行父类的构造方法。这个时候，并没有创建父类对象，仅仅是对父类的内容进行了初始化。

                                         注意：如果在父类中没有无参构造，在子类中要么用this(…)，要么用super(…) 。

                             成员方法：

                                  a：如果名字不同，直接调用本类的。

                                  b：如果有名字相同的方法，是重写的形式（覆盖、复写）。子类使用的是自己的方法，覆盖父类的方法。

                   方法重写：

                              override，子类与父类方法声明相同。 

                              体现形式：

                                   a：方法名相同，参数列表相同。

                                   b：子类返回值类型小于等于父类返回值类型。

                                   c：子类访问权限修饰符大于等于父类访问权限修饰符。

                              注意：

                                   a：父类的私用方法不能被重写。

                                   b：静态方法只能被静态方法重写。

                  方法重载：

                         overload，方法名相同，参数列表不同。

                         体现形式：

                                  a：方法名，参数列表不同。

                                  b：与返回值类型无关。

                                  c：与返回值无关。

                  this与super的区别：

                        this:代表当前类的对象，谁调用，就代表谁。

                        super：代表父类存储空间标识，父类的引用。

                        应用场景：

                              一般都在子类使用。

                              成员变量：

                                      this.变量

                                      super.变量

                              构造方法：

                                     this.(…)

                                     super.(…)

                              成员方法：

                                     this.方法()

                                     super.方法()

                           类的初始化：

                                         Person p=new Person();    

                                              a：把Person.class类加载到内存。

                                              b：执行该类中的静态代码块，如果有，给Person.class进化初始化。

                                              c：在栈内开辟存储变量p的空间，分配内存地址。

                                              d：在堆内开辟new Person()的空间。

                                              e：对成员变量进行默认初始化。

                                              f：对成员变量进行显示初始化。

                                              g：如果有构造代码块，通过它对成员变量进行初始化。

                                              h：通过构造方法对成员变量初始化。   

                                              i：对象创建完毕，把堆内存的地址值赋给栈内存中的变量p。

                       

      3，多态：

             同一个对象在不同的时刻表现出不同的状态，编译期类型与运行期类型不一致。

             根据实际的对象不同而表现出的不同状态。

                  前提：

                        a：有继承或实现关系。

                        b：有method override。

                        c：有父类或父接口引用指向子类对象。

                  弊端：

                       不能使用子类特有的功能。

                  优点：

                       提高了程序的扩展性与维护性（由继承来保证）。

                 向上转型：

                       把子类对象赋值给父类对象或父接口引用。

                 向下转型：

                       把父类或父接口引用强制转换为子类

                 体现形式：

                      a：具体类多态

                      b：抽象类多态

                      c：接口多态

 

抽象类：

       多个具体的事物具备相同的方法声明，而方法体不同，抽取方法声明，定义到一个类中。

       一个没有方法体的方法是一个抽象方法，一个类有抽象方法，该类必须定义为抽象类。

            特点：

                a：抽象类或抽象方法被abstract修饰。

                b：抽象方法没有方法体，抽象类中不一定有抽象方法，而有抽象方法一定是抽象类。而没有抽象方法的抽象类是为了不让外界创建对象。

                c：抽象类不能被实例化。构造方法主要用于对子访问父类数据的初始化。

                d：子类继承抽象类，要么是子类也是抽象类，要么重写父类所有抽象方法。

            抽象类的成员：

                   成员变量：有变量，也有常量。

                   构造方法：有构造方法，用于子类访问父类数据的初始化。

                   成员方法：有抽象方法，也有非抽象方法。

            注意：

                   抽象类不能与以下几个关键字共存。

                 a：final，final修饰的方法不能被重写，而abstract修饰的方法必须被重写，冲突。

                 b：private,private修饰的方法不能被重写，而abstract修饰的方法必须被重写，冲突。

                 c：static，static修饰的方法可以直接通过类名调用，而abstract修饰的方法，没有方法体，调用没有意义。

          实现继承：

                    分析：从具体到抽象。

                    实现：从抽象到具体。

                  

                    学习：抽象的内容，因为它定义的是共性的内容。

                    使用：具体的内容，因为它才是具体的实现，才能实现更多的功能。

接口：

       当一个类中的方法都是抽象的时候，Java推荐了一种更抽象的方式，叫接口。

       特点：

                 a：接口用interface修饰。

                 b：子类实现接口用implements标识。

                 c：接口不能被实例化。

                 d：子类实现接口的时候，要么子类也是抽象类，要么全部实现接口的方法。

       思想特点：

                 a：对外暴露的规则。

                 b：程序的扩展功能。（多态）

                 c：降低程序的耦合性。（多态）

                          高内聚

                          低耦合

                          效率与安全

                 d：让类可以多实现。    

       成员特点：

               成员变量： 是常量，默认修饰符：public static final

               成员方法：是抽象方法，默认修饰符:public abstract

       接口和抽象类的区别：

               共性：都是不断抽取出来抽象的内容。

                     成员特点：

                                 抽象类：

                                           成员变量：可以是常量，可以是变量。

                                           构造方法：有。

                                           成员方法：可以是抽象方法，也可以是非抽象方法。

                                 接口：

                                           成员变量：只能是常量。

                                           成员方法：只能是抽象方法。

                                           无构造方法。

                    继承和实现关系：

                               a：类与类的关系：

                                           继承关系，只能单继承，可以多层继承。

                               b：类与接口的关系：

                                           实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

                               c：接口与接口的关系：

                                           继承关系，可以单继承，也可以多继承。

                    设计区别：

                                抽象类中定义的体系是共性，表达的是：is a的关系。

                                接口定义的体系是扩展性，表达的是：like a 的关系。

内部类：

          把类定义在一个类的内部。

          特点：

                内部类可以直接使用外部类，包括私有。

                外部类要使用内部类，必须要创建对象调用。

           内部类分类：

                 成员内部类：定义在类中，方法外的内部类。

                                 private：为了数据安全。

                                 static：为了方便调用。

                 局部内部类：定义在方法中的内部部类。

          匿名内部类：

                      a：没有名字的内部类。其本质是一个对象。

                      b：前提，存在一个抽象类或者接口。

                      c：格式：

                                   new 抽象类名或接口(){

                                           重写父类方法;

                                   };

               本质：是一个继承了类或者实现接口的子类匿名对象。

 

关键字：

        private：

              私有的意思，可以修饰成员变量、构造方法、成员方法。

              被private修饰的成员只能在本类中访问。

              怎么赋值给被private修饰的成员：

                          a：同过setXxx()和getXxx()方法。

                          b：通过构造方法

        this：

              代表当前类的对象，谁调用，就代表谁。

              应用场景：

                  a：解决局部变量隐藏成员变量。

                  b：在本类的构造方法中调用本类的构造方法（只能放在第一条语句）。

        super：代表父类空间存储标识，可以理解为对父类引用。

        final：

              最终的意思，它可以修饰类，成员方法，变量。

              特点：

                   它修饰的类不能被继承。

                   它修饰的成员方法不能被重写。

                   它修饰的变量是常量。

            注意：

                final修饰的基本数据类型的值不能被改变。

                final修饰的引用类型，地址值不能改变，对象内容可以改变。

        abstract：抽象的意思，可以修饰成员方法和类。

        interface：接口的意思。

        extends：继承的关键字，让类与类之间产生了联系，是多态的前提 。

        implements：实现接口的关键字。

        static：

             表示静态的意思。

             可以修饰成员变量和方法。

             特点：

                  a：随着类的加载而加载。

                  b：优先于对象而存在。

                  c：被所有对象共享。

                  d：可以直接通过类名直接调用。

                       静态修饰的内容，即可以通过类名调用，也可以通过对象调用。

             注意：

                  a：静态只能访问静态。 因为静态方法和变量在类加载时就存在，非静态变量在对象存在时才存在。

                  b：随着类加载而存在，生命周期长，占用资源，效率低。

                  c：静态方法中不可定义this,super关键字。因为静态优先于对象存在，所以静态方法不可以出现this。

             应用场景：

                  a：被所有对象访问的数据。节省空间，没必要为每个对象单独存储。

                  b：工具类，方便直接通过类名调用。

            main方法的解释 ：

                public static void main(String [] args)

                  public：公共的，足够的访问权限。

                  static：静态的，为了不创建对象，直接调用。

                  void：返回給JVM没有意义。

                  main：主方法，程序入口，是标准规范。

                  String [] args：早期为了接收键盘数据，现在被Scanner替代。

             静态成员变量与成员变量的区别：

                  a:在类中的初始化值的过程是一样的。

                  b:在内存中的位置：

                        成员变量：在堆中。

                        静态成员变量：在方法区的静态区。

                  c:生命周期：

                        成员变量：随着对象的创建而存在，随着对象的消失而消失。

                        静态成员变量：随着类的加载而存在，随着类的消失而消失。

                  d:设计和调用的区别:

                        设计：

                            成员变量：每个对象是独立的特征。

                            静态成员变量：所有对象是共享的特征。

                        调用：

                            成员变量：只能通过对象调用。

                            静态成员变量：可以通过类名直接调用，也可以通过对象调用。

 

权限修饰符：

 

                             本类                同一包下            不同包下的子类             不同包下的无关类

private                     y

default                     y                      y                           

protected                 y                      y                          y

public                       y                      y                          y                                       y

 

---

  权限修饰符的组合以及常见使用

                               类                  成员变量               构造方法                         成员方法        

private                                              y                           y                                     y

default                     y                       y                           y                                     y

protected                                         y                           y                                     y

public                       y                      y                           y                                     y

abstract                   y                                                                                          y

final                         y                       y                                                                 y

static                                                y                                                                 y