关键字

       对于关键字的总结
1.访问限定符 用来定义 类的属性
   public class{
  //定义两个全局变量
        private int num;//私有变量,只能在此类里调用
        public int name;//公有变量，可以跨类调用
     }
  一下简化言之
  public :在同一个工程项可以到处使用
  protected:在同一个包中可以被使用，不在同一个包中的子类也可以被使用。
  默认的：在同一个包中可以被使用
  private：在同一个类中可以使用
 
接口中的属性和方法必须是public，默认是public
子类再重写父类的方法时候，不能减少方法的可见范围

2.this和super
  this:1.代表当前调用该方法的对象
       public class A{
           String name;
           public void setName(String name){
                   this.name=name;
           }
           public void test(){
           }
       }
    此处的this指class这个类。
        2.表示当前类中某一个构造方法
        public class A{
       public A() {
this("默认");
}

    public A(String name) {
   this.name = name;
    }
   }
   super:1.表示当前类的父类对象
       2.调用父类的构造方法
     public class C extends A{
    
     public C(){
                   //调用父类的构造方法
     super();
     }
                    //此处super相当于父类的一个对象，可以调用父类里的方法
     public void change(){
                    //只有父类里有test方法
     super.test();
     }
       public void test(){
                  }
            }
3.final  可以用来定义类，属性，方法，变量、
      public final class A{}  这样的类不能被继承
      private final int age=100;表示只能赋值一次，必须初始化，不能被修改
      public final void test(){
       }     //这样定义的方法不能被重写
     
4.static 可以定义属性，方法，代码块
       public final  class A{
       private static String name;//这一个类所有的对象共同使用的一个变量指向同一地址
       public static void test(){} //表示这个方法的调用只和类型相关  
        } 
       static的属性和方法是不需要对象，只需要通过类名来调用
       A.name="AAA";
       A.test();
       static{
        }//这个称呼静态代码块，在函数之前执行，初始化数据
       下面举一个经典例子：
        首先创建两个类
       public class A{
           public A{
          System.out.println("A");
         }
          }
       public  class B extends A{
           public B{
          System.out,println("B");
          }
          }
         
       在创建一个主类、
       public class C{
       static A a=new A();
       B b=new B();
        public C(){
           System.out.println("C");
           }
       public static void main(String[] args){
             C.change();
          }
       public static void change(){
          B b=new B();
         }
      }
        最后运行的结果为AAB。对于此处的解释
     首先执行 static A a=new A();
     打印出“ A”;
     接着执行主函数，因为C类的方法为静态方法，所以可以直接用类名来调用方法
     change方法里创建一个B类对象，调用B类的构造方法。同时它还要先调用其父类的方法。
     故调用A类的构造方法。这一句话，最终打印出“AB”。