java第七章学习笔记:访问控制---java世界的卫兵

淩亂°似流年 2022-05-28 23:08 198阅读 0赞

【因为每一章都篇幅比较长（10多页，难免有的地方会写错字，如发现请指正，本人不胜感激）】

【今天看到我居然有一名粉丝，内心还是有点小激动的，之间我是一枚不是很喜欢技术的妹纸，但是从现在开始，我从被动学习开始转为主动学习，因为我想给自己一个机会，也许它就会还我一个惊喜呢。好了废话不多说了，如果有像我一样不喜欢技术的妹纸希望我能给你鼓励。↖(^ω^)↗】

【ps:因为时间有点紧，所以排版不好，后期我会调整一下】

上一章介绍了类与对象的基本用法，本章介绍如何控制类及其成员的访问权限，包括：包的使用、类的访问控制、成员的访问控制以及final的变量以及static关键字

## 7.1 包的使用 ##

在实际开发中，往往需要开发很多不同的类，能否方便高效的组织这些类对项目的开发和使用具有和重要的意义。  
提示：标准的java类库分布在多个包中，eg:java.lang,java.util等  
使用包的目的：可以在同一个项目中使用相同名称的类，本节从类的放置与导入两个方面对包及使用进行介绍。包括：

1.  声明创建包
2.  引入包内的资源
3.  静态引入

7.1.1 声明创建包  
要想将类放在指定的包中，就必须使用package语句，语法如下：  
*package<包名>;*

*  package语句必须放在源文件的最前面（有效代码第一行）
 *  每个源文件最多一句package,因为一个类不能属于两个包
 *  包名用点“.”分隔，eg:java.lang,这就表示此源文件中的类在java包下的lang子包中。
 *  在实际开发中，包可能分很多级，越复杂的系统，包越多，级也可能越多；eg:

package lixiaoxi.bupt;
    public class Test
    {
        public static void main(String[] args)
        {
            System.out.println("运行成功，我在lixiaoxi.by包中！！");
        }
    }

编译上面的代码，并将编译后的.class文件拷贝到相应的包(lixiaoxi.bupt)对应的文件夹中，即Test.class文件放到所在目录下的lixiaoxi文件中的bupt文件下，文件放置完后，其目录结构为：

![这里写图片描述][Image 1]

从上图可以看出，包实际上代表的是文件夹（目录路径）如果不将编译后的class文件放在相应的文件夹中，则无法运行。  
提示 在实际开发中会为每一个类制定具体的包。  
运行结果：  
![这里写图片描述][Image 1]  
![这里写图片描述][Image 1]  
使用命令行运行在具体包中的类时要使用全称类名，即：包名与类名顺次用“.”隔开，eg(java lixiaoxi.bupt.Test),若只是（java Test）则会报“java.lang.NoClassDefFoundError”异常  
提示：在运行程序时，要将当前目录设置为最外层的包文件夹所在的目录（即本例的lixiaoxi文件夹所在目录，而不是类文件所在目录，否则在有些情况下运行可能报错）

*  在开发中要注意不要把类文件随意拷贝到别的目录中，开发中想改变类所在的包，**一定要修改源代码重新编译**，只是拷贝、移动类文件是不对的
 *  如果没有在源文件中使用package语句，那么这个源文件中的类就被放置在一个匿名包中，匿名包是一个有名字的包，其代码编译后的类文件与源文件在同一个目录中即可
 *  注意：后面例子中有包的，不要忘记将编译后的class文件放到相应的文件，否则程序不能正常执行  
    7.1.2 引入包内的资源  
    当一个类使用与自己处于同一个包中的类————-直接访问；  
    使用其他包中的类———————import语句；语法如下：  
    import<包名>.\*;//使用指定包中的所有类，但不包括子包中的类  
    import<包名>.类名；//使用指定包中特定类
 *  包名可以是一个由“.”分隔的序列，eg:”java.lang”、“java.util”

import java.util.*;
    import java.io.InputStream;

*  import语句放在package语句之后，类声明之前
 *  import语句只是在编译的时候有作用，另外java.lang包中的类系统是自动引入的，相当于在每个源文件中系统在编译时会自动加上“import.java.lang.\*语句”  
    \-.”\*”可以导入第一层的所有类，但是若要使用多个包中的同名类就不行；
 *  两个包中有同名类，但只用到其中一个及其他不同名的类。
 *  两个包中有同名类，且都要使用  
    1、两个包中有同名类，但只用到其中一个及其他不同名的类  
    eg:java.util和java.sql包中都有名称为Date的类，在程序中要同时使用这两个包中的很多类，但只用到java.util包中的Date类：

package lixiaoxi.bupt;
    import java.util.*;
    import java.sql.*;
    public class Test { 
        public static void main(String[] args)
        {
            Date date=new Date();
            //其他使用别的类的代码省略
        }
    }

运行结果：  
The type Date is ambiguous(引起歧义)

系统报Date类匹配失败，因为在源代码中用import语句引入两个包中的所有类，两包都有Date类，系统不知道应该匹配哪一个，如果只用到java.util包中的Date类，可以将import util中修改为：

import java.util.*;
    import java.util.Date;
    import java.sql.*;

这样就不会报错了，因为系统会优先匹配import语句中明确给出类名的类；  
这就是为什么 会在别人的方法中看到已经有了.\*还要指定类名。  
2、两个包中有同名类，且都要使用  
使用两个不同包中的同名类只靠import就无法解决了，eg:将上面demo改为：

package lixiaoxi.bupt;
    import java.util.*;
    import java.util.Date;
    import java.sql.*;
    import java.sql.Date;//报错：//Date is already defined in a single-type import
    public class Test { 
        public static void main(String[] args)
        {
            Date date=new Date();//使用java.util中的Date类
            Date d1=new Date(123);//使用java.sql中的Date类
            //其他使用别的类的代码省略
        }
    }

系统报具体指定名称的同类名只能引入一次的错误，真正的解决办法是在使用同名类的地方使用全称类名eg:

package lixiaoxi.bupt;
    import java.util.*;
    import java.sql.*;
    
    public class Test { 
        public static void main(String[] args)
        {
            java.util.Date date=new java.util.Date();//使用java.util中的Date类
            java.sql.Date d1=new java.sql.Date(123);//使用java.sql中的Date类,数字的含义不必理会
            //其他使用别的类的代码省略
        }
    }

需要特别注意：不要使用星号（\*）代替包，eg:下面的导入语句是非法的。  
import java.*.*;

7.1.3 静态引入  
导入语句不但可以导入类，还具有导入静态方法和静态成员变量的功能，不过要在关键字“import”和包名之间添加关键字“static”，具体语法如下：  
*import static <包名>.<类名>.*;  
*import static <包名>.<类名>.<具体方法/成员变量名>；*

1.  “\*”代表通配符，不过这里表示的是指定类下面所有的静态方法或成员变量。
2.  如果要明确指明要使用的方法或成员变量，用第二种
3.  遇到不同类下同名静态方法或成员变量，解决冲突方式与上一小节类似；

package lixiaoxi.bupt;
    import static java.lang.System.*;//引用System类下的所有静态成员，包含方法和成员变量；
    import static java.lang.Math.sqrt;//y引用Math类下的sqrt方法（开平方）
    
    public class Test
    {
        public static void main(String[] args)
        {
            out.println("简单打印功能~~~~~");
            out.println("123.44的平方根为："+sqrt(123.44));
        }
    }

上面打印就不需要像以前一样列出方法所在的类的类名了；  
运行结果：  
![这里写图片描述][Image 1]  
实际上，没有很多开发人员使用静态引入，因为这种代码编写形式容易降低代码的可读性，造成维护困难。但是以下两个特别的地方有很实际的作用，可以简化开发。

1.  算数函数  
    \- 如果对Math类使用静态引入，就可以采用更加自然的方式在表达式中使用算数函数，eg:”pow(3,2)+sqrt(4)”比“Math.pow(3,2)+Math.sqrt(4)”看起来更清晰
2.  静态常量  
    \- 如果需要使用大量的带有繁琐的名字的静态常量，使用静态引入代码会清晰明了，eg:”MONAY”比“Calendar.MONDAY”看起来简单很多

## 7.2 类的访问控制 （public或默认不写） ##

首先了解类访问的含义：若一个类（类A）访问另一个类（类B）时，其指类A具有以下三种操作：

1.  在类A中创建类B的对象；
2.  使用类B的某些方法和成员变量；
3.  继承类B  
    类访问实际上是指：一个类对另一个类的可见性，eg:类A看不见类B,则类B中的方法和变量的访问权限对A来说就为不可访问，类的访问权限有两种：  
    公有级别访问（public类型）  
    默认访问级别（什么都不写）  
    因此，声明每个类时无论是否明确指定，其都将有一个访问控制级别；  
    7.2.1 公有访问级别  
    带有“public”修饰的类，任何包中的任何类都可以访问此访问级别的类。需注意：尽管从访问级别上其可以被任何包中的任何类访问，但是编写代码时，如果**访问其他类与其不再同一个包，依然需要引入语句或全称类名**

package bupt;
    public class Test2
    {
    }

package lixiaoxi;
    import bupt.*;
    
    class Test
    {
        public static void main(String[] args)
        {
            Test2 test=new Test2();
            System.out.println("Test2创建成功，可以访问到Test2");
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
提示：javac命令一次可以编译多个源文件，只要把编译的多个源文件用空格符分开，逐一列出即可；  
7.2.2 默认访问级别  
可以将默认访问级别看做**包访问**，因为*默认访问级别下的类只能被同一个包中的类看到，包外不可见*  
将类Test2的public去掉就看到两处错误：分别是声明引用于创建对象时都无法都无法访问类Test2,因为Test2具有默认访问级别，并与要访问类位于不同包中，可以把两个类放在同一个包中，或者将Test2设置为publlic的。  
7.2.3 类与源代码文件的搭配  
一个源代码文件中可以同时有多个类，类与源代码文件搭配的规则：

1.  **每个源代码文件**中可以有任意多个类，**但只能有一个public类**【C\#中可以多个public类】
2.  该文件名必须与public的类名完全相同（注意区分大小写），若没有public类，则可以任意命名该文件；
3.  如果类是包的一部分，包语句必须在有效代码第一行，注释和空行可以出现在任意位置；
4.  如果有引入语句，其必须位于包语句之后，第一个类声明之前，若没有包语句，引入语句必须在文件中最前面；
5.  导入语句和包语句应用于源代码文件中的所有类；eg,下面是一个合法的源代码文件：

package lixiaoxi.bupt;
    import java.util.Date;
    
    public class Test
    {
        public static void main(String[] args)
        {
            Test2 test=new Test2();
            test.show();
    
        }
    }
    class Test2
    {
        Date today=new Date();
        void show()
        {
            System.out.println(today.toString());
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
在实际开发中建议一个源代码文件一个类，并且不管此类是不是public的，文件名与该类名相同，因为在实际开发中，可能会有成千上万个类，若需要修改某一个类，那么该类的源代码文件会很容易找到

## 7.3 成员的访问控制（public，默认不写，protected,private，） ##

成员包括（方法和成员变量【java中的成员除方法和变量外还有语句块，内部类】）  
成员访问指的是什么？指以下两种不同的操作：

1.  一个类中的方法代码是否能够调用另一个类中的成员；
2.  一个类是否能继承其父类的成员；  
    注意：成员的访问权限基于类的访问权限，即若类A有权访问类B时，类B中成员的访问权限对类A才起作用（即类A能调类B，才会考虑到成员变量访问权限问题）  
    7.3.1 公共类型  
    用public:所有其他类，无论该类属于哪个包，均能访问该成员：eg:

package bupt;
    public class Test2
    {
        Date today=new Date();
        public void show()
        {
            System.out.println("成功调用了public 修饰的show方法");
        }
    }

package lixiaoxi
    import bupt.*;
    class Test
    {
        public static void main(String[] args)
        {
            Test2 test=new Test2();
            test.show();
    
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
对于继承而言，规则为：*如果父类的成员声明为public，那么无论这两个类是否在同一个包中该子类都能继承其父类的该成员*  
7.3.2 私有类型（private）  
不能被该成员所在类之外的任何类中代码访问eg:

package bupt;
    public class Test2
    {
        Date today=new Date();
        private void show()
        {
            System.out.println("成功调用了public 修饰的show方法");
        }
    }
    
    class Test
    {
        public static void main(String[] args)
        {
            Test2 test=new Test2();
            test.show();//error message:The method show() from the type Test2 is not visible
    
        }
    }

虽然两个类在同一个包中，方法show()却不能被调用，因为被设置为private，自己类以外的任何代码都是不可见的  
7.3.3 默认类型（啥也不写）  
只对与此成员所属类在同一个包中的类可见，对于同一个包中的类：默认类型相当于public，而对包外的类则相当于private

package bupt;
    public class Test2
    {
        void show()
        {
            System.out.println("成功调用了默认修饰符（不写） 修饰的show方法");
        }
    }

package lixiaoxi;
    import bupt;
    
    class Test
    {
        public static void main(String[] args)
        {
            Test2 test=new Test2();
            test.show();//The method show() from the type Test2 is not visible
    
        }
    }

从继承角度若父类的成员声明为默认类型，则包内的子类可以继承而包外的则不可以  
7.3.4 保护类型（protected）  
其规则与默认类型一样：对于同一个包中的类：默认类型相当于public，而对包外的类不是不能访问而是只有通过继承才能访问该成员  
![这里写图片描述][Image 1]  
成员访问修饰符  
提示：***访问修饰符不能用来修饰局部变量，否则将编译报错，而且局部变量作用域为局部，也没有这个必要***  
7.3.5 java中封装的实现

1.  封装的含义；
2.  封装的使用及优点；  
    
    
    1.  封装的含义：  
        把东西包起来，换言之：成员变量和方法的定义都包装于类定义之中，类定义可以看成是将构成类的成员变量和方法封装起来  
        通过限定类成员的可见性，可以使得类成员中的某些属性和方法能够不被程序的其他部分访问，被隐藏起来，只能在所定义的类中使用，这就是面对对象中实现封装的方式；
3.  封装的使用及优点：  
    尽管技术上可以把成员变量标识为public，但是在实际中最好把所有的成员变量都保持为private，如果需要修改、设置或读取该成员变量，应该使用公共的访问器方法，因此任何其他类中的代码必须通过调用方法来访问该成员变量，而不是直接使用；  
    这样有助于提高程序的灵活性，便于做代码修改和维护eg:

public class Test
    {
        public static void main(String[] args)
        {
            People test=new People();
            test.size=-5;//访问成员变量size
    
        }
    }
    class People
    {
       public int size;//身高
    }

代码中给size（身高）赋值为-5显然是错误的，但由于size是public的，这就很难避免这种错误，解决办法是为size变量编写访问器方法用private访问限制修饰符保护size变量，修改后demo为：

public class Test
    {
        public static void main(String[] args)
        {
            People test=new People();
            test.setSize(-5);//访问成员变量size
    
        }
    }
    class People
    {
       private int size;//身高
       public void setSize(int newsize)//set成员变量的set方法
       {
           if(newsize>0)
           {
               size=newsize;
           }else
           {
               System.out.println("身高必须大于0，请重新输入");
           }
       }
       public int getSize()//size成员变量的get访问器
       {
           return size;
       }
    }

运行结果：  
![这里写图片描述][Image 1]  
上面的demo对size成员变量做了封装，必须通过访问器方法设置size的值而在访问器set方法中编写了验证之正确性的规则  
提示：*学会这种思想，对成员变量进行封装，在访问方法中编写值正确性的验证规则*  
eg 由于某种原因需要将size的类型修改为String，如果没有使用封装，那么所有用到size的地方都将不能使用，很可怕；而封装以后，只需要对访问器进行一定修改，可以使外面的调用者感觉不到变化，eg:

public class Test
    {
        public static void main(String[] args)
        {
            People test=new People();
            test.setSize(185);//访问成员变量size
            System.out.println("设置的身高为："+test.getSize()+"厘米");
        }
    }
    class People
    {
       private String size;//身高
       public void setSize(int newsize)//set成员变量的set方法
       {
           if(newsize>0)
           {
               size=newsize+"厘米";
           }else
           {
               System.out.println("身高必须大于0，请重新输入");
           }
       }
       public int getSize()//size成员变量的get访问器
       {
           return Integer.parseInt(size.substring(0,size.indexOf("厘米")));//从字符串中提取出身高信息转换为整数返回
       }
    }

运行结果：  
![这里写图片描述][Image 1]  
java封装所需要遵循的规则：

1.  用访问限制符保护成员变量，通常是private；
2.  建立公有访问器方法，强制调用代码通过这些方法访问成员变量
3.  关于访问器方法，严格使用JavaBean命名规则set<成员变量>和get<成员变量>
    
    ## 7.4 final的变量 ##
    
    final能修饰很多类型的元素，而且功能含义各不相同；分几部分介绍，本节介绍final变量  
    **用final修饰的变量含义**：该变量一旦被*显示初始化*之后，其值就不能再被修改。要特别注意的是：对原始类型和引用类型的变量值不能修改的含义不完全一样；
4.  对于原始类型：一旦赋值以后，该值就不能修改；eg:final int x=10;则x的值永远保持为10；
5.  对于引用类型，一旦赋值以后，将不能重新用来引用（指向）另一个对象，然而可以修改其引用对象的成员变量，也就是说，可以修改final的引用的引用对象，但是不能修改final引用指向别的对象；简言之，没有最终的对象，只有最终的引用。  
    7.4.1 final的成员变量  
    一般情况下，不对成员变量赋初值，系统会给其默认初始值。但是对于final的成员变量，系统不会为其赋默认初始值，而是要求在构造器完成之前必须显式初始化，当然一旦初始化就不能修改。  
    提示：上面的成员变量指非静态的成员变量 eg:

class Test2//errormessage:The blank final field x may not have been initialized
    {
        final int x;//声明final成员变量
       public void showfinal()//set成员变量的set方法
       {
           System.out.println("final x="+x);
       }
    }

final变量初始化的时间只要在构造器完成之前即可；其可选时机有如下三种：

*  声明的同时进行初始化
 *  在非静态语句块中进行初始化
 *  在构造器中进行初始化 eg:

public class Test { 
        final int x1=100;//声明同时完成初始化
        final int x2;
        final int x3;
    
        {
            x2=88;//非晶态语句块中进行初始化
        }
    
        public Test()
        {
            x3=66;//构造器中初始化
        }
    
        public void showFinalX()
        {
            System.out.println("final x1的值为："+x1+",final x2的值为："+x2+",final x3的值为："+x3);
        }
        public static void main(String[] args)
        {
            Test test=new Test();
            test.showFinalX();
    
    
        }
    }

运行结果为：  
![这里写图片描述][Image 1]  
通过下面的demo来说明final引用的问题：

public class Test
    {
        final Student stu=new Student();
        public void setAge()
        {
            System.out.println("修改年龄以前的年龄为："+stu.age);
            stu.age=18;
            System.out.println("修改年龄以后的年龄为："+stu.age);
        }
        public static void main(String[] args)
        {
            Test test=new Test();
            test.setAge();
        }
    }
    class Student
    {
        int age=21;
    }

运行结果：  
![这里写图片描述][Image 1]  
从上面的程序中可以看到，final引用所指向的对象的成员变量是可以修改的。当然要修改的成员变量本身不能为final的，在第九行和第十行之间插入stu=new Student()就会报错：  
![这里写图片描述][Image 1]  
因为stu是final的，其值（对象的地址）不能被修改即指向哪一个对象是不能修改的（eg:房东就是房子对象的引用，房子里可以住不同的人（搬来搬走）但是房东与这个房子的关系不能修改）  
说明：在java中可能有多个修饰符同时修饰一个元素这多个修饰符之间可以任意交换次序：eg:下面的代码是等价的：

public final int a=10;
    final public int b=6;

int是变量类型，不是修饰符其位置不能改变  
7.4.2 final的局部变量  
被修饰final的局部变量与成员变量非常相似，不同之处是，局部final变量可以只声明不初始化，一旦初始化了值不能改变，初始化时间只要在其使用之前就行，下面demo说明局部final变量：

public static void main(String[] args)
        {
            final int x;
            System.out.println("没有为final的局部变量初始化，并已成功运行！");
        }

运行结果：  
![这里写图片描述][Image 1]  
这说明局部变量在使用之前不初始化是没问题的，在19行和21行加上两个初始化：  
![这里写图片描述][Image 1]  
提示：关于局部引用的问题，与基本数据类型一致，可以不初始化，一旦初始化不可更改即指向哪个对象是不能改变的，但其所引用对象的成员是可以修改的。

## 7.5 static关键字 ##

被static修饰过的成员与普通成员有很大的不同，Static关键字只能修饰成员，只要身份是成员都可以修饰eg:变量、方法、语句块、内部类

*  静态的成员的基本使用
 *  静态成员的访问
 *  静态最终成员变量  
    提示：访问限制修饰符对静态成员变量同样有作用，规则与前面讲的非静态的相同
    
    7.5.1 静态的成员  
    为什么要引入静态的概念？原因主要有以下两个：
 *  假定有一个实用的工具类，其中的一个方法总是以相同的方式运行，其行为与结果不依赖于对象的状态，eg:Math中的求绝对值的abs方法；因此当方法执行与对象完全无关时，就不需要创建对象，完全可以要求类自身来运行这个方法。
 *  另一种特殊情况，若想记录某个类的所有对象的个数等关于这个类的所有对象的信息，这时必须需要一个依赖于类的而不是依赖于对象的变量来记录此信息，否则将不能解决此问题；eg:依赖于对象的成员是不可能解决此问题的，因为每次创建对象时都会为其执行相同的初始化工作  
    上述以相同方式运行的实用方法以及记录同一个类所有对象的信息这两种特殊情况，都是使用static来解决的。因此，**用static关键字修饰的成员将属于类，而不属于任何特定的对象。也就是说，可以在根本没有该类任何对象的时候使用被static修饰的成员**  
    但若存在对象，静态成员将被该类的所有对象共享，只有一份拷贝，而不像非静态成员每个对象自己拥有一份拷贝eg:

public class Test
    {
        static int count=0;
        int selfCount=0;
        public Test()
        {
            count++;
            selfCount++;
        }
    
        public static void main(String[] args)
        {
            Test t1=new Test();
            Test t2=new Test();
            Test t3=new Test();
            System.out.println("静态成员变量count的值分别t1: "+t1.count+",t2: "+t2.count+",t3： "+t3.count);
            System.out.println("非静态成员变量count的值分别t1: "+t1.selfCount+",t2: "+t2.selfCount+",t3 "+t3.selfCount);
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
对于非静态成员变量selfCount，每个对象都有自己的拷贝，其属于各个对象都从0加了一次1，所以打印1；  
对于静态成员变量count属于类，类的所有对象共享一份拷贝所以三次，运行结果都为3；  
7.5.2. 静态成员的访问  
静态成员属于类，所以访问的不需要创建对象 eg:

public class Test
    {
        static int staticvar=66;
        public static void main(String[] args)
        {
            Test.staticvar=88;//使用类名点变量名调用
            System.out.println("静态成员变量staticvar的值为："+staticvar+".");//与静态成员在同一个类中可以直接使用静态成员变量名，在其他类中使用时需要用类名点变量名调用
        }
    }

同一个类中可以不用类名点静态变量名调用，但是在其他方法中就必须使用类名点静态变量名，或者是相应的对象引用，受到访问限制级别的约束。  
提示：实际开发中，提倡用类名来访问静态成员。  
运行结果：  
![这里写图片描述][Image 1]  
从下面两个方面介绍同一个类中的静态成员变量与非静态成员变量成员之间的访问。

1.  静态成员访问非静态成员
2.  非静态成员访问静态成员
3.  静态成员访问非静态成员：eg:  
    ![这里写图片描述][Image 1]  
    “无法从静态上下文中引用非静态变量staticVar”的错，这是因为main()方法是static的，而staticVar是非静态成员，如下图，因为静态成员不依赖于该类的任何对象，所以当其所在的类加载成功后，就可以访问其了，此时对象不一定存在，非静态成员自然也不一定存在，静态成员的生命周期比非静态的长：  
    ![这里写图片描述][Image 1]  
    即使访问时存在非静态成员，静态方法也不知道访问的是哪一个对象的成员，因为静态方法属于类，非静态成员属于对象，所以静态方法将不知道关于其所属类对象的信息  
    提示：main()方法被定义为静态的也是如此，其只是程序开始执行的入口，不需要依赖任何对象，若要在静态方法中访问非静态成员主要使用指向特定对象的引用即可：

public class Test
    {
        int var=66;//声明非静态变量
        public static void main(String[] args)
        {
            Test t2=new Test();
            System.out.println("成员变量var的值为："+t2.var+".");
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
![这里写图片描述][Image 1]  
而静态方法访问静态成员时，自然是任何时候都没问题，静态成员属于类只要类存在，静态成员都将存在。  
同理，静态方法中不能使用this预定义对象引用的，即使后边所操作的也是静态成员也不行，因为this代表指向自己对象的引用，而静态方法属于类不属于对象，其成功加载以后，对象还不一定存在，即使存在，也在不知道this指的是哪一个对象eg:  
![这里写图片描述][Image 1]  
系统报“无法从静态上下文中引用非静态变量this”  
2. 非静态成员访问静态成员：  
非静态访问静态成员的时候，规则很简单，非静态成员的生命周期被静态成员生命周期包含，因此，当非静态成员存在的时候，静态成员绝对存在，故非静态方法可以随时访问静态成员。eg:

public class Test
    {
        static int staticvar=66;//声明非静态变量
        public void showStaticVar()
        {
            System.out.println("非静态方法调用静态成员变量staticvar,值为："+staticvar);
        }
        public static void main(String[] args)
        {
            Test test=new Test();
            test.showStaticVar();
        }
    }

运行结果：  
![这里写图片描述][Image 1]  
7.5.3. 静态最终成员变量

*  静态最终变量的具体应用
 *  静态最终成员变量的初始化  
    1、静态最终变量的具体应用：  
    没有介绍java中如何实现常量，其实java中没有一个直接的修饰符来实现常量，而是通过静态最终成员变量的方式来实现的eg:

//声明常量xyz
        public static final int x=10;
        static public final int y=25;
        final static public int z=88;

\*1】static 属于类，不必创建对象就能使用，因为常量不依赖于任何对象，final表示值不能改变；  
2】一般用做常量的静态最终变量访问限制符都设置为public，因为常量允许所有类或对象访问\*  
其实前面的Math类中的PI与E常量就是Math类的最终成员变量  
提示：虽然java中有const关键字，但不是用来声明常量的，与C和C++不同，在java中const只是一个关键字，没有任何意义，也不能出现在源代码中  
2、静态最终成员变量的初始化【必须初始化】  
前面的非静态最终成员变量时讲过，系统不会为其分配默认值，必须在构造器完成之前对其初始化，对于**静态最终成员变量，系统也不会为其分配默认值，也必须初始化，但是其属于类，是不能等到构造器运行再初始化的因为类加载完之后其值必须可以使用**  
java中静态最终成员变量的初始化要求在静态语句块结束之前必须完成，即java中静态初始化有两个时机：

1.  在声明的同时进行初始化
2.  在静态语句块中进行初始化  
    eg:

public class Test
    {
        public static final int const1=789;//声明是完成初始化
        public static final int const2;
        static 
        {
            const2=57;//初始化常量2
        }
        public static void main(String[] args)
        {
           System.out.println("两个常量的值分别为,const1="+const1+"，const2="+const2);
        }
    }

static  
\{  
const2=57;//初始化常量2  
\}这一块称为静态语句块，也是静态成员的一种  
提示：**静态语句块在类加载的时执行一次**，可以将对类进行初始化的代码写在其中。  
运行结果：  
![这里写图片描述][Image 1]

若将static语句块中的赋值语句注释掉就会报“尚未初始化变量const2”的错误，再次给const2赋值也会提示“无法为final变量const2指定值“的错误。

![这里写图片描述][Image 1]  
必须在静态语句块完成之前对静态最终变量进行初始化。  
第七章完~~~  
![这里写图片描述][Image 1]  
【伟大的物理学家，一个有趣的人—-霍金在今天（2018年3月14号去世了），一颗伟大的恒心消失在天际。他几乎陪着我们从小学开始到整个学习生涯的结束，他的对生活的态度，对科学的执着，对人类的伟大贡献使他将永远活在我们的心中，愿他在天堂可以奔跑。】

[Image 1]: