java修饰符

2019-11-04 本文已影响0人幻想的绝望

概述

java修饰符有以下两种

访问修饰符
private：私有访问修饰符，仅类内可见
protected：受保护，仅同包内可见
defult：默认，仅同包内可见
public：公有，所有包可见，只需导入包
非访问修饰符
static：用于声明静态方法，变量
final：用于声明不可修改的类，方法，常量
abstract：创建抽象类和抽象方法
synchronized：声明的方法同一时间只能被一个线程访问
transient：修饰的实例变量不会被序列化
volatile：修饰的成员变量强制从共享内存中读取

static要点分析

static修饰的变量为类变量，修饰的方法为类方法，可通过类名直接调用。（修饰类，这个类就是静态内部类）
从jvm虚机机类加载角度看，静态资源是类初始化的时候加载的，而非静态资源是类new的创建对象的时候加载的。静态资源的加载早于非静态资源。所以静态方法不可以引用非静态资源，非静态方法可以引用静态资源。

public class A {
    private static int a = s2();

    static {
        System.out.println("this is s1");
    }

    static int s2() {
        System.out.println("this is s2");
        return 1;
    }

    public A() {
        System.out.println("this is A()");
    }

    public static void main(String[] args) {
        new A();
    }
}
输出结果
this is s2
this is s1
this is A()

说明静态资源的加载顺序是按照资源定义的顺序加载的，且先于非静态资源

public class B {
    static {
        i = 3;
        System.out.println(i);
    }
    private static int i;
}

第四行输出i编译器直接提示报错，说明静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问

public class C {
    static {
        System.out.println("c.static");
    }

    public C(){
        System.out.println("c.public");
    }
}

public class D extends C {
    static {
        System.out.println("d.static");
    }

    public D(){
        System.out.println("d.public");
    }

    public static void main(String[] args) {
        new D();
        new D();
    }
}

输出结果
c.static
d.static
c.public
d.public
c.public
d.public

说明静态代码先执行父类，再执行之类，且只执行一遍

public class Hello {

    public static void main(String[] args) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        printClassesOfClassLoader(loader);
        System.out.println("hello  " + A.class);
        printClassesOfClassLoader(loader);
    }

    public static void printClassesOfClassLoader(ClassLoader loader){
        try {
            Field classesF = ClassLoader.class.getDeclaredField("classes");
            classesF.setAccessible(true);
            Vector<Class<?>> classes = (Vector<Class<?>>) classesF.get(loader);
            for(Class c : classes) {
                System.out.println(c);
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

程序输出
class com.intellij.rt.execution.application.AppMainV2$Agent
class com.intellij.rt.execution.application.AppMainV2
class com.intellij.rt.execution.application.AppMainV2$1
class statics.Hello
hello  class statics.A
class com.intellij.rt.execution.application.AppMainV2$Agent
class com.intellij.rt.execution.application.AppMainV2
class com.intellij.rt.execution.application.AppMainV2$1
class statics.Hello
class statics.A

接着上面的A类，以上代码运行后，程序输出中并没有出现A中的静态代码块输出的内容，但是类加载器里面的确有了A类。为什么A.class这种方式不会触发A内的静态代码块的执行呢？
这就要提到java类加载的五个过程加载，验证，准备，解析，初始化。在Java方法区中创建A.Class的类信息发生在加载阶段，运行静态块内容则发生在初始化阶段

final要点分析

final修饰类，类不可被继承
final修饰方法，方法不可被重写
final修饰变量，变量不可改变

    public static void main(String[] args) {
        final String[] s = {"aaa", "bbb"};
        s[1] = "ccc";
        //s = new String[2];//无法使用，程序报错
    }

第三行没问题，第四行程序提示bug，说明变量的不可改变，指的是引用不可改变，但是引用指向的内容可以改变

final String s = "a"

重点说说这个，这个a存在于常量池中，s存储的是指向a的地址，如果把s赋值为"b"，本质上是把s存储的地址改成b的，当然修改时不会成功的。所以本质上来说final修饰变量的时候确实是，不可变的是变量的引用而非引用指向对象的内容

其他要点分析

类默认和接口默认并不相同，接口变量默认为public static final，接口方法默认为public
protected修饰符，经测试，子类父类在不同包，子类不可见父类的protected方法

public class Student extends People {

    protected void say4() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        People p = new Student();
        //p.say4();//无法使用，会报错

        Student s = new Student();
        s.say4();
    }
}

想我所见，思我说闻
写我所想，写我所思
不求处处皆对 
只求问心无愧

java修饰符

概述

static要点分析

final要点分析

其他要点分析

猜你喜欢

热点阅读