java语言基础之关键字1（public、protested、private、static）

关键字static

 在java语言中，static用来修饰成员变量和成员方法，也可形成静态代码块来优化程序性能（特性：只会在类加载的时候执行一次）。

 static变量也称作静态变量，静态变量和非静态变量的区别是：

静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。

而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

（1）静态变量/方法调用

public class A {
      static int x = 1;
      void  a() {
    	  {
    		  System.out.println("调用非静态方法");
                  b();///非静态方法中调用静态方法
    	  }
    	  
      }
      static void b() {
    	  {
    		  System.out.println("调用静态方法！");
    	  }
      }
      public static void main(String[] args) {
    	    System.out.println(A.x);
    	   /// static int b = 2;不允许在修饰局部变量，这样会报错的
    	    A.b();///静态方法直接用类名调用
    	    A st = new A();
    	    st.a();
    	      
      }   
}

 （2）静态代码块

注意：1、java语法规定，static是不允许用来修饰局部变量的，也可以说static块可以出现类中的任何地方（只要不是方法内部）。

          2、static方法就是没有this的方法。在static方法内部是不能调用非静态方法的，当是反过来就可以了。

          3、static可以在没有创建对象的情况下，仅仅通过类本身来调用static方法，也就是说方便没有创建对象的情况下进行调用(变量/方法）

不可以使用protected来修饰class

关键字(public、private、protected)

     默认方法，public、private、protected方法都可以在同一个类（本类）下调用。

 

package Training;

public class Father {
      void show() {
           System.out.println("默认show！");
      }
      public void show1() {
          System.out.println("public show1!");
      }
      private void show2() {
          System.out.println("private show2!");
      }
      protected void show3() {
          System.out.println("protected show3!");
      }
      public static void main (String[] args) {
          Father f = new Father();
          f.show();
          f.show1();
          f.show2();
          f.show3();
          
      }
}

 

　private属于私有的，只能为本类（子类、无关类）所用。其他可以在同一个包调用。

package Training;

public class son extends Father{
     public static void main(String [] args) {
    	 Father f = new Father();
    	 f.show();
   	     f.show1();
   	    // s.show2();
   	     f.show3();
   	     System.out.println("**************");
   	     son s= new son();
   	     s.show();
   	     s.show1();
 	    // s.show2();
 	     s.show3();
     }
}

　　

package Training;

public class tect {
     public static void main(String  []args) {
    	   Father f = new Father();
    	   f.show();
    	   f.show1();
    	   //f.show2();
    	   f.show3();
     }
}

　　

 

 

只有protected、public能在不同包下的（子类、无关类）调用。

package Training1;

import Training.Father;

public class son2 extends Father{
    public static void main(String [] args) {
   	 Father f = new Father();
     	//f.show();
  	     f.show1();
  	    //s.show2();
  	    // f.show3();
  	     System.out.println("**************");
  	     son2 s= new son2();
  	     //s.show();
  	     s.show1();
	     //s.show2();
	     s.show3();
    }
}

　　

package Training1;

import Training.Father;
class tect2 {
     public static void main(String[] args) {
    	 Father f = new Father();
    	 //f.show();
    	 f.show1();
    	 //f.show2();
    	 //f.show3();
     }
}

　　

 

以上权限修饰符的可见范围：

                     本类         同一个包下      不同包下的子类     不同包下的无关类
private         可以
默认             可以               可以
protected     可以               可以               可以 
public           可以               可以               可以                     可以

参考资料：

http://www.cnblogs.com/dolphin0520/p/3799052.html

https://zhidao.baidu.com/question/294516388.html