Java基础--10.final,static,权限修饰符

一. final

1.1 概述

​ 那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

​ final： 不可改变。可以用于修饰类、方法和变量。

​ 类：被修饰的类，不能被继承。

​ 方法：被修饰的方法，不能被重写。

​ 变量：被修饰的变量，不能被重新赋值。

1.2 使用方式

1.2.1 修饰类

​ final修饰的类，不能被继承。

final class 类名 {
}

​ 查询API发现像 public final class String 、 public final class Math 、 public final class Scanner

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

1.2.2 修饰方法

​ final修饰的方法，不能被重写。

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

1.2.3 修饰变量

1.2.3.1 局部变量

​ 1.基本类型

​ 基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。

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

​ 错误示例:(同一个变量不能再复制)

final int c = 0; 
for (int i = 0; i < 10; i++) { 
	c = i; 
	System.out.println(c); 
}

​ 正确示例:不同的变量

for (int i = 0; i < 10; i++) { 
    final int c = i; 
    System.out.println(c); 
}

​ 2.引用类型

​ 引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成 员变量值的修改.

public class FinalDemo2 { 
    public static void main(String[] args) { 
        // 创建 Person 对象 
        final Person p = new Person(); 
        // 创建 另一个 Person对象 
        p = new Person(); // 报错，指向了新的对象，地址值改变。 
        // 修改对象成员变量的值,可以修改 
        p.name("张三"); 
    } 
}

1.2.3.2 成员变量

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

​ a.显示初始化(在定义成员变量的时候立马赋值)；

public class Student { 
    final int num = 10; 
}

​ b.构造方法初始化(在构造方法中赋值一次);

public class Student { 
    final int num = 10; 
    final int num2; 
    public Student() { 
        this.num2 = 20;  
    } 
}

​ 备注:被final修饰的常量名称，一般都有书写规范，所有字母都大写

二. static

2.1 概述

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

2.2 定义和使用格式

2.2.1 静态变量

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

​ **静态变量：**使用 static关键字修饰的成员变量。

static 数据类型 变量名；

public class Chinese { 
    String name; 
    int age; 
    static String country; 
    public Chinese() { 
    }
    public Chinese(String name, int age) { 
        this.name = name; 
        this.age = age; 
    }
    public void show() { 
        System.out.println(name + "," + age + "," + country); 
    } 
}

//测试类
public class Demo08 { 
    public static void main(String[] args) {
        // 类名.静态成员变量名 
        Chinese.country = "中国"; 
        System.out.println(Chinese.country);
        
        Chinese c1 = new Chinese("范冰冰", 20); 
        c1.country = "中国"; 
        c1.show(); // 范冰冰, 20, 中国
    }
}

**static修饰成员变量好处:**static修饰的成员变量会存储在静态区，只有一份，节省内存，可以使用类名调用。

​ 2.2.2 静态方法

​ 当 static 修饰成员方法时，该方法称为静态方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

​ **静态方法：**使用 static关键字修饰的成员方法，习惯称为静态方法。

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

​ 静态方法调用的注意事项：

​ 静态方法可以直接访问静态变量和静态方法。

​ 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问静态变量或静态方法。

​ 静态方法中，不能使用this关键字。

​ 备注:静态方法只能访问静态成员

​ 2.2.3 调用格式

​ 被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员。

// 访问类变量 
类名.类变量名； 
// 调用静态方法 
类名.静态方法名(参数)；
//对象名调用
类型 对象名 = new 类型();
对象名.类变量名;
对象名.静态方法名(参数);

​ 2.2.4 静态代码块

​ 静态代码块：定义在成员位置，使用static修饰的代码块{ }。

​ 位置：类中方法外。

​ 执行：随着类的加载而执行且执行一次。

public class ClassName { 
    static { 
        // 执行语句 
    } 
}

​ 给静态变量进行初始化赋值:

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

​ static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况

下，去调用方法。

三. 权限修饰符

​3.1 概述

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

​ public：公共的。

​ protected：受保护的

​ default：默认的

​ private：私有的

​ public > protected > default > private

3.2 不同权限的访问能力

	public	protected	default	private
同一类中	true	true	true	true
同一包中(子类与无关类)	true	true	true
不同包的子类	true	true
不同包的无关类	true