java基础之 修饰符

一、访问修饰符

 Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

1、default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

2、private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

3、public : 对所有类可见。使用对象：类、接口、变量、方法

4、protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

• 基类的 protected 成员是包内可见的，并且对子类可见；
• 若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。

二、非访问修饰符

1、static：修饰符，用来创建类方法和类变量。

静态变量：static关键字用来声明独立于对象的静态变量。

  （1）无论一个类实例化多少对象，它的静态变量只有一份拷贝。

  （2）局部变量不能被声明为static。　

静态方法：Static关键字用来声明独立于对象的静态方法。

  （1）静态方法不能使用类的非静态变量。

public class VisitNot {
    // 声明静态变量
    public static String str = "喵帕斯";
    public int a = 0;

    // 声明静态方法
    public static String printStr() {
        // 局部变量不能被声明为static，会报错
        // static String localv = "10";

        // 静态方法可以使用静态变量
        str = "(" + str + ")";

        // 静态方法不可以使用非静态变量，会报错
        // System.out.println(a);
        return str;
    }

    public static void main(String[] args) {
        // 访问静态变量 类.变量名
        System.out.println(VisitNot.str);
        // 访问静态方法 类.方法名
        System.out.println(VisitNot.printStr());
    }
}

  注意：对类（静态）变量和方法的访问可以直接使用classname.variablename和classname.methodname的方式访问。

2、final：修饰符，用来修饰类、方法和变量。

（1）final变量能被显式地初始化并且只能初始化一次。

（2）修饰的变量为常量，不可修改。

（3）final对象的引用不能改变。

（4）类中的final方法可以被子类继承，但是不能被子类重写，可被重载。

（5）final类不能被继承。

public class FinalTest {
    // 声明final变量
    public final int a = 0;

    // 声明的final变量引用了一个实例对象
    public final B b = new B();

    // 声明的final变量是不能被修改的，会报错
    public int m() {
        b = new B();
        a += 100;
        return a;
    }

    // 声明final的方法可以重载
    class B {
        public final void m2() { }
        public final void m2(int a) { }
    }

    // 声明final的方法，不能被重写，会报错
    class c extends B{
        @Override
        public final void m2() { }
    }

    final class D{}
    // 声明final的类，不能被继承
    class E extends D{}
}

3、abstract：修饰符，用来创建抽象类和抽象方法。

（1）abstract如果用于修饰类，此类将不能被实例化；

（2）abstract如果用于修饰方法，那么此方法的类必须也要用abstract修饰；

（3）abstract修饰的类用于继承，子类必须实现里面abstract修饰的方法；

（4）用abstract修饰的类和方法，不能再使用 final、static来进行修饰；

（5）abstract类可存在非abstract的方法，但存在abstract方法的类，必须是abstract修饰的；

package test;

public class abstractTest {
    public static void main(String[] args) {
        System.out.println("abstractTest");
    }
}

// 这是一个abstract修饰的类
abstract class A {

    // abstract类里的abstract方法
    public abstract void aM();

    // abstract类里的普通方法
    public void bM() {
        int i = 0;
        i++;
        System.out.println(i);
    }
}

// 类B继承abstract类A
class B extends A {

    //必须实现abstract类A的abstract方法、否则报错
    @Override
    public void aM() {
        System.out.println("abstract类A的abstract方法aM()，实现了！");
    }
}

4、synchronized和volatile修饰符，主要用于线程的编程。

这个有点复杂，后面再看。