美文网首页
java关键字static和final的理解

java关键字static和final的理解

作者: 移动端_小刚哥 | 来源:发表于2018-11-30 15:00 被阅读37次

    一、static

    “static方法就是没有this的方法。在static方法内部不能调用非静态方法,反过来是可以的。而且可以在没有创建任何对象的前提下,仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

    方便在没有创建对象的情况下来进行调用(方法/变量)。
    很显然,被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问。
    static可以用来修饰类的成员方法、类的成员变量,另外可以编写static代码块来优化程序性能。

    1.1 static修饰成员方法

    static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用

    如下代码

    public class Test {
        
        private static String str1 = "staticProperty";
        private String str2 = "property";
        
        public Test(){}
        
        public void print1(){
            Log.d(str1,"");
            Log.d(str2,"");
            print2();
        }
        
        
        public static void print2(){
            Log.d(str1,"");
            Log.d(str2,""); //报错
            print1(); //报错
        }
    }
    
    1.2 static修饰成员变量

    static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。
    static成员变量的初始化顺序按照定义的顺序进行初始化

    1.3 static修饰静态代码块

    如下代码

    public class Test {
    
    
        /**
         * static代码块
         */
        static {
            Log.d("","static代码块");
        }
    
        /**
         * 构造代码块
         */
        {
            Log.d("","构造代码块");
        }
    
        public Test(){
            Log.d("","构造方法1");
        }
        
        public Test(String name){
            Log.d("","构造方法2");
        }
    
    }
    

    代码块分为static代码块和构造代码块,static代码块在该类被装载时仅执行一次,而构造代码块在调用构造方法时都会被调用,而且执行顺序早于构造方法。上述代码可写为:

    public class Test {
    
    
        /**
         * static代码块
         */
        static {
            Log.d("","static代码块");
        }
    
        public Test(){
            Log.d("","构造代码块");
            Log.d("","构造方法1");
        }
    
        public Test(String name){
            Log.d("","构造代码块");
            Log.d("","构造方法2");
        }
    
    }
    
    1.4 注意⚠️
    1. static关键字并不会影响访问权限,使用static修饰的变量也不会自动变成public,访问权限还是要以权限修饰关键字为准(public、private、protected等)
    2. static是不允许用来修饰局部变量。不要问为什么,这是Java语法的规定
    3. 如果说想在不创建对象的情况下调用某个方法,就可以将这个方法设置为static。我们最常见的static方法就是main方法,至于为什么main方法必须是static的,现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象,因此只有通过类名来访问
    1.5 能通过this访问静态成员变量吗?

    是可以的

    1.6 常见的笔试面试题
    1.6.1 面试题一
    public class Test extends Base{
     
        static{
            System.out.println("test static");
        }
         
        public Test(){
            System.out.println("test constructor");
        }
         
        public static void main(String[] args) {
            new Test();
        }
    }
     
    class Base{
         
        static{
            System.out.println("base static");
        }
         
        public Base(){
            System.out.println("base constructor");
        }
    }
    

    结果为

    base static
    test static
    base constructor
    test constructor
    

    执行顺序:

    1. 先加载Test类,而在加载Test类的时候发现Test类继承自Base类,因此会转去先加载Base类,在加载Base类的时候,发现有static块,便执行了static块
    2. 在Base类加载完成之后,便继续加载Test类,然后发现Test类中也有static块,便执行static块
    3. 在加载完所需的类之后,便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器
    4. 然后再调用自身的构造器
    1.6.2 面试题二这段代码输出什么
    public class Test {
        Person person = new Person("Test");
        static{
            System.out.println("test static");
        }
         
        public Test() {
            System.out.println("test constructor");
        }
         
        public static void main(String[] args) {
            new MyClass();
        }
    }
     
    class Person{
        static{
            System.out.println("person static");
        }
        public Person(String str) {
            System.out.println("person "+str);
        }
    }
     
     
    class MyClass extends Test {
        Person person = new Person("MyClass");
        static{
            System.out.println("myclass static");
        }
         
        public MyClass() {
            System.out.println("myclass constructor");
        }
    }
    

    执行结果为

    test static
    myclass static
    person static
    person Test
    test constructor
    person MyClass
    myclass constructor
    

    执行顺序

    1. 首先加载Test类,因此会执行Test类中的static块
    2. 接着执行new MyClass(),而MyClass类还没有被加载,因此需要加载MyClass类。在加载MyClass类的时候,发现MyClass类继承自Test类,但是由于Test类已经被加载了,所以只需要加载MyClass类,那么就会执行MyClass类的中的static块
    3. 在加载完之后,就通过构造器来生成对象。而在生成对象的时候,必须先初始化父类的成员变量,因此会执行Test中的Person person = new Person(),而Person类还没有被加载过,因此会先加载Person类并执行Person类中的static块
    4. 接着执行父类的构造器,完成了父类的初始化
    5. 然后就来初始化自身了,因此会接着执行MyClass中的Person person = new Person(),最后执行MyClass的构造器
    1.6.3 面试题三这段代码输出什么
    public class Test {
         
        static{
            System.out.println("test static 1");
        }
        public static void main(String[] args) {
             
        }
         
        static{
            System.out.println("test static 2");
        }
    }
    

    执行结果

    test static 1
    test static 2
    

    因为static修饰的代码块是在加载类时被调用一次,和类有关而不依赖于类的实例对象

    二、final

    参看文章https://www.cnblogs.com/chenssy/p/3428180.html

    参考文章
    http://www.cnblogs.com/dolphin0520/p/3799052.html

    相关文章

      网友评论

          本文标题:java关键字static和final的理解

          本文链接:https://www.haomeiwen.com/subject/kdlhcqtx.html