Java学习-修饰符

一、访问控制修饰符

访问权限表

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
default	Y	Y	Y	N	N
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N（说明）	N
private	Y	N	N	N	N

1.1 public

项目	含义
含义	公共的。
使用者	类、接口、变量、方法。
可见性	同包其他类 + 其它包（需要先导入包）类。
注意	由于类的继承性，类所有的公有方法和变量都能被其子类继承。

// 主入口函数，一个项目，只能有一个主入口函数，且语法不可改变。
public static void main(String[] arguments) {
   // ...
}

1.2 default

项目	含义
含义	不使用任何关键字修饰时，为该类型。
使用者	类、接口、变量、方法。
可见性	当前包。
注意	接口中，变量隐式声明为public static final，方法默认访问权限为public。

// 声明变量
String age = 18;
// 声明方法
boolean setAge(){
  return true;
}

1.3 protected

项目	含义
含义	受保护的。
使用者	变量、方法。
可见性	同包其他类 + 其它包中的子类。
注意	接口的成员变量和成员方法不能声明为protected。

// 父类
class people {
   protected void speak() {
      // 实现细节
   }
}
// 子类
class male {
   boolean speaker() {
      // 实现细节
   }
}

1.4 private

项目	含义
含义	私有的。主要隐藏类的实现细节和保护类的数据。
使用者	变量、方法。
可见性	当前类。
注意	外部类只能通过类中公共的getter方法，访问私有类型的变量。

public class people{
	private String age = 18;// 声明私有、字符串型变量
	// 声明公共的、有返回值的方法getAge，目的是让外部类能够访问age
	public String getAge(){
	  return this.age;
	}
	// 声明公共、无返回值的方法setAge，目的是让外部类能够设置age
	public void setAge( String age){
	  this.age = age;
	}
}

访问控制与继承

父类访问控制类型	子类访问控制类型
public	public
无	可private
protected	protected 或 public
private	不能被继承

二、非访问控制修饰符

目的：实现一些其他的功能

修饰符	含义
static	静态的
final	最终的、不可改变的
abstract	抽象的
synchronized	同步的
transient	短暂的、路过的
volatile	不稳定的、爆炸性的

2.1 static

作用：用来创建类方法和类变量（静态变量）。

2.1.1 静态变量

含义：使用static修饰的变量，称为静态变量（即类变量）。
特点：

1. 静态变量只有一份拷贝。即静态变量的数量与一个类实例化对象的个数无关。
2. 局部变量不能被声明为static变量。

声明语法：访问控制修饰符 static 数据类型 变量名 = 变量值;
访问语法：类名.静态变量名

public class Counter {
   // 声明静态变量（类变量）number
   private static int number = 0;
   // 声明返回值为int类型静态方法getcounter
   protected static int getCounter() {
     // 静态方法不能使用类的非静态变量。
      return number;
   }
   private static void addNumber() {
     // 静态方法调用静态变量，并对其进行操作。
      number++;
   }
   // 构造函数
   Counter() {
      // 调用静态方法
      Counter.addNumber();
   }
   public static void main(String[] arguments) {
      // 调用类中的静态方法。类名.静态方法名。
      System.out.println(Counter.getCounter());
      for (int i = 0; i < 500; ++i){
         new Counter(); // 调用构造函数
      }
      System.out.println(Counter.getCounter());
  } 
} 

2.1.2 静态方法

含义：使用static修饰的方法，称为静态方法。
特点：

1. 静态方法不能使用类的非静态变量。
2. 静态方法从参数列表得到数据，然后计算这些数据。

声明语法：访问控制修饰符 static 返回值数据类型 方法名(){ };
访问语法：类名.静态方法名
示例：参《2.1.1 静态变量》

2.2 final

作用：用来修饰类、方法和变量。

2.2.1 修饰变量 ——常量

含义： 使用final非访问修饰符修饰的变量。
特点：

1. 为常量，是不可修改的，只能初始化一次。
2. 常和static一起使用来创建类常量。
3. final对象，final对象的引用不能改变，但是里面的值可以改变。

声明语法：访问控制修饰符 [static] final 数据类型 常量名 = 常量值;

public class Test{
  // 声明final变量value。
  final int value = 10;
  // 声明整型类常量boxWidth。
  public static final int boxWidth = 6;
  // 声明字符串型类常量。
  static final String name = "张三";
  public void changeValue(){
     value = 12; // 将输出一个错误，final变量不可改变。
  }
}

2.2.2 修饰方法——不可被重写

含义： 使用final非访问修饰符修饰的方法。
特点：

1. final方法，不能被重写。
2. 主要目的是防止该方法的内容被修改。

声明语法：访问控制修饰符 final 返回值数据类型 方法名(){}

public class Test{
   // 声明final方法。
    public final void changeName(){
       // 方法体
    }
}

2.2.3 修饰类——不可被继承

含义： 使用final非访问修饰符修饰的类。
特点： final类，不能被继承，，但里面的值可以改变。
声明语法：访问控制修饰符 final class 类名{}

public final class Test {
   // 类体
}

2.3 abstract

作用：用来创建抽象类和抽象方法。

2.3.1 抽象类

含义： 使用abstract非访问修饰符修饰的类。
特点：

1. 不能用来实例化对象。
2. 唯一目的是为了将来对该类进行扩充。
3. 若类包含抽象方法，该类必须要声明为抽象类。
4. 可包含抽象方法和非抽象方法。
5. 抽象类可以不包含抽象方法。
6. 不能同时被abstract和final修饰。

声明语法：访问控制修饰符 abstract class 类名{}

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

2.3.2 抽象方法

含义： 使用abstract非访问修饰符修饰的方法。是一种没有任何实现的方法。
特点：

1. 该方法的的具体实现由子类提供。
2. 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
3. 抽象方法的声明以分号结尾。
4. 不能同时被abstract和final修饰。

声明语法：访问控制修饰符 abstract 返回值数据类型 方法名();

// 声明抽象类。
public abstract class SuperClass{
    abstract void m(); // 声明抽象方法
}
// 扩充抽象类。
class SubClass extends SuperClass{
     // 实现抽象方法
      void m(){
          .........
      }
}

2.4 synchronized

作用：主要用于线程的编程。
特点：

1. synchronized方法同一时间只能被一个线程访问。
2. 可以应用于四个访问修饰符。

声明语法：访问控制修饰符 synchronized 返回值数据类型 方法名();

public synchronized void showDetails(){
.......
} 

2.5 transient

作用：主要用于线程的编程。
特点：

1. 序列化的对象包含被transient修饰的实例变量时，JVM跳过该特定的变量。
2. 该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

声明语法：访问控制修饰符 transient 数据类型 变量名 = 变量值;

public transient int limit = 55;   // will not persist
public int b; // will persist

2.6 volatile

含义：不稳定的、爆炸性的。
特点：

1. volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
2. 当成员变量发生变化时，强迫线程将变化值回写到共享内存。
3. 这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
4. 一个volatile对象引用可能是null。

声明语法：访问控制修饰符 volatile 数据类型 变量名 = 变量值;

{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // line 1
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // line 2
    }
}
// 一般地，在一个线程中调用run()方法，在另一个线程中调用stop()方法。如果line 1中的active位于缓冲区的值被使用，那么当把line 2中的active设置成false时，循环也不会停止