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();
              
      }   
}

package 大圣归来;

class person{
          String name;
          int age;
          static String country;///静态是被所有对象所共享的
          public person(String name,int age) {
                  this.name = name;
                  this.age = age;
          }
          public person(String name,int age,String country) {
                  this.name = name;
                  this.age = age;
                  this.country = country;
          }
          public void show() {
                  System.out.println("姓名:"+name+"年龄:"+age+"国籍:"+country);
          }
}
public class persondemo {
     public static void main(String [] args) {
         person p  = new person("A",23,"中国");
         p.show();
         
         person p1 =new person("B",65);
         p1.show();
     }
}
/*

姓名:A年龄:23国籍:中国

姓名:B年龄:65国籍:中国

*/

（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