Java基础之static、final与权限修饰符

1. static关键字

1.1 概述

关于static关键字的使用,它可以用来修饰成员变量和成员方法,被修饰的成员是属于类的,而不单单是属于某个对象分,也就是说,既然属于类,就可以不靠创建对象来调用了.

1.2 定义和使用格式

类变量

当static修饰成员变量时,该变量称为类变量.该类的每个对象都共享同一个类变量分值,任何对象都可以该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行操作.

• 类变量:使用static修饰的成员

定义格式:

static 数据类型 变量名;

举例:

static int number;

代码实现

public class Test{
    public static void main(String[] args) {
        Studnet s1 = new Studnet("张三", 23);
        Studnet s2 = new Studnet("李四", 24);
        Studnet s3 = new Studnet("王五", 25);
        Studnet s4 = new Studnet("赵六", 26);
        s1.show();// Student : name=张三, age=23, sid=1
        s2.show();//  Student : name=李四, age=24, sid=2
        s3.show();// Student : name=王五, age=25, sid=3
        s4.show();//  Student : name=赵六, age=26, sid=4
    }
}

class Studnet {
    private String name;
    private int age;
    private int sid;//学生的id
    //类变量,记录学生数量,分配学号
    public static int numberOfStudent = 0;

    public Studnet(String name, int age) {
        this.name = name;
        this.age = age;
        //通过numberOfStudent给学生分配学号
        this.sid = ++numberOfStudent;
    }
    //打印属性值
    public void show(){
        System.out.println("Student:name=" + name + ", age=" + age + ", sid=" + sid);
    }
}

静态方法

当static修饰成员方法时,该方法称为类方法.静态方法在声明中有static,使用类名来调用,而不需要创建类的对象.

• 类方法:使用static关键字修饰的成员方法,习惯成为静态方法.

定义格式:

修饰符 static 返回值类型 方法名 (参数列表) {
	//执行语句
}

举例:

public static void showNum () {
 System.out.println("num:" + numberOfStudent);
}

• 静态方法调用的注意事项：
  • 静态方法可以直接访问类变量和静态方法。
  • 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
  • 静态方法中，不能使用this关键字

调用格式:

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

// 访问类变量
类名.类变量名

// 调用静态方法
类名.静态方法名(参数);

public static void main(String[] args) {
    // 访问类变量
    System.out.println(Studnet.numberOfStudent);
    // 调用静态方法
    Studnet.showNum();
}

1.3 静态原理图解

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
• 它优先于对象存在，所以，可以被所有对象共享
  

1.4静态代码块

• 静态代码块:定义在成员位置,使用static修饰的代码块{}
  • 位置:类中方法外
  • 执行:随着类的加载而执行且执行一次,优先于main方法和构造方法的执行

格式:

public class 类名称 {
    static {
        // 执行语句
    }
}

class Test1{
    public static int number;
    public static ArrayList<String> list;
    
    static  {
        // 给类变量赋值
        number = 2;
        list = new ArrayList<String>();
        // 添加元素到集合中
        list.add("张三");
        list.add("李四");
        
    }
}

2. final关键字

2.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final关键字，用于修饰不可改变内容

扫描二维码关注公众号，回复： 10971077 查看本文章

• final:不可改变,用于修饰类,方法和变量.
  • 类:被修饰的类,不能被继承.
  • 方法:被修饰的方法,不能被重写.
  • 变量:被修斯的变量不能被重新赋值.

2.2 使用方式

修饰类

final class 类名 {
    
}

public final class Math 、 public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

格式:
修饰符 final 返回值类型 方法名 (参数列表) {
// 方法体
}

修饰变量

局部变量–基本类型
基本类型的局部变量被final修饰后,只能赋值一次,不能在更改

public static void main(String[] args) {
    // 声明变量,使用final修饰
    final int a;
    // 第一次赋值;
    a = 10;
    // 第二次赋值
    a = 20; // 报错,不可重新赋值
    // 声明变量,直接赋值,使用final修饰
    final int b = 10;
    // 第二次赋值
    b = 20; // 

报错,不可重新赋值
}
局部变量–引用类型
引用类型的局部变量,被final修饰后,只能指向一个对象,地址不能在更改,胆汁不影响对象内部的成员变量的修改

public static void main(String[] args) {
    // 创建Student对象
    final Studnet s1 = new Studnet("张三", 14);
    // 创建另一个Student对象
     s1 = new Studnet("李四",25);// 报错,指向了新的对象,地址值改变
    s1.setName("李四");//可以修改
}

成员变量
成员变量涉及到初始化的问题,初始化的方式只有两种,只能二选一:

• 显示初始化:

public class user {
    final String USERNAME = "张三";
    private int age;
}

• 构造方法初始化:

public class user {
    final String USERNAME;
    private int age;
    public user(Sytring name,int age) {
        this.USERNAME = name;
        this.age = age;
    }
}

3. 权限修饰符

3.1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

• public：公共的。
• protected：受保护的
• default：默认的
• private：私有

3.2 不同权限的访问控制能力

	public	protected	default（空的）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

public 具有最大权限,private则是最小权限.

如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用 private ，隐藏细节。
• 构造方法使用public，方便创建对象。
• 成员方法使用 public ，方便调用方法