导航
我们为什么需要这些非访问修饰符?
像其他语言一样,Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符:
- 访问控制修饰符 : default, public , protected, private(详细介绍见:《封装、继承、多态》,中的访问修饰符)
- 非访问控制修饰符 : static,final, abstract , synchronized,volatile
四个访问修饰符,解决了Java中类与类之间访问权限的设置问题。而非访问控制修饰符,各有各的妙用,且听我一一道来:
static修饰符
static 修饰符,可以用来修饰类方法和类变量。
static变量
- 修饰变量时,称变量为静态变量:
static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
static方法
- 修饰方法时,称方法为静态方法:
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。
来个实例:
class Person {
public static int totalnum; // totalnum为静态变量变量,static修饰
private String name;
private int age;
Person(String name,int age) {
this.name = name ;
this.age = age;
Person.totalnum++;
}
public void die(){
totalnum--;
}
public static void destroy() {
totalnum = 0;
// age = 18; 会报错,static方法中不能使用非static变量
}
}
public class Test {
public static void main(String[] args){
Person person1 = new Person("小猪",18);
System.out.println("小猪出生后,人类总人数:"+person1.totalnum); // Person.totalnum结果与一样
Person person2 = new Person("小牛",20);
System.out.println("小牛出生后,人类总人数:"+person2.totalnum); // Person.totalnum结果与一样
person2.die();
System.out.println("小牛死亡后,人类总人数:"+Person.totalnum);
Person.destroy();
System.out.println("人类灭亡后,人类总人数:"+Person.totalnum);
}
}
-------------------------------------------------
输出结果为:
小猪出生后,人类总人数:1
小牛出生后,人类总人数:2
小牛死亡后,人类总人数:1
人类灭亡后,人类总人数:0
我用比较白话的方式谈谈自己理解:被static 修饰,就是指这些变量和方法是类本身的东西,与具体的实例化对象无关,我们在调用时应该直接从类中调用:类名.变量/方法。所以调用static方法时,static方法内是不能操作非static变量的,因为非static变量都是属于实例化后的对象的,调用static方法是从类的层面调用,并不具体到某一个对象。
final修饰符
final:最终的、最后的。
final修饰符,可以用来修饰方法、变量以及类。
final 变量
- final变量一旦赋值后,不能被重新赋值。并且被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
class Person {
public static final int max_totalnum = 10;
public static int totalnum;
private String name;
private int age;
Person(String name,int age) {
this.name = name ;
this.age = age;
Person.totalnum++;
}
}
public class Test {
public static void main(String[] args){
// Person.max_totalnum = 20 ; 会报错,无法修改final变量的值
}
}
final 方法
- 父类中的 final 方法可以被子类继承,但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
class Person {
public static final int max_totalnum = 10;
public static int totalnum;
private String name;
private int age;
Person(String name,int age) {
this.name = name ;
this.age = age;
Person.totalnum++;
}
static final void destroy() {
Person.totalnum = 0;
}
}
class Woman extends Person {
Woman(String name, int age) {
super(name, age);
}
// void destroy(){ } 无法重写,会报错
}
final 类
- final 类不能被继承,没有类能够继承 final 类的任何特性。
final class Person {
private String name;
private int age;
Person(String name,int age) {
this.name = name ;
this.age = age;
}
}
class Woman extends Person { // 会报错,无法继承,因为Person为final类
}
abstract 修饰符
abstract修饰符用于抽象类与接口当中,关于抽象类与接口详细介绍见:《抽象类与接口》
抽象类
-
被abstract修饰的类为抽象类,抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。
-
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。
扫描二维码关注公众号,回复: 10030321 查看本文章 -
抽象类可以包含抽象方法和非抽象方法。
abstract class Person { //抽象类,注意不能同时被 abstract 和 final 修饰
public static int totalnum;
private String name;
private int age;
Person(String name,int age) {
this.name = name ;
this.age = age;
}
public abstract void die(); //抽象类中可以有抽象方法,有抽象方法一定要声明为抽象类
public static void destroy() { //抽象类中也可以有非抽象方法
totalnum = 0;
}
}
public class Test {
public static void main(String[] args){
new Person(); // 报错,抽象类无法实例化
}
}
抽象方法
-
抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。
-
抽象方法不能被声明成 final 和 static。
-
任何继承抽象类的非抽象子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
-
抽象方法的声明以分号结尾,如:public abstract void die(); 不能再加{}
abstract class Person {
public static int totalnum;
private String name;
private int age;
Person(String name,int age) {
this.name = name ;
this.age = age;
}
public abstract void die();
public static void destroy() {
totalnum = 0;
}
}
class Woman extends Person{ // Woman 为 Person 的 非抽象 子类
Woman(String name, int age) {
super(name, age);
}
@Override // 非抽象子类,必须实现抽象父类的所有抽象方法,也是一种重写
public void die() {
// TODO Auto-generated method stub
Person.totalnum--;
}
}
synchronized,volatile与transient
synchronized 修饰符
- synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
volatile 修饰符
-
volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
-
一个 volatile 对象引用可能是 null。
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}
通常情况下,在一个线程调用 run() 方法(在 Runnable 开启的线程),在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用,那么在 第二行 的 active 值为 false 时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active,所以该循环会停止。
transient 修饰符
-
序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
-
该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。
public transient int limit = 55; // 不会持久化
public int b; // 持久化