java中的访问控制符、构造器、this、super、final关键字、代码块总结

1访问控制符

      Java提供了3个访问控制符：private、protected、public，分别代表了3个访问控制级别，另外还有一个不加任何访问控制符的的访问控制级别。

	public	protected	default	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

         Private：表示私有的，表示类访问权限。只能在本类中访问，离开本类之后就不能访问；
         Default（缺省）：表示包私有，表示包访问权限，访问者的包必须和当前类的包相同才行；

         Protected：表示子类访问权限，同包中的可以访问，即使不同包，但有继承关系也可以访问；

         Public：全局的，公共的访问权限，在项目的任何地方都可以访问。

      访问控制符使用原则：

           1)类里的绝大部分成员变量都应该使用private修饰，只有一些static修饰的、类似全局变量的成员变量，才可能考虑使用public修饰。除此之外，有些方法只用于辅助实             现该类的其他方法，这些方法被称为工具方法，工具方法也应该使用private修饰。

          2)如果某个类主要用做其他类的父类，该类里包含的大部分方法可能仅希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。

          3)希望暴露出来给其他类自由调用的方法应该使用public修饰。因此，类的构造器通过使用public修饰，从而允许在其他地方创建该类的实例。因为外部类通常都希望被             其他类自由使用，所有大部分外部类都使用public修饰。

2.包的声明与访问

   2.1  包的概念

          java的包，其实就是文件夹，包里存放的是类文件。当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。

          类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。

   2.2  包的声明格式

          通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接

          类中包的声明格式：

                  package 包名.包名.包名…;

          注意：声明包的语句，必须写在程序有效代码的第一行（注释不算），即在声明包package后，定义所有类class前，使用导包import包名.包名.类名;

   2.3  包的访问

        在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。

                 包名.包名….类名

         如：java.util.Scanner

                 java.util.Random

         带有包的类，创建对象格式：包名.类名变量名 = new包名.类名();

         前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。

     2.4   import导包

         通过import导包的方式可以使用该类，可以避免使用全类名编写（即，包类.类名）。

         导包的格式：import 包名.类名;

         import的作用：使用import可以省略写包名；（使用import static可以连类名都省略）

         Java默认为所有源文件导入java.lang包下所有类，因此在java程序中使用String、System类时都无需使用import语句来导入这些类。

     2.5  java的常用包

          java.lang:该包下包含了java语言的核心类，如String、Math、System类等。使用这个包下的类无需使用import语句导入，系统会自动导入这个包下所有类；

          java.util:该包下包含了java的大量工具类/接口和集合框架类/接口，如Arrays和List 、Set等；

          java.net:该包下包含了一些java网络编程相关的类/接口；

          java.io:该包下包含了一些java输入输出编程相关的接口/类；

          java.text:该包下包含了一些java格式化相关的类；

          java.sql:该包下包含了java进行JDBC数据库编程的相关类/接口；

          java.awt:该包下包含了抽象窗口工具集的相关类/接口；

          java.swing:该包下包含了Swing图形用户界面编程的相关类/接口。

3.构造器

      3.1构造器概述

           构造器是一个特殊的方法，这个特殊的方法用于创建对象和初始化对象数据。

           构造方法的格式：

                   修饰符 构造方法名(参数列表)

                   {

                   }

      3.2构造器的特点:

           类都有一个默认构造器,当不显示的定义构造器的时候,编译器会在编译的时候,提供一个默认构造器.

                  1):构造器的名字必须和当前所在类的类名相同.

                  2):不需要定义返回值类型,更加不能使用void作为返回.构造器的目的在于创建和返回当前类的对象,即使要编写返回类型,也应该是当前类名,如:Student Student(){},            既然和当前类名相同,就规定统统省略.

                  3):构造器中不需要使用return来返回当前构造的对象.

       3.3默认构造器:

           1):无参数,无方法体.

           2):构造器的访问修饰符和当前类的修饰符相同(是否有public).

           3):一旦在类中显示地提供了构造器,则默认的构造器就不再提供了.

           一个类至少有一个构造器(即使没有自定义,编译器也会创建一个默认的).但一旦程序员提供了自定义的构造器，系统就不再提供默认的构造器。

       3.4方法重载与构造器重载的区别

            方法的重载:在同一个类中,方法同名,但是参数列表不同.解决了相同的功能方法,因为参数列表不同,而带来参数名不同的问题.

            构造器重载:不同类的构造器是不相同的. 对于构造器重载来说,肯定是在同一个类中,并且构造器都是和类名相同.所以在同一个类中的多个构造器就必须参数列表不同 (参数类型,参数个数,参数顺序).

         为了在构造器中调用另一个构造器的初始化代码，又不会重新创建一个java对象，可以使用this关键字来调用相应的构造器。使用this调用另一个重载的构造器只能在构造器中使用，而且必须作为构造器执行体的第一条语句。使用this调用重载的构造器时系统会根据this后括号里的实参来调用形参列表与之对应的构造器。

4.this关键字

      4.1 this概述

             this表示当前对象。当一个对象创建之后,JVM会分配一个引用自身的引用:this

             this主要存在的两个位置:

                 构造器中:  表示当前创建的对象.

                 方法中:  哪一个对象调用this所在的方法,那么此时this就表示哪一个对象.

      4.2 this调用构造方法

            构造方法之间的调用，可以通过this关键字来完成。构造方法调用格式：this(参数列表);

            构造方法的调用

    class Person {
         //Person的成员属性
         privateint age;
         privateString name;
         //无参数的构造方法
         Person(){
         }
         //给姓名初始化的构造方法
         Person(Stringnm) {
                  name= nm;
         }
         //给姓名和年龄初始化的构造方法
         Person(Stringnm, int a) {
                  //调用其他构造方法，需要通过this关键字来调用
                  this(nm);
                  //给年龄初始化
                  age= a;
         }
    }

     4.3   成员变量和局部变量同名问题

            当在方法中出现了局部变量和成员变量同名的时候，那么在方法中可以在成员变量名前面加上this.来区别成员变量和局部变量

   class Person {
         privateint age;
         privateString name;
 
         //给姓名和年龄初始化的构造方法
         Person(Stringname, int age) {
                  this.name= name;
                  this.age= age;
         }
 
         publicvoid speak() {
                  System.out.println("name="+ this.name + ",age=" + this.age);
         }
    }
 
    class PersonDemo {
         publicstatic void main(String[] args) {
                  Personp = new Person("薛之谦", 32);
                  p.speak();
         }
    }

        对于static修饰的方法而言，可以使用类来直接调用该方法，如果在static修饰的方法中使用this关键字，则这个关键字就无法指向合适的对象。所以static修饰的方法中不能使用this引用。

5.super关键字

     5.1 super概述

         Super是java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法。正如this不能出现在static修饰的方法中一样，super也不能出现在static修饰的方法中。如果在构造器中使用super，则super用于限定该构造器初始化的是该对象从父类继承得到的实例变量，而不是该类自己定义的实例变量。

         如果子类里没有包含和父类同名的成员变量，那么在子类实例方法中访问该成员变量时，则无须显式使用super或父类名作为调用者。如果在某个方法中访问名为a的成员变量，但没有显式指定调用者，则系统查找a的顺序为：

         1)查找该方法中是否有名为a的局部变量；

         2)查找当前类中是否包含名为a的成员变量；

         3)查找a的直接父类中是否包含名为a的成员变量，依次上溯a的所有父类，直到java.lang.Object类，如果最终不能找到名为a的成员变量，则系统出现编译错误。

     5.2子父类中构造方法的调用

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

        格式：

               调用本类中的构造方法

               this(实参列表);

               调用父类中的空参数构造方法

               super();

               调用父类中的有参数构造方法

               super(实参列表);

           子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作，然后才可以使用父类中的内容。

           当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

           示例：

public class Test {
    publicstatic void main(String[] args) {
        newZi();
    }
   
}
class Fu{
    int num ;
    Fu(){
        System.out.println("Fu构造方法"+num);
        num =4;
    }
}
class Zi extends Fu{
    Zi(){
        //super(); 调用父类空参数构造方法
        System.out.println("Zi构造方法"+num);
    }
}

执行结果：　　

             Fu构造方法0

　　     Zi构造方法4

    5.3子类对象创建过程的细节

          使用super调用父类构造器和使用this调用构造器很像，区别在于super调用的是其父类的构造器，而this调用的是同一个类中重载的构造器。因此，使用super调用父类构造器也必须出现在子类构造器执行体的第一行，所以super调用和this调用不会同时出现。

          不管是否使用super调用来执行父类构造器的初始化代码，子类构造器总会调用父类构造器一次。子类构造器调用父类构造器分如下情况：

          (1)子类构造器执行体的第一行使用super显式调用父类构造器，系统将根据super调用里传入的实参列表调用父类对应的构造器。

          (2)子类构造器执行体的第一行代码使用this显式调用本类中重载的构造器，系统将根据this调用里传入的实参列表调用本类中的另一个构造器。执行本类中另一个构造器时即会调用父类构造器。

          (3)子类构造器执行体中既没有super调用，也没有this调用，系统将会在执行子类构造器之前，隐式调用父类无参数构造器。

注意：

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

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

6.static关键字

        static关键字是静态修饰符，一般用来修饰类中的成员。

     6.1static特点

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

class Demo {
         publicstatic int num = 100;
}
 
class Test {
         publicstatic void main(String[] args) {
                  Demod1 = new Demo();
                  Demod2 = new Demo();
                  d1.num= 200;
                  System.out.println(d1.num);//结果为200
                  System.out.println(d2.num);//结果为200
         }
}
 

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

               访问静态成员的格式：

                   类名.静态成员变量名

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

                   对象名.静态成员变量名        

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

                 

class Demo {
         //静态成员变量
         publicstatic int num = 100;
         //静态方法
         publicstatic void method(){
                  System.out.println("静态方法");
         }
}
class Test {
         publicstatic void main(String[] args) {
                  System.out.println(Demo.num);
                  Demo.method();
         }
}

static注意事项:

                (1) 静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区。

                (2)同一个类中，静态成员只能访问静态成员

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

      6.2定义静态常量

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

             定义格式：

                   publicstatic final 数据类型 变量名 = 值;

             如下演示：

             classCompany {

                       public static final String COMPANY_NAME= "演员";

                       public static void method(){

                                  System.out.println("我好像在哪见过你");

                       }

             }

            当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。

注意：

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

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

            interfaceInter {

                     public static final int COUNT = 100;

            }

         访问接口中的静态变量

          Inter. COUNT

7.final关键字

        final可用于修饰类、变量和方法。Final修饰变量时，表示该变量一旦获得了初始值就不可被改变，final既可以修饰成员变量（包括类变量和实例变量），也可以修饰局部变量、形参。

    7.1final的特点

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

          class Y {}

           final class Fu extendsY{} //可以继承Y类

           class Zi extends Fu{} //不能继承Fu类

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

              class Fu {

                  // final修饰的方法，不可以被覆盖，但可以继承使用

                   public final void method1(){}

                   public void method2(){}

             }

            class Zi extends Fu {

             //重写method2方法

             public final void method2(){}

             }

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

              final int i = 20;

               i= 30; //赋值报错，final修饰的变量只能赋值一次

          (4)引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。

              final Person p = new Person();

              Person p2 = newPerson();

              p = p2; //final修饰的变量p，所记录的地址值不能改变

              p.name = "小明";//可以更改p对象中name属性值

              p不能为别的对象，而p对象中的name或age属性值可更改。

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

              class Demo {

                     //直接赋值

                     finalint m= 100;

                     //final修饰的成员变量，需要在创建对象前赋值，否则报错。

                     finalint n;

                     publicDemo(){

                    //创建对象时所调用的构造方法中，为变量n赋值

                    n = 2018;

                   }

              }

     7.2 不可变类

             不可变类指的是创建该类实例后，该实例的实例变量是不可改变的。Java提供的8个包装类和java.lang.String类都是不可变类。如果需要创建自定义的不可变类，可遵守如下规则：

               (1)使用private和final修饰符来修饰该类的成员变量；

               (2)提供带参数的构造器，用于根据传入参数来初始化类里的成员变量；

               (3)仅为该类的成员变量提供getter方法，不要为该类的成员提供setter方法，因为普通方法无法修改final修饰的成员变量；

               (4)如果有必要，重写Object类的hashCode和equals方法。

总结：

           (1)final修饰的成员变量一旦有了初始值就不能被重新赋值，如果既没有在定义成员变量时指定初始值，也没有在初始化块、构造器中为成员变量指定初始值，那么这些成员变量的值将由系统默认指定(java语法规定：final修饰的成员变量必须由程序员显式的指定初始值)；

           (2)final修饰局部变量时既可以在定义时指定初始值，也可以不指定初始值。如果final修饰的局部变量在定义时没有指定默认值，则在后面代码中可以为该final变量赋初始值，但只能一次，不能重复赋值；

           (3)当使用final修饰基本类型变量时，不能对基本类型变量重新赋值，但对引用类型变量而言，它保存的仅仅是个引用，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以改变；

8.代码块

        8.1局部代码块

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

             特点：

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

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

         8.2构造代码块

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

             特点：

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

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

         8.3静态代码块

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

             特点：

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

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

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