重温！Java访问修饰符

重温！Java访问修饰符

1、访问控制修饰符

访问控制修饰符	描述
public	公开级别。对外公开，任何类、任何包都可以访问到。
protected	受保护级别。对子类以及同一包中的类公开。
无	默认级别。对同一包中的类公开。
private	私有级别。只有当前类本身可以访问，不对外公开

在一个com.demo.mypack包里面创建一个fw.java的类：

package com.demo.mypack;

public class fw {

    private String a;  //私有的
    protected String b; //受保护的
    String c;  //默认的
    public String d;  //公共的

    //私有的
    private void fa() {

    }

    //受保护的
    protected void fb() {

    }

    //默认的
    void fc() {

    }

    //公共的
    public void fd() {

    }
}

在另一个包com.demo.mypack2去创建fw的对象并调用里面的变量和方法：

package com.demo.mypack2;

import com.demo.mypack.fw;

public class Son {

    public static void main(String[] args) {
        fw fw = new fw();
        String d = fw.d;  //public String d;  //公共的
        fw.fd();  //公共的public void fd();
    }
}

事实上，只有public修饰的变量d和public修饰的方法fd能被在其他包里面调用，其他的均不能被调用。

2、abstract修饰符：抽象的

abstract修饰的类是抽象类，修饰的方法是抽象方法。被abstract修饰的类不能被实例化，被abstract修饰的方法没有方法体，也就是说没有具体的实现。没有被abstract修饰的方法可以有自己的方法体的实现。

语法是，如果当前类中包含抽象方法，那么这个类就必须是抽象类，如果继承此抽象类的子类没有全部实现抽象方法，那么这个子类也必须定义为抽象类。

可以这么理解，抽象类定义的是概念，这需要"人"去实现他或者说重写里面非抽象的方法。

注意！没有抽象的静态方法，static和abstract不能一起使用。

抽象类：

//抽象类
public abstract class Abs {

    //抽象方法
    public abstract void sayHello();

    public void sayHi(){
        System.out.println("Abs sayHi~");
    }
}

抽象类的子类：

public class Son extends Abs {
    //实现父类的抽象方法
    @Override
    public void sayHello() {
        System.out.println("实现sayHello");
    }

    //重写父类的方法
    @Override
    public void sayHi() {
        System.out.println("son sayHi~");
    }
}

3、final修饰符：不可改变的

final具有不可改变的含义，它可以修饰类、成员变量和方法以及形参。

final修饰的类不能被继承扩展、不能被子类的方法覆盖、修饰的常量只能被覆盖一次。

final初始化变量是显式的并且只能进行一次初始化，初始化之后不能被修改。

//final修饰的类，不能被继承
public final class fin {

    final String v1 = "vip";
    //没有被初始化的成员变量编译报错
    //final String v2;

    //不能被重写的方法，也不可能重写，因为类就是final的
    public final void sayHello(){
        //--
    }

    public void sayHi(final String str){
        //---
        //str = "122";  final修饰的形参值不能被改变
    }
}

4、static修饰符：静态、类级别

static用来修饰成员变量、成员方法和代码块。

static修饰的成员变量为静态(类)变量（没有static的变量为实例变量），可以直接通过类名访问；修饰的方法叫静态方法，可以通过类名访问；修饰的代码块当JVM加载时会先进行代码块的加载。

静态变量与示例变量的区别：

• 静态变量在类加载时在内存中只分配一次内存，可以通过类名调用。
• 每创建一次对象就会为实例变量分配一次内存，实例变量在内存中有多份，互不影响。

可以这么理解！静态变量或者方法不是属于某个对象而是属于当前的类，与类的实例对象无关。

public class sta {

    private sta() {
        System.out.println("构造方法...第三个加载");
    }

    //静态代码块
    static {
        System.out.println("静态代码块...第一个加载");
    }

    //普通代码块
    {
        System.out.println("代码块...第二个加载");
    }

    //静态变量
    private static String str;
    //普通变量
    private String str2;

    //静态方法
    public static void fa() {

    }

    //普通方法
    public void fb() {

    }

    public static void main(String[] args) {
        new sta().fb();  //对象调用普通方法
        sta.fa();  //类调用静态方法
        String str = sta.str;  //类调用静态变量
        String str2 = new sta().str2; //对象调用普通变量
    }
}