java之static和final精选

Posted 磊哥的Java历险记

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java之static和final精选相关的知识，希望对你有一定的参考价值。

前言：

我们上一篇讲到了this，super和代码块，这一篇我们聊一下static final，文章中每一条概念都会配上演示代码和代码截图还有结果，希望能给兄弟们带来帮助！

java之static和final精选_final

一.介绍

    static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

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

    final是java中的一个关键字，可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。如果一个类的域被关键字final所修饰，它的取值在程序的整个执行过程中将不会改变。

    假如说整个类都是final，就表明自己不希望从这个类继承，或者不答应其他任何人采取这种操作。换言之，出于这样或那样的原因，我们的类肯定不需要进行任何改变；或者出于安全方面的理由，我们不希望进行子类化（子类处理）。

除此以外，我们或许还考虑到执行效率的问题，并想确保涉及这个类各对象的所有行动都要尽可能地有效。

二.知识点介绍

1、static

2、final

3、static和final一起使用

三.节点详解

1、static

1.1、修饰成员变量

    在我们平时的使用当中，static最常用的功能就是修饰类的属性和方法，让他们成为类的成员属性和方法，我们通常将用static修饰的成员称为类成员或者静态成员，这句话挺起来都点奇怪，其实这是相对于对象的属性和方法来说的。

代码演示:

package com.Test;

public class Person 
        String name;
        int age;

        /*自定义的toString()方法不能够传入参数，并且必须返回一个字符串。定义的toString可以返回我们任何需要的值*/
        public String toString() 
            return "Name:" + name +
                    ", Age:" + age;
        

        public static void main(String[] args) 
            //对象一
            Person p1 = new Person();
            p1.name = "磊哥";
            p1.age = 25;
            //对象二
            Person p2 = new Person();
            p2.name = "java历险记";
            p2.age = 4;
            System.out.println(p1);
            System.out.println(p2);

java之static和final精选_java_02

1.2、修饰成员方法

static的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的。static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用：

代码演示：

package com.Test;

public class Person 

        public static void print(Object o)
            System.out.println(o);
        

        public static void main(String[] args) 
            Person.print("磊哥的java历险记");

java之static和final精选_java_03

1.3、静态块

在说明static关键字的第三个用法时，我们有必要重新梳理一下一个对象的初始化过程。以下面的代码为例：

代码演示：

package com.Test;

public class Person 


    class Book
        public Book(String msg) 
            System.out.println(msg);
        
    

    class PersonTwo 

        Book book1 = new Book("book1成员变量初始化");
        static Book book2 = new Book("static成员book2成员变量初始化");

        public PersonTwo(String msg) 
            System.out.println(msg);
        

        Book book3 = new Book("book3成员变量初始化");
        static Book book4 = new Book("static成员book4成员变量初始化");

        public static void main(String[] args) 
            PersonTwo p1 = new PersonTwo("p1初始化");

java之static和final精选_代码_04

1.4、静态导包

相比于上面的三种用途，第四种用途可能了解的人就比较少了，但是实际上它很简单，而且在调用类方法时会更方便。以上面的“PrintHelper”的例子为例，做一下稍微的变化，即可使用静态导包带给我们的方便：

代码演示：

/*
PrintHelper.java文件
*/
package com.Test;

public class PrintHelper 

        public static void print(Object o)
            System.out.println(o);
        
    
package com.Test;



import static com.Test.PrintHelper.print;

public class Main 

       public static void main(String[] args) 
              print("磊哥的java历险记");

java之static和final精选_java_05

2、final

    在java中，final的含义在不同的场景下有细微的差别，但总体上来说，它指的是“这是不可变的”。下面，我们来讲final的四种主要用法。

2.1、修饰数据

在编写程序时，我们经常需要说明一个数据是不可变的，我们成为常量。在java中，用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。更重要的是，final会告诉编译器，这个数据是不会修改的，那么编译器就可能会在编译时期就对该数据进行替换甚至执行计算，这样可以对我们的程序起到一点优化。不过在针对基本类型和引用类型时，final关键字的效果存在细微差别。举个例子：

代码演示：

package com.Test;

public class PrintHelper 

    static class Value 
        int v;
        public Value(int v) 
            this.v = v;
        
    

    public static class FinalTest 

        final int f1 = 1;
        final int f2;

        public FinalTest() 
            f2 = 2;
        

        public static void main(String[] args) 
            final int value1 = 1;
            // value1 = 4;
            final double value2;
            value2 = 2.0;

            final Value value3 = new Value(1);
            value3.v = 4;

2.2、修饰方法参数

    前面我们可以看到，如果变量是我们自己创建的，那么使用final修饰表示我们只会给它赋值一次且不会改变变量的值。那么如果变量是作为参数传入的，我们怎么保证它的值不会改变呢？这就用到了final的第二种用法，即在我们编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，我们不会（实际上是不能）改变参数的值：

代码演示：

package com.Test;
public class Main 

              public void finalFunc(final int i, final PrintHelper p) 
                     // i = 5; 不能改变i的值
                     // v = new Value(); 不能改变v的值
                    p.name = "磊哥的java历险记"; // 可以改变引用对象的值
              
       
    class Test4 
              public static void main(String[] args) 

                     new Test4().f1(2);
                   
              

              public void f1(final int i) 
                     //i++;    //i是final类型的,值不允许改变的.
                     System.out.print(i);

java之static和final精选_代码_06

2.3、修饰方法

第三种方式，即用final关键字修饰方法，它表示该方法不能被覆盖。这种使用方式主要是从设计的角度考虑，即明确告诉其他可能会继承该类的程序员，不希望他们去覆盖这个方法。这种方式我们很容易理解，然而，关于private和final关键字还有一点联系，这就是类中所有的private方法都隐式地指定为是final的，由于无法在类外使用private方法，所以也就无法覆盖它。

代码演示：

class A
        public
final void a()
     
    
    class A1 extends A
       public final void a()//不可以

java之static和final精选_代码_07

代码演示：

package com.Test;



public class Test 

        public static void main(String[] args) 
            //TODO 自动生成方法存根
        
        public void f1() 
            System.out.println("f1");

        
        //无法被子类覆盖的方法
        public final void f2() 
            System.out.println("f2");

        
        public void f3() 
            System.out.println("f3");

        
        private void f4() 
            System.out.println("f4");

        
    
    //继承Test
    class Test2 extends Test 

        public void f1()
            System.out.println("Test父类方法f1被覆盖!");
        

        /*public void f2()
            System.out.println("Test父类方法不能被f2被覆盖!");
        */

        public void f3()
            System.out.println("Test父类方法f3被覆盖!");
        



        public static void main(String[] args) 
            Test2 t=new Test2();
            t.f1();
            //调用从父类继承过来的final方法
            t.f2();
            //调用从父类继承过来的方法
            t.f3();
            //调用失败，无法从父类继承获得
            //t.f4();

java之static和final精选_代码_08

java之static和final精选_static_09

2.4、修饰类

    了解了final关键字的其他用法，我们很容易可以想到使用final关键字修饰类的作用，那就是用final修饰的类是无法被继承的。

final class A

3、static和final一起使用

（1）static final用来修饰成员变量和成员方法，可以理解为“全局变量”

（2）对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

（3）对于方法，表示不可覆盖，并且可以通过类名直接访问。

注意：

对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象。

代码演示：

package com.Test;


import java.util.ArrayList;

public class Test 
    private static final String strStaticFinalVar = "磊哥的java历险记";
    private static String strStaticVar = null;
    private final String strFinalVar = null;
    private static final int intStaticFinalVar = 0;
    private static final Integer integerStaticFinalVar = new Integer(8);
    private static final ArrayList<String> alStaticFinalVar = new ArrayList<String>();

    private void test() 
        System.out.println("-------------值处理前----------");

        System.out.println("strStaticFinalVar=" + strStaticFinalVar + "");

        System.out.println("strStaticVar=" + strStaticVar + "");
        System.out.println("strFinalVar=" + strFinalVar + "");

        System.out.println("intStaticFinalVar=" + intStaticFinalVar + "");

        System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "");
        System.out.println("alStaticFinalVar=" + alStaticFinalVar + "");
        //错误，final表示终态,不可以改变变量本身.
        //strStaticFinalVar="哈哈哈哈";
        //正确，static表示类变量,值可以改变
        strStaticVar = "_51博客";
        //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
        //strFinalVar="呵呵呵呵";
        //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
        //intStaticFinalVar=2;
        //integerStaticFinalVar=new
        //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
        //Integer(8);
        //正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
        alStaticFinalVar.add("aaa");
        //正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
        alStaticFinalVar.add("bbb");
        System.out.println("-------------值处理后----------");

        System.out.println("strStaticFinalVar=" + strStaticFinalVar + "");
        System.out.println("strStaticVar=" + strStaticVar + "");
        System.out.println("strFinalVar=" + strFinalVar + "");
        System.out.println("intStaticFinalVar=" + intStaticFinalVar + "");
        System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "");
        System.out.println("alStaticFinalVar=" + alStaticFinalVar + "");
    
    public static void main(String args[])
    
        new Test().test();

java之static和final精选_java_10

java之static和final精选_代码_11

结语：

只有向前不断行走，才能有始有终。当你想要放弃的时候，就想想一开始你是怎样的拼尽全力；当你想要逃避的时候，就回头看看当初那个坚定执着的你。 

 我从不知道顺其自然有多自然，但我知道现实有多现实。

感谢兄弟们的持续关注！

java之static和final精选_static_12



以上是关于java之static和final精选的主要内容，如果未能解决你的问题，请参考以下文章

java之StringBuilder和stringbuffer精选

java之基础算法精选

java之Calender类精选

java之String类精选

Java中，static成员可以被继承吗？

java之增强for和迭代器精选