java修饰符public final static abstract transient

 

JAVA 修饰符public final static abstract transient 
关键字: public final static abstract ... 
1.public protected default private 组 

位置                        private      默认      protected        public 

同一个类                    是            是         是                  是 

同一个包内的类            否            是         是                  是 

不同包内的子类            否            否         是                  是 

不同包并且不是子类       否            否         否                 是 

public 访问权限最高,不论是不是同一个包或是否是子类 都可以访问 
protected 其次只有是不同包且不是子类的无法访问外，其它均可 
默认级别 次之,要求只能是同一个包中的类才能访问 
private 只能是同一个类才能访问 

这些修饰符可以修饰方法或者属性，但是类只能用public 或者不写. 

Java代码 

   1. package test;  
   2.   
   3. //访问修饰符的使用  
   4. public class PublicClass{  
   5.   
   6.          public String publicVariable = "publicVariable" ;  
   7.          private String privateVar = "private var";  
   8.          protected String protectedVar ="protected var";  
   9.          String defaultVar="defaultVar";  
  10.   
  11.          private void showPrivate(){  
  12.                    System.out.println("Nobody will access!");  
  13.               }  
  14.   
  15.          public void showPublic(){  
  16.                    System.out.println("showPublic method!");  
  17.               }  
  18.   
  19.          public void showProtected(){  
  20.                    System.out.println("Show protected method!");  
  21.               }  
  22.   
  23.          void showDefault(){  
  24.                    System.out.println("Show default method!");  
  25.               }  
  26.      }  

package test; 

//访问修饰符的使用 
public class PublicClass{ 

         public String publicVariable = "publicVariable" ; 
         private String privateVar = "private var"; 
         protected String protectedVar ="protected var"; 
         String defaultVar="defaultVar"; 

         private void showPrivate(){ 
                   System.out.println("Nobody will access!"); 
              } 

         public void showPublic(){ 
                   System.out.println("showPublic method!"); 
              } 

         public void showProtected(){ 
                   System.out.println("Show protected method!"); 
              } 

         void showDefault(){ 
                   System.out.println("Show default method!"); 
              } 
     } 



Java代码 

   1. package test;  
   2.   
   3. //import test.PublicClass;  
   4. class Test{  
   5.          private String var =" private variable in class-Test!";  
   6.            
   7.          public static void main(String args[]){  
   8.                    Test t = new Test();  
   9.                    PublicClass pClass = new PublicClass();  
  10.                    //另外一个类中的共有属性和方法是可以被外界所访问的  
  11.                    System.out.println("可以访问到的资源属性:"+pClass.publicVariable);//可访问  
  12.                    pClass.showPublic();       // 可访问  
  13.                    /* 
  14.                     *以下两条编译错误，在另外一个类中的私有方法是访问不到的 
  15.                     **/  
  16.                    //System.out.println("可以访问到的资源属性:"+pClass.privateVariable );     //不能访问  
  17.               //   pClass.showPrivate();       //不能访问  
  18.              //私有变量自己可以访问  
  19.               System.out.println("私有变量自己可以访问"+t.var);  
  20.             //protected 成员可以被该类的成员和子类的成员访问。  
  21.               // 还可以被同一个包中内的其他类成员访问  
  22.               System.out.println("可以访问到的资源属性:"+pClass.protectedVar);//可访问  
  23.               pClass.showProtected();//可访问  
  24.               System.out.println("可以访问到的资源属性:"+pClass.defaultVar);//可访问  
  25.               pClass.showDefault();//可访问  
  26.               }  
  27.      }  

package test; 

//import test.PublicClass; 
class Test{ 
         private String var =" private variable in class-Test!"; 
         
         public static void main(String args[]){ 
                   Test t = new Test(); 
                   PublicClass pClass = new PublicClass(); 
                   //另外一个类中的共有属性和方法是可以被外界所访问的 
                   System.out.println("可以访问到的资源属性:"+pClass.publicVariable);//可访问 
                   pClass.showPublic();       // 可访问 
                   /* 
                    *以下两条编译错误，在另外一个类中的私有方法是访问不到的 
                    **/ 
                   //System.out.println("可以访问到的资源属性:"+pClass.privateVariable );     //不能访问 
              //   pClass.showPrivate();       //不能访问 
             //私有变量自己可以访问 
              System.out.println("私有变量自己可以访问"+t.var); 
            //protected 成员可以被该类的成员和子类的成员访问。 
              // 还可以被同一个包中内的其他类成员访问 
              System.out.println("可以访问到的资源属性:"+pClass.protectedVar);//可访问 
              pClass.showProtected();//可访问 
              System.out.println("可以访问到的资源属性:"+pClass.defaultVar);//可访问 
              pClass.showDefault();//可访问 
              } 
     } 



2. final 修饰符 
        final 具有 不可更改的意思，它可以修饰非抽象类，非抽象成员方法和变量。 
        用 final 修饰的类不能被继承，没有子类 如 String 
       用 final 修饰的方法不能被子类的方法覆盖 
        用 final 修饰的变量表示常量，只能被赋值一次 
        用 final 不能修饰构造方法，因为方法覆盖这一概念仅适用于类的成员方法，而不适用于类的构造方法，父类的构造方法和子类的构造方法之间不存在覆盖关系，因此用 final 修饰构造方法是豪无意义的。 

        父类中用 private 修饰的方法不能被子类的方法覆盖，因此 private 类型的方法默认是 final 类型的。 
       
final 类 
        String  类 ，不让继承，封装实现的细节。 

final 方法 
        在某些情况下，出于安全的原因，父类不允许子类覆盖某个方法，此时可以把这个方法声明为 finnal 类型。java.lang.Object 类，getClass（）为 final 类型，equals（）不为 final 类型。  

final 变量 
        用 final 修饰的变量表示取值不会改变的常量。 
        final 修饰符可以修饰静态变量，实例变量和局部变量，分别表示静态常量，实例常量和局部常量。 

        例如 出生日期，年龄的限制等。 
        final 变量都必须显示初始化，否则会导致编译错误。 
        final 变量只能被赋值一次。 

在程序中使用 final 修饰符来定义常量的作用 
        提高程序的安全性，禁止非法修改取值固定并且不允许修改的数据 
        提高程序代码的可维护性。 


3.transient 关键字 
   首先是JAVA的序列化，简单来说就是将某一个类存储以文件形式存储在物理空间，下次再从本地还原的时候，还可以将它转换回来，这种形式便利了网络上的一些操作。 

   序列化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。 

   以文件形式描述某些信息时，容易涉及到安全问题，因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中 ，或者不应简单地不加处理地保存下来 ，为了保证安全性。应该在这些字段前加上transient关键字。它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。 

如果TransTest 类的一个对象被序列化，i的内容不被保存，但j的将被保存。 
Java代码 

   1. class TransTest {     
   2.   transient int i;   //不需要保存     
   3.    int j;            //需要保存     
   4.     

class TransTest {   
   transient int i;   //不需要保存   
    int j;            //需要保存   
}  



4. volatile关键字 不常用 

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。 

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。 

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。 

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。 

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。 


5.Synchronize 关键字 
   先提出问题，如果开启多线程同时操作同一实例变量，Thread-0线程从主内存中取出的值a 为 1，然后a++;  Thread-1线程也从主内存中取出的值 a 进行 a+=2操作;Thread-0存入2到主内存中，Thread-1也存入，这样就覆盖了Thread-0存入的值. 

   原因是在JAVA 的内存模型中，是每一个进程都有一个主内存，每个线程都有自己的内存，线程从主内存取得数据，计算后再存回到主内存中. 

   解决这个问题就可以使用 synchronize关键字. 
   使用synchronized修饰此方法后，把下面的这几个步骤当作一个原子操作:取数据，操作数据，存数据。原子操作是不能够被打断的，所以就保证了数据的一致性，这样在同一时间有线程再执行，虽然在效率上比较有影响，但是能够保证在同一时间只有一个线程能够访问到这一块内存单元。 

6.static 关键字 
    static 修饰符可以用来修饰类的成员变量，成员方法和代码块。 
        用 static 修饰的成员变量表示静态变量，可以直接通过类来访问。 
        用 static 修饰的成员方法表示静态方法，可以直接通过类名来访问。 
        用 static 修饰的程序代码块表示静态代码块，当JAVA虚拟机加载类时，就会执行该代码块。 
        被 static 所修饰的成员变量和成员方法标明归某个类所有，它不依赖于类的特定实例，被类的所有实例共享。只要这个类被加载，JAVA虚拟机就能根据类名在运行时数据区的方法区定位到它们。 

     static 变量 
     类的成员变量有两种，一个是实例变量，没有被 static 修饰，一种是被 static 修饰过的变量，叫类变量或者静态变量。 

     静态变量和实例变量的 区别： 
     静态变量在内存中只有一个拷贝，运行时JAVA虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。可以直接通过类名访问静态变量。 
     对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响。 

      static 方法 
      成员方法分为静态方法和实例方法。用 static 修饰的方法叫做静态方法，或者类方法。静态方法和静态变量一样，不需要创建类的实例，可以直接通过类名来访问。 

      因为静态方法不需要通过它所属的类的任何实例就会被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。 
Java代码 

   1.         
   2. class StaticTest{  
   3.   
   4.         static int num =100;  
   5.         int num1 = 20;  
   6.   
   7.         static void staticMethod(){  
   8.            System.out.println("StaticMethod!");  
   9.            //System.out.println(this.num); //编译错误，在static 方法内，不能使用this 关键字  
  10.               //System.out.println(this.num1);//编译错误，在static 方法内，不能使用this 关键字  
  11.              //   System.out.println(num1);//编译错误，在static 方法内，不能直接访问非 static 变量或者方法  
  12.   
  13.             System.out.println(StaticTest.num);  
  14.         }  
  15.               
  16.           void LocalMethod(){  
  17.                        System.out.println("StaticMethod!");  
  18.            }  
  19.   
  20.                      
  21.   
  22.               public static void main(String args[]){  
  23.                        StaticTest t = new StaticTest();  
  24.   
  25.                        //静态变量被所有的实例共享  
  26.                           t.staticMethod();  
  27.                        System.out.println(t.num);  
  28.                        StaticTest.staticMethod();  
  29.                        System.out.println(StaticTest.num);  
  30.                    }  
  31.         }  
  32.   
  33.       //  总结：在静态方法内不允许访问非静态变量 不能出现 this 和 supper   

      
class StaticTest{ 

        static int num =100; 
        int num1 = 20; 

        static void staticMethod(){ 
           System.out.println("StaticMethod!"); 
           //System.out.println(this.num); //编译错误，在static 方法内，不能使用this 关键字 
              //System.out.println(this.num1);//编译错误，在static 方法内，不能使用this 关键字 
             //   System.out.println(num1);//编译错误，在static 方法内，不能直接访问非 static 变量或者方法 

            System.out.println(StaticTest.num); 
        } 
            
          void LocalMethod(){ 
                       System.out.println("StaticMethod!"); 
           } 

                   

              public static void main(String args[]){ 
                       StaticTest t = new StaticTest(); 

                       //静态变量被所有的实例共享 
                          t.staticMethod(); 
                       System.out.println(t.num); 
                       StaticTest.staticMethod(); 
                       System.out.println(StaticTest.num); 
                   } 
        } 

      //  总结：在静态方法内不允许访问非静态变量 不能出现 this 和 supper 

 

      static 代码块 
      类中可以包含静态代码块，它不存在于任何方法体中。在JAVA虚拟机加载类时会执行这些静态代码块。如果类中包含多个静态块，那么JAVA虚拟机将按照他们在类中出现的顺序依次执行它，并且每个代码块只会被执行一次。 
        
Java代码 

   1. class StaticBlock{  
   2.   
   3.              static int i =5;  
   4.              int j;  
   5.              static{  
   6.                       System.out.println("First :"+i++);  
   7.                   }  
   8.   
   9.              static{  
  10.                       System.out.println("Sencond :" +i++);  
  11.                   }  
  12.                   
  13.              public static void main(String args[]){  
  14.                       StaticBlock s1 = new StaticBlock();  
  15.                       StaticBlock s2 = new StaticBlock();  
  16.                       System.out.println("Last :"+i);  
  17.                   }  
  18.        }  

class StaticBlock{ 

              static int i =5; 
              int j; 
              static{ 
                       System.out.println("First :"+i++); 
                   } 

              static{ 
                       System.out.println("Sencond :" +i++); 
                   } 
                 
              public static void main(String args[]){ 
                       StaticBlock s1 = new StaticBlock(); 
                       StaticBlock s2 = new StaticBlock(); 
                       System.out.println("Last :"+i); 
                   } 
        } 



      静态方法必须被实现 
      静态方法用来表示某个类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。既然如此，当前类必须为静态方法提供实现，即一个静态的方法不能被定义为抽象方法。 

      static 和 abstract 永远不能放在一起用 

      如果一个方法是静态的，它就必须自力更生，自己实现该方法。 
      如果一个方法是抽象的，那么它就只表示类所具有的功能，但不会去实现它，在子类中才会去实现它。 

        作为程序入口的 main() 方法是静态方法 

        因为把 main() 方法定义为静态方法，可以使得JAVA虚拟机只要加载了 main 方法所属的类，就能执行 main() 方法，而无须创建这个类的实例。 

        在 main() 方法中不能直接访问实例变量和实例方法。 

7.abstract 修饰符

类只能是（final+）默认或（final+）public或abstract修饰。其中final+abstract+class是不合法的，编译出错。
        abstract 修饰符可以用来修饰类和成员方法 
        用 abstract 修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化，即不允许创建抽象类本身的实例。没有用 abstract 修饰的类称为具体类，具体类可以被实例化。 
        用 abstract 修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。没有用 abstract 修饰的方法称为具体方法，具体方法具有方法体。 
        abstract 语法规则： 
       抽象类可以没有抽象方法，但包括了抽象方法的类必须被定义为抽象类。如果子类没有实现父类中所有的抽象方法，那么子类也必须被定义为抽象类。 
    以下一个父类 
Java代码

package test; 

//抽象类 

abstract class Shape{ 

//受保护的属性 
     protected double length; 
    protected double width; 
     
    //构造方法 
     Shape(double num1,double num2){ 
               this.length = num1; 
               this.width = num2; 
       }             
     //定义了一个抽象方法，方法体为空，只要有类继承就必须实现这个抽象方法，否则子类也必须声明为抽象类 
     abstract double area();          
} 

其中一个抽象方法 abstract double area(); 

现有一子类去实现这个父类，会出现什么情况？ 

Java代码 

package test; 

//子类继承父类 
class Square extends Shape{ 

            Square(double num1,double num2){ 
                  super(num1,num2); 
               } 
} 


ERROR！！！ 

父类有一抽象方法 abstract double area(); 

子类必须去实现，否则本身也只能为抽象类。 

所以，要么： 
Java代码 
package test; 
//子类继承父类 
class Square extends Shape{ 
            Square(double num1,double num2){ 
                   super(num1,num2); 
               } 
            //实现抽象方法 
            double area(){ 
                   System.out.println("正方形的面积为: "); 
                   return length*width; 
               } 
} 
要么： 
Java代码

package test; 
//子类继承父类 
abstract class Square extends Shape{ 

        Square(double num1,double num2){ 
                   super(num1,num2); 
               } 
} 

没有抽象构造方法，也没有抽象静态方法。 
abstract和static不能同时修饰方法，若是abstract方法则是普通方法，需要实现。
Java代码 

        abstract class Base{ 
            abstract Base() ;// 编译出错，构造方法不能是抽象的 
            static abstract void method() ;//编译出错， static 和 abstract 不能连用 
             static void method2()｛｝; //合法 
        } 
   
抽象类中可以有非抽象的构造方法，创建子类的实例时可能会调用这些构造方法。抽象类不能被实例化，然而可以创建一个引用变量，其类型是一个抽象类，并让它引用非抽象的子类的一个实例。     
Java代码 
  abstract class Base{} 
        class Sub extends Base{ 
           public static void main(String args[]){ 
            Base base1 = new Base (); //编译出错，不能创建抽象类B ase 的实例 
            Base base1 = new Sub(); // 合法，可以创建具体类Sub 的实例 

        }} 

        抽象类及抽象方法不能被 final 修饰符修饰。因为抽象类只允许创建子类，它的抽象方法才能被实现，并且只有它的具体子类才能被实例化，而用final 修饰的类不允许拥有子类，用 final 修饰的方法不允许被子类方法覆盖，因此把abstract 修饰符与 final 修饰符连用，会导致自相矛盾。