final与 static的区别;static代码块以及嵌套类介绍

本篇文章主要分为两个模块进行介绍：1.final，staic，static final之间的异同；2. static 模块；3.嵌套类的概念

1.final，staic，static final之间的异同：

（1）final

 final可以修饰属性，方法，类，局部变量（静态变量、实例变量和局部变量）；

其中，final修饰的属性表明是个常量，它的初始化可以在编译期，也可以在运行期，初始化后不能被改变；

final修饰的属性跟具体对象有关，在运行期初始化的final属性，不同对象可以有不同的值；

final修饰的方法不能被子类方法覆盖，但可以被继承；

private不能被子类方法覆盖，private类型的方法默认是final类型的

final修饰的类不能被继承，没有子类，final类中的方法默认是final的

final不能用于修饰构造方法；

另外,对于基本类型数据，final会将值变为一个常数（创建后不能被修改）；但是对于对象句柄（亦可称作引用或者指针），final会将句柄变为一个常数（进行声明时，必须将句柄初始化到一个具体的对象。而且不能再将句柄指向另一个对象。但是，对象的本身是可以修改的。这一限制也适用于数组，数组也属于对象，数组本身也是可以修改的。方法参数中的final句柄，意味着在该方法内部，我们不能改变参数句柄指向的实际东西，也就是说在方法内部不能给形参句柄再另外赋值）。

（2）static

static表示“全局”或者“静态”的意思，可以用来修饰：属性，方法，代码段，内部类（静态内部类或嵌套内部类），static不可以修饰局部变量。

其中，static修饰的属性的初始化在编译期（类加载的时候），初始化后能改变，并且每个对象都只有一个值，主要强调它们只有一个。

static修饰的属性、方法、代码段跟该类的具体对象无关，不创建对象也能调用static修饰的属性、方法等，

static和“this、super”势不两立，因为this、super正好跟具体对象有关。

也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static属性和方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

 其中：

- 类成员变量

  - 静态变量（类变量）: static修饰

  - 实例变量  : 无static修饰

  - 局部变量 ：（方法内部声明）

（3）static final(等价于final staic，但是一般习惯staic在前)

static修饰的属性强调它们只有一个，final修饰的属性表明是一个常数（创建后不能被修改）。static final修饰的属性表示一旦给值，就不可修改，并且可以通过类名访问。static final也可以修饰方法，表示该方法不能重写，可以在不new对象的情况下调用

 

2.static{}代码块与普通{}代码块的区别

在类中，可以将某一块代码声明为静态的，这样的程序块叫静态初始化段。静态代码块的一般形式如下：

//静态代码块
static {
  语句序列
}

//普通代码
{
  语句序列
}

其中，静态代码块只能定义在类里面，它独立于任何方法，不能定义在方法里面。

静态代码块里面的变量都是局部变量，只在本块内有效。

静态代码块会在类被加载时自动执行，而无论加载者是JVM还是其他的类。

一个类中允许定义多个静态代码块，执行的顺序根据定义的顺序进行。

静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许它使用实例成员变量，所以它也不能调用实例方法。基于同样的道理，静态方法中也不能使用关键字this。main()方法是一个典型的静态方法，它同样遵循一般静态方法的规则，所以它可以由系统在创建对象之前就调用。

例子1：

public class staticBlock{
//定义一个普通的main()方法
public static void main(String args[]){
System.out.println("This is main method.");  
}
//定义一个静态代码块
static{
System.out.println("This is static block.");
int stVar = 0;   //这是一个局部变量，只在本块内有效
}
}

运行结果：

This is static block.
This is main method.　

从以上输出结果中可以看出，静态代码块甚至在main方法之前就被执行。在main()方法中可以完成的任务在静态代码块中都可以完成。但是二者在执行上仍然有一些区别。

例子2：

public class staticBlock{
static int stMember = 100;    //定义静态成员变量
public static void main(String args[]){
System.out.println("This is main method.");
}
//第一个静态代码块
static{
System.out.println("This is first static block.");
stMember  = 200;      //访问静态成员变量
staticBlock oa = new staticBlock(); //创建对象
System.out.println("stMember = " + oa.stMember);
statFun();        //调用静态方法
}
//定义一个静态方法
static void statFun(){
System.out.println("This is a static method.");
} 
//第二个静态代码块
static{
System.out.println("This is second static block.");
}
}

运行结果如下：

This is first static block.
stMember = 200
This is a static method.
This is second static block.
This is main method.

 

静态代码块与普通代码块的差异如下：

相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，

　　　　一般在代码块中对一些static变量进行赋值。

不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。

　　　　静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new

　　　　一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。

例子：

//普通类
public class PuTong {
    public PuTong(){
        System.out.print("默认构造方法！-->");
    }
    
    //非静态代码块
    {
        System.out.print("非静态代码块！-->");
    }
    
    //静态代码块
    static{
        System.out.print("静态代码块！-->");
    }
    
    public static void test(){
        {
            System.out.println("普通方法中的代码块！");
        }
    }
}

//测试类
publicclass TestClass {
    
    /**
     * 区别两次new静态与非静态代码块执行情况
     */
    public static void main(String[] args) {
        PuTong c1 = new PuTong();
        c1.test();
        
        PuTong c2 = new PuTong();
        c2.test();
    }
}

/*
运行输出结果是：
静态代码块！-->非静态代码块！-->默认构造方法！-->普通方法中的代码块！
非静态代码块！-->默认构造方法！-->普通方法中的代码块！
*/

一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的.

两者的区别就是:静态代码块是自动执行的;

静态方法是被调用的时候才执行的.

作用:静态代码块可用来初始化一些项目最常用的变量或对象;静态方法可用作不创建对象也可能需要执行的代码.

 

 

3.嵌套类概念

可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
　　其一、在一个类（外部类）中直接定义的内部类；
　　其二、在一个方法（外部类的方法）中定义的内部类；
　　其三、匿名内部类。

（1）静态嵌套类

public class StaticTest {   
        private static String name = "javaJohn";　          
　　private String id = "X001";  
　　static class Person{  
　　　　private String address = "swjtu,chenDu,China";  
　　　　public String mail = "josserchai@yahoo.com";//内部类公有成员  
　　　　public void display(){  
　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员  
　　　　　　System.out.println(name);//只能直接访问外部类的静态成员  
　　　　　　System.out.println("Inner "+address);//访问本内部类成员。  
　　　　}  
　　}  
  
　　public void printInfo(){  
　　　　Person person = new Person();  
　　　　person.display();  
　　　　//System.out.println(mail);//不可访问  
　　　　//System.out.println(address);//不可访问  
　　　　System.out.println(person.address);//可以访问内部类的私有成员  
　　　　System.out.println(person.mail);//可以访问内部类的公有成员  
  
　　}  
　　public static void main(String[] args) {  
　　StaticTest staticTest = new StaticTest();  
　　staticTest.printInfo();  
}  
} 

在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。

（2）外部内中的内部类

 public class Outer {   
         　　int outer_x = 100;  
　　　　class Inner{  
　　　　　　public int y = 10;  
　　　　　　private int z = 9;  
　　　　　　int m = 5;  
　　　　　　public void display(){  
　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
　　　　　　}  
　　　　　　private void display2(){  
　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
　　　　　　}  
　　　　}  
　　　　void test(){  
　　　　　　Inner inner = new Inner();  
　　　　　　inner.display();  
　　　　　　inner.display2();  
　　　　　　//System.out.println("Inner y:" + y);//不能访问内部内变量  
　　　　　　System.out.println("Inner y:" + inner.y);//可以访问  
　　　　　　System.out.println("Inner z:" + inner.z);//可以访问  
　　　　　　System.out.println("Inner m:" + inner.m);//可以访问  
　　　　　　InnerTwo innerTwo = new InnerTwo();  
　　　　　　innerTwo.show();  
　　　　}  
　　　　class InnerTwo{  
　　　　　　Inner innerx = new Inner();  
　　　　　　public void show(){  
　　　　　　　　//System.out.println(y);//不可访问Innter的y成员  
　　　　　　　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法  
　　　　　　　　innerx.display();//可以访问  
　　　　　　　　innerx.display2();//可以访问  
　　　　　　　　System.out.println(innerx.y);//可以访问  
　　　　　　　　System.out.println(innerx.z);//可以访问  
　　　　　　　　System.out.println(innerx.m);//可以访问  
　　　　　　}  
　　　　}  
　　　　public static void main(String args[]){  
　　　　　　Outer outer = new Outer();  
　　　　　　outer.test();  
　　　　}  
　　}  

 

以上代码需要说明有，对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响（？）。另外，就是要注意，内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量。

3.在代码块的作用域内定义内部类。

public class Outer {

    private String outerName = "This is Outer Name";

    public void test() {

        for(int i=0;i<3;i++) {
             class Inner {
                public void display() {
                    System.out.println(outerName);
                }
            }
             Inner inner = new Inner();
             inner.display();
        }
    } 
}

在上面的代码中，只能定义成class inner，不能定义成public class inner，因为此时是作为方法中的变量定义的，不是作为类的成员变量。

参考链接：

https://blog.csdn.net/qq_40665031/article/details/78440084

https://blog.csdn.net/hust_yfang/article/details/79585696

https://www.cnblogs.com/EasonJim/p/7841990.html

https://blog.csdn.net/leixiongbo/article/details/52161936

https://blog.csdn.net/WelcomeSpring/article/details/79430546