Java笔记-面向对象之构造方法 内部类 访问修饰符 代码块

一 构造方法

1.1构造方法介绍

    在开发中经常需要在创建对象的同时明确对象的属性值，比如员工入职公司就要明确他的姓名、年龄等属性信息。

    那么，创建对象就要明确属性值，那怎么解决呢？也就是在创建对象的时候就要做的事情，当使用new关键字创建对象时，怎么给对象的属性初始化值呢？这就要学习Java另外一门小技术，构造方法。

    那什么是构造方法呢？从字面上理解即为构建创造时用的方法，即就是对象创建时要执行的方法。既然是对象创建时要执行的方法，那么只要在new对象时，知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值。

    构造方法的格式：修饰符  构造方法名( 参数列表 ){    }

    构造方法的体现：

        ①构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。

        ②构造方法名称必须和类型保持一致。

        ③构造方法没有具体的返回值。

1.2构造方法调用及内存图解

    理解构造方法的格式和基本功能之后，现在就要研究构造方法是怎么执行的呢？在创建对象的时候是如何初始化的呢？构造方法是专门用来创建对象的，也就是在new对象时要调用构造方法。现在来看看如何调用构造方法。

图解说明：

1）首先会将main方法压入栈中，执行main方法中的 new Person(23,"张三");

2）在堆内存中分配一片区域，用来存放创建的Person对象，这片内存区域会有属于自己的内存地址（0x88）。然后给成员变量进行默认初始化（name=null，age=0）。

3）执行构造方法中的代码（age = a ;name = nm;）,将变量a对应的23赋值给age，将变量nm对应的”张三赋值给name，这段代码执行结束后，成员变量age和name的值已经改变。执行结束之后构造方法弹栈，Person对象创建完成。将Person对象的内存地址0x88赋值给p2。

1.3默认构造方法及细节

    在没有学习构造方法之前，我们也可以通过new关键字创建对象，并调用相应的方法，同时在描述事物时也没有写构造方法。这是为什么呢？

    在之前学习的过程中，描述事物时，并没有显示指定构造方法，当在编译Java文件时，编译器会自动给class文件中添加默认的无参构造方法。如果在描述类时，我们显示指定了构造方法，那么，当在编译Java源文件时，编译器就不会再给class文件中添加默认构造方法。

    当在描述事物时，要不要在类中写构造方法呢？这时要根据描述事物的特点来确定，当描述的事物在创建其对象时就要明确属性的值，这时就需要在定义类的时候书写带参数的构造方法。若创建对象时不需要明确具体的数据，这时可以不用书写构造方法（不书写也有默认的构造方法）。

构造方法的细节：

    1）一个类中可以有多个构造方法，多个构造方法是以重载的形式存在的

    2）构造方法是可以被private修饰的，作用：其他程序无法创建该类的对象。

    到目前为止，学习两种方法，分别为构造方法和一般方法，那么他们之间有什么异同呢？构造方法在对象创建时就执行了，而且只执行一次。一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。

问题：

有了构造方法之后可以对对象的属性进行初始化，那么还需要对应的set和get方法吗？

答：需要相应的set和get方法，因为对象在创建之后需要修改和访问相应的属性值时，在这时只能通过set或者get方法来操作。

二 this和super关键字

2.1this概述

    在之前学习方法时，我们知道方法之间是可以相互调用的，那么构造方法之间能不能相互调用呢？若可以，怎么调用呢？在之前学习方法之间调用时，可以通过方法名进行调用。可是针对构造方法，无法通过构造方法名来相互调用。

    构造方法之间的调用，可以通过this关键字来完成。

    构造方法调用格式：this( 参数列表 );

2.2this的原理图解

    了解了构造方法之间是可以相互调用，那为什么他们之间通过this就可以调用呢？通过上面的学习，简单知道使用this可以实现构造方法之间的调用，但是为什么就会知道this调用哪一个构造方法呢？接下来需要图解完成。

图列说明：

1）先执行main方法，main方法压栈，执行其中的new Person(“张三”,23);

2）堆内存中开辟空间，并为其分配内存地址0x33，，紧接着成员变量默认初始化（name=null  age = 0）；

3）拥有两个参数的构造方法（Person（String nm , int a））压栈，在这个构造方法中有一个隐式的this，因为构造方法是给对象初始化的，那个对象调用到这个构造方法，this就指向堆中的那个对象。

4）由于Person（String nm , int a）构造方法中使用了this(nm);构造方法Person(Stringnm)就会压栈，并将“张三”传递给nm。在Person（String nm , int a）构造方法中同样也有隐式的this，this的值同样也为0x33，这时会执行其中name = nm，即把“张三”赋值给成员的name。当赋值结束后Person（String nm , int a）构造方法弹栈。

5）程序继续执行构造方法（Person（String nm , int a）中的age = a；这时会将23赋值给成员属性age。赋值结束构造方法（Person（String nm , int a）弹栈。

6）当构造方法（Person（String nm , int a）弹栈结束后，Person对象在内存中创建完成，并将0x33赋值给main方法中的p引用变量。

    注意：

    this到底代表什么呢？this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在的方法，this就代表哪个对象。

    调用其他构造方法的语句必须定义在构造方法的第一行，原因是初始化动作要最先执行。

    此外，this还有一个用途，当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量

2.3super关键字-子父类中构造方法的调用

    在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句。

    为什么子类对象创建都要访问父类中的构造方法？

    因为子类继承了父类的内容，所以创建对象时，必须要先看父类是如何对其内容进行初始化的。就是说必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

格式：

    调用本类中的构造方法：this( 实参列表 );

    调用父类中的空参数构造方法：super( );

    调用父类中的有参数构造方法：super( 实参列表 );

2.4super关键字-子类对象创建过程的细节

    如果子类的构造方法第一行写了this调用了本类其他构造方法，那么super调用父类的语句还有吗？

    这时是没有的，因为this()或者super(),都只能定义在构造方法的第一行，因为初始化动作要先执行。

    父类构造方法中是否有隐式的super呢？

    也是有的。

记住：1.只要是构造方法默认第一行都是super();

          2.对于子类中所有的构造方法，无论重载了多少个，每个构造方法第一行必须是super！！

          3.若父类有多个构造方法，任选一个调用即可。

          4.构造方法第一行写this还是super？由于不能同时存在，任选其一，保证子类的所有构造方法调用父类的构造方法即可。

         5.小结论：无论如何，子类的构造方法，或直接，或间接，必须调用父类构造方法。对于子类构造方法，什么都不写的话，默认构造方法第一行为super（）。

父类的父类是谁呢？super调用的到底是谁的构造方法呢？Java体系在设计，定义了一个所有对象的父类Object。

 注意：

    类中的构造方法默认第一行都有隐式的super()语句，在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。

    如果默认的隐式super()语句在父类中没有对应的构造方法，那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

2.5this和super小结

this关键字

    this关键字，本类对象的引用。this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用。

    this什么时候存在的？当创建对象的时候，this存在的。

    this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

            public void setName(String name) {

                this.name = name;

            }

构造方法：用来给类的成员进行初始化操作

    格式：

            修饰符 类名 (参数列表) {

            ...

            }

    构造方法的特点：

        1, 方法名与类名相同

        2，没有返回值，也没有返回值类型，连void也没有

    构造方法什么时候会被调用执行？只有在创建对象的时候才可以被调用。

super: 指的是父类的存储空间(理解为父类的引用)。

    调用父类的成员变量：super.成员变量;

    调用父类的构造方法:   super(参数);

    调用方法的成员方法:   super.成员方法();

继承中的构造方法注意事项：

    1，如果我们手动给出了构造方法，编译器不会在给我们提供默认的空参数构造方法

          如果我们没写任何的构造方法，编译器提供给我们一个空参数构造方法

    2,在构造方法中，默认的第一条语句为 super();

          它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作

     3, 当父类中没有空参数构造方法的时候，怎么办？

            a: 通过 super(参数) 访问父类有参数的构造方法

            b: 通过 this(参数) 访问本类中其他构造方法

            注意:[本类中的其他构造方法已经能够正常访问父类构造方法]

     4, super(参数) 与 this(参数) 不能同时在构造方法中存在

三 final和static关键字

3.1final概述

    继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，那怎么解决呢？

    要解决上述的这些问题，需要使用到一个关键字final，final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。

3.2final特点

    final修饰类不可以被继承，但是可以继承其他类。

    final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。

    final修饰的变量称为常量，这些变量只能赋值一次。

    修饰成员变量，需要在创建对象前赋值(直接赋值或者用构造方法赋值，不能用setXX)，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

3.3static介绍

    当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？

    可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

    被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）。

    被static修饰的成员可以并且建议通过类名直接访问。

    访问静态成员的格式：

            类名.静态成员变量名

            类名.静态成员方法名(参数)

            对象名.静态成员变量名     ------不建议使用该方式，会出现警告

            对象名.静态成员方法名(参数)    ------不建议使用该方式，会出现警告

3.4static注意事项

    静态内容是优先于对象(非静态)存在于内存中，只能访问静态，不能使用this/super。这是因为this是本类的对象引用，super是父类的对象，而静态是优于非静态的，那个时候还没有创建对象。静态修饰的内容存于静态区。

    同一个类中，静态成员只能访问静态成员。

    main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。

    该不该加static，对于成员变量看是不是大家都有的且值相同；对于方法看有没有用到静态变量或者如果类中某个方法并没有使用本类的成员变量就应该加。

总之，一般用静态调静态，非静态调非静态。

注意啦：多态的调用中，编译都看等号左边的父类，父类有则编译成功，没有编译失败；

            多态中方法：运行时，若是运行静态的方法，则调用的是父类的静态方法；对于非静态方法调用的是子类的重写方法。

            多态中成员变量：编译运行全是父类的。

    开发中，我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。

    接口中的每个成员变量都默认使用public static final修饰。

    所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问：

            interface Inter {

                    public static final int COUNT = 100;

            }

      访问接口中的静态变量：

            Inter.COUNT

四 匿名对象与内部类

4.1匿名对象

    匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

                创建一个普通对象：Person p = new Person();

                创建一个匿名对象：new Person();

    创建匿名对象直接使用，没有变量名。匿名对象在没有指定其引用变量时，只能使用一次。

                new Person().eat(); //创建一个匿名对象，调用eat方法

                new Person().eat(); //想再次调用eat方法，重新创建了一个匿名对象    

    匿名对象可以作为方法接收的参数、方法返回值使用。

4.2内部类概述

1）什么是内部类：

    将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

2）什么时候使用内部类：

    在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

                    class 汽车 {     //外部类

                            class 发动机 {     //内部类

                            }

                    }

3）内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

4.3成员内部类

    成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问。可使用成员修饰符：public  static等。

    调用规则：内部类可直接使用外部类成员，包括私有。

                    外部类要使用内部类成员，必须建立内部类对象。即依靠外部类对象，找到内部类，再通过内部类对象，调用内部类方法。

    定义格式

             class 外部类 {

                       修饰符 class 内部类 {

                            //其他代码

                        }

            }

    访问方式

            外部类名.内部类名  变量名 = new 外部类名().new 内部类名();

            变量.内部类方法();

    成员内部类代码演示。定义类，观察成员内部类中的同名变量调用：

           

    访问内部类：

           

4.4局部内部类

    局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问。

    定义格式       

    访问方式：在外部类方法中，创建内部类对象，进行访问

          

4.5内部类的实际使用--匿名内部类

    最常用到的内部类就是匿名内部类，它是局部内部类的一种。

    定义的匿名内部类有两个含义：

            临时定义某一指定类型的子类；

            定义后即刻创建刚刚定义的这个子类的对象。

    作用：匿名内部类是创建某个类型子类或实现类对象的快捷方式。

    格式：    new 父类或接口(){

                        //进行方法重写

                  };

    使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。匿名内部类如果不定义变量引用，则也是匿名对象。

        

五 访问修饰符

    在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：

        

    归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问的话

        要想仅能在本类中访问使用private修饰；

        要想本包中的类都可以访问不加修饰符即可；

        要想本包中的类与其他包中的子类可以访问使用protected修饰

        要想所有包中的所有类都可以访问使用public修饰。

    注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

    受保护权限(比较坑)，只能在子类的类里面直接用才能用，不用new，在另外类里面建对象也不能用。用法如下：

       

六 代码块

    代码块有以下几种：

         局部代码块：定义在方法中的，用来限制变量的作用范围

         构造代码块：定义在类中方法外，用来给对象中的成员初始化赋值

         静态代码块：定义在类中方法外，用来给类的静态成员初始化赋值

6.1局部代码块

    局部代码块是定义在方法或语句中。

    特点：

            以”{}”划定的代码区域，此时只需要关注作用域的不同即可；

            方法和类都是以代码块的方式划定边界的。

        

6.2构造代码块

    构造代码块是定义在类中成员位置的代码块

    特点：

            构造代码块优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作；

            每创建一个对象均会执行一次构造代码块。

               

运行结果：

6.3静态代码块

    静态代码块是定义在成员位置，使用static修饰的代码块。

    特点：

            它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

            该类不管创建多少对象，静态代码块只执行一次。

            可用于给静态变量赋值，用来给类进行初始化。

            

运行结果：测试类与6.2中例子一样