Java修饰符的知识

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

• 访问修饰符: public, protected, default, private
• 非访问修饰符: final, abstract, static, synchronized

一、访问修饰符

• public: 对所有类可见。使用对象：类、接口、成员变量、成员方法。
• protected: 对同一包内的类和所有子类可见。使用对象：成员变量、成员方法。 注意：不能修饰外部类和接口。
• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、成员变量、成员方法。
• private: 在同一类内可见。使用对象：成员变量、成员方法。 注意：不能修饰外部类和接口。

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N（见下面的访问修饰符的说明）	N
default(缺省)	Y	Y	Y	N	N
private	Y	N	N	N	N

访问修饰符不能用于局部变量
所有的访问修饰符和abstract, static, 不能修饰局部变量(即成员方法里定义的变量)

(1)访问变量的方式

(1)在子类中直接访问父类的成员变量和成员方法

(2)通过类创建的对象来访问成员变量和成员方法

(2)四种访问修饰符的区别:

• 1、假设public的类A里有个public变量a，那么A在任何包里创建的对象都可以访问a，继承的子类所创建的对象，也可以访问a。

• 2、假设public的类B里有个protect变量b，那么B在外包里创建的对象不能访问b，因为b只在同一个包里可见，只有在外包里继承了B，才能在那个子类里访问b (如何在包内继承，那完全可以访问，因为变量包内可见)

• 3、假设public的类C里有个缺省修饰符的变量c，那么C在外包里创建的对象也是无法访问c的，因为c只在同一个包里可见，即便是在外包中继承了C的子类里，也不能访问c (如何在包内继承，那完全可以访问，因为变量包内可见)

• 4、假设public的类D里有个private的变量d，就更不用说了，d在同一个包里也是不可见的，只有在当前类中可见 (d在包内也无法继承)

• 对于public修饰的类，可用于一切包，需要import一下

• 对于缺省修饰词的类，只在同包可见(同包也没有必要import)
  

1)public修饰符

允许所有的包访问,是安全级别最低的修饰符

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

public static void main(String[] arguments) {
   // ...
}

2)protected修饰符

• 基类的 protected 成员是包内可见的，并且对子类可见；
• 若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法
• 从基类继承来的子类的pro方法,只对子类本身和重子类可见
  也就是说,只有初代父类的pro变量对同包可见

package p1;
public class Father1 {
    protected void f() {}    // 父类Father1中的protected方法
}
 
package p1;
public class Son1 extends Father1 {}
 
package p11;
public class Son11 extends Father1{}
 
package p1;
public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK     ----（1）
        son1.clone(); // Compile Error     ----（2）
 
        Son11 son = new Son11();    
        son11.f(); // Compile OK     ----（3）
        son11.clone(); // Compile Error     ----（4）
    }
}

此例说明，父类和子类不在相同的包，在父类包中用子类创建的对象，可以访问   子类对象.f()   原因是父类的pro方法对同包可见，即便不是用父类对象。
而clone方法是父类从更高的祖类继承来的，只在父类本身中和子类本身中可见,在Text1类中不可见

package p2;
class MyObject2 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}
 
package p22;
public class Test2 extends MyObject2 {
    public static void main(String args[]) {
       MyObject2 obj = new MyObject2();
       obj.clone(); // Compile Error         ----（1）
 
       Test2 tobj = new Test2();
       tobj.clone(); // Complie OK         ----（2）
    }
}
此例说明，父类和子类不在相同的包，在子类中，可以访问子类对象的pro方法，但是不能访问父类对象的pro方法。
因为父类的pro变量只对父类包可见，其继承到子类中，只能用子类创建的对象才能访问子类的pro变量 

3)default修饰符

default是一个缺省修饰符，并不用写出来。

当类和类的成员变量及成员方法缺省修饰符时,它们在同一个包内可见。

当接口本身缺省修饰符时，会默认为default abstract而不是public abstract。

当接口的变量和方法缺省修饰符时，成员变量隐式声明为 public static final，成员方法隐式声明为public abstract。

由于default修饰的类在其他包不可见，所以在其他包也就没有子类可以继承它。

由public修饰的类，default修饰的变量，这个变量在外包的子类中也是无法访问的，因为default只在包内可见。

4)private修饰符

只能在当前类中访问private变量和方法，是安全级别最高的修饰符。

子类在包内和包外都不能继承父类的private方法和private变量。

子类在包外不能继承父类的default方法和变量，

用于封装数据:

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

二、非访问修饰符

(1)static 修饰符

• 静态变量：
  static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

• 静态方法：
  static 关键字用来声明独立于对象的静态方法。 静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

(2)final 修饰符

1) final 变量：

• final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
• final 修饰符通常和 static 修饰符一起使用来创建类常量。

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
 
  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

2) final 方法

• 父类中的 final 方法可以被子类继承，但是不能被子类重写。
• 声明 final 方法的主要目的是防止该方法的内容被修改。
• 如下所示，使用 final 修饰符声明方法。

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

3) final 类

• final 类不能被继承，没有类能够继承 final 类的任何特性。

public final class Test {
   // 类体
}

(3)abstract 修饰符

抽象类：

• 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
• 一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
• 抽象类可以包含抽象方法和非抽象方法。
• 没有抽象成员变量的说法，abstract不用于变量前面

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

抽象方法

• 抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
• 抽象方法不能被声明成 final 和 static。
• 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
• 如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
• 抽象方法的声明以分号结尾，例如：public abstract sample();。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

(4)synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。