java中的修饰符

java中的修饰符

　　其实后续的章节都是在http://www.runoob.com/java/java-basic-syntax.html网站上的学习笔记,虽然有些知识点很简单，这里还是记一下吧，写下来真的有痕迹的。平时开发的过程中，有需要查看上层的代码，加上已经初步熟悉上层到底层的通信链路，这里在把java的知识，在简单学习一下。

1.java 修饰符

java是面向对象的语言，同其面向对象语言一样的，都一些修饰符。

• 类访问修饰符

  • public: 它可以被该类任何对象访问。
  • final:将一个类生命为最终（即非继承类），表示他不能被其他类继承

  • abstract:将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现

  • private:该成员只允许内部方法访问。

  • protected:指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量.
  • final，最终修饰符，指定此变量的值不能变。
  • static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
  • transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
  • volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改

• 方法修饰符：

  • public:公共控制符,大家都能访问的。
  • private:（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
  • protected:（保护访问控制符）指定该方法可以被它的类和子类进行访问。
  • final:指定该方法不能被重载。
  • static:指定不需要实例化就可以激活的一个方法,可以通过类名直接访问到的。
  • synchronize:同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
  • native:本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。在Android中该方法时用C++来实现的。

• 可见性
  下面这张表格在大学时，学习C#时，在课本上见到过类似的。只是这里多了一个default。defult就是什么默认的，定义变量或者对象时的默认访问权限,下面在具体介绍对应的访问修饰符号时，会结合例子加深理解的。

修饰符	当前类	同一包内	子类	其它包
public	Y	Y	Y	Y
protected	Y	Y	Y	N
private	Y	N	N	N
default	Y	Y	N	N

2.访问修饰符

• public
  public比较好理解，可以理解成，带着这个帽子都是老好人，东西都会分享给大家，就不必做过多介绍了。
• protected
  protected修饰的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。protected访问修饰符不能修饰类和接口，方法和成员变量能够声明为protected，但是接口的成员变量和成员方法不能声明为 protected。子类能访问 protected修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。
• private
  被private修饰的方法和变量只能被所属类访问，但是类和借口不能被声明为private
  。如果对象像访问private修饰的变量，只能通过公共的get方法来访问了。Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
• default
  不使用任何关键字修饰符声明变量和方法时，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为 public。

3.非访问修饰符

• static
  
  • 修饰方法
    static修饰静态方法时，该方法是该类对象所共有的，我们可以通过类名字，直接访问该方法。静态方法中不能直接访问类的成员变量,例如b = this.age,只能通过参数传递数据(毕竟是公共的方法)。在方法中最好不要定义static 变量，因为就算是在函数中定义的局部static变量，它和全局变量没什么差别。
  • 修饰变量
    同修饰方法一样，当变量前面加了static，说明该变量是所有该类对象所有（和全局变量类似）.
• final
  
  1. final修饰变量：final修饰的变量，只能初始化一次。final修饰的引用对象，不能修改，但是引用对象里面的数据是可以修改的。例如：下面我们新建一个文件test.java。

---

class people{
    public int height;
    public int weight;
    people(int _a, int _b){
        this.height = _a;
        this.weight = _b;
    }
}

class home{
    final people peo;
    home(people p){
        this.peo = p;
    }
}

public class test{
    public static void main(String []args) {
        home hom = new home(new people(185, 150));
        System.out.printf("111:height=%d,weight=%d\n",hom.peo.height, hom.peo.weight);
        hom.peo.height = 180;
        hom.peo.weight = 200;
        System.out.printf("222:height=%d,weight=%d\n",hom.peo.height, hom.peo.weight);
        System.out.println("hello world");
    }
}

实验结果

111:height=185,weight=150
222:height=180,weight=200
hello world

2.final修饰的方法：
final方法可以被子类继承，但是不能被子类修改,也就是最终的方法(请看下面的例子)，除非父类方法声明是private类型。使用final修饰方法的原因就是防止子类修改父类方法的内容。

class father{
    private int money;
    father(int mon){
        this.money = mon;
    }
    public final int get_money(){
        System.out.printf("baba monye:%d",this.money);
        return this.money;
    }
}

class son extends father{
    private int money;
    son(int mo){
        super(88);
        this.money = mo;
    }
    public int get_money(){
        System.out.printf("son is monye:%d",this.money);
        return this.money;
    }
}

public class final_t{
    public static void main(String []args) {
        son s = new son(66);
        System.out.printf("money:%d\n",s.get_money());
    }
}

实验结果：
下面可以清楚的看到，子类中重定义了get_money()方法，编译器就报错了。，如果将子类son中的get_money()方法去掉，或者将父类的get_money()方法定义成private属性。编译器就不会报错了。

final_t.java:19: error: get_money() in son cannot override get_money() in father
public int get_money(){
^
overridden method is final
1 error

3.final 修饰的类
用final修饰的类时不能够被继承的，还是终极的意思。

final class base{
    private int a;
}
class test extends base{

}
public class final_t{
    public static void main(String []args){
        System.out.println("hello world");
    }
}

编译结果：
编译结果明显看到，final修饰的类base不能被继承。

final_t.java:4: cannot inherit from final base
class test extends base{
^
1 error

• abstract
  抽象类不能用来实例化对象，而且一个类不能同时被abstract和final修饰(abstract是用来方面扩充类的和让被人来继承的，但是加上final就不能被继承了，显然时互斥的)。一个类包含抽象法，那么该类就要声明为抽象类了(类名前面加abstract修饰)，但是如果一个类被声明为抽象类，不一定要包含抽象方法。

class ab_t{
    public abstract void get();
}
public class abstract_t{
    public static void main(String []args) {
        System.out.println("hello world");  
    }
}

测试结果：
包含abstract方法的类，要被声明为abstract.不然就像下面报错了。

abstract_t.java:1: ab_t is not abstract and does not override abstract method get() in ab_t
class ab_t{
^
1 error

• synchronized

synchronized 关键字的作用就是方法同一时间只能被一个线程访问。

• volatile

volatile，是被设计用来修饰被不同线程访问和修改的变量。就是确保任何时刻，两个不同线程总是能看到某个成员变量为同一个值。

---