java编码中一些值得注意的语法

1. 常量一般用大写，定义成静态的，如 static final PI=3.1415

2. 静态方法不能访问非静态的方法或非静态的成员变量，反之则可以．

3. 特殊变量super提供了对父类的访问，可以使用super访问被子类隐藏的变量或被子类覆盖的方法；每个子类被构造时，都隐式地调用supper()，所以说，父类必须提供相应的构造函数；即子类实例化时，调用了子类的构造方法之前，先调用父类的构造方法。因为子类，隐式地调用了supper()方法。

4. 多态性：通过覆盖父类的方法来实现，在运行时根据传递对象的引用来调用相应的方法。如果传递的是子类对象的引用，则调用的是子类的方法，如果子类没有该方法则调用的是父类的方法。如果传递的是父类对象的引用，则调用的是父类的方法。

 5. 类的访问说明符：
 （1）public
 （2）default（不加访问说明符时）
类的其它修饰符
 （1）final：public final class test{}——不希望该类被继承。
 （2）abstract：public abstract class test{}——含有抽象方法的类，即为抽象类。如果一个子类没有实现抽象基类中所有的抽象方法，则子类也成为一个抽象类，所以一个类如果是抽象类的子类，并且该类又不是抽象类，则必须实现抽象类中所有的抽象方法。由于抽象类中的抽象方法没有实体，无法决定其形态，所以抽象类不能直接被实例化。我们也可以将一个没有任何抽象方法的类声明为abstract，避免由这个类产生任何的对象。

6. 方法的说明
方法的访问说明符
 （1）public：全部能访问。
 （2）protected：不同包，并且类没有关系的不能访问（如果是不同包的子类可以访问）。
 （3）default(不加访问说明符时)：在同包中可以访问。
 （4）private：只限于同类中访问。
方法的其它修饰符
 （1）static：静态方法属于类
 （2）final：为了确保某个函数的行为在继承过程中保持不变，并且不能被覆盖（overridden），可以使用final方法。class中所有的private和static方法自然就是final。
 （3）abstract：在类中没有方法体的方法，就是抽象方法。如：public abstract void test(); （后面有分号）；构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法。
 （4）native：native方法是用户在Java中可以使用，但不能编写的方法。
JNI(Java Native Interface)，它允许Java虚拟机(JVM)内部运行的Java代码能够与用其它编程语言(如C、C++、汇编语言)编写的应用程序和库进行互操作。
JNI最大的好处是它没有对底层Java虚拟机的实现施加任何限制，因此，Java虚拟机厂商可以在不影响虚拟机其它部分的情况下添加对JNI的支持。程序员只需编写一种版本的本地(Native)应用程序和库，就能够与所有支持JNI的Java虚拟机协同工作。
JNI可以理解为Java和本地应用程序之间的中介
 （5）synchronized：native方法是用户在Java中可以使用，但不能编写的方法。JNI(Java Native Interface)，它允许Java虚拟机(JVM)内部运行的Java代码能够与用其它编程语言(如C、C++、汇编语言)编写的应用程序和库进行互操作。JNI最大的好处是它没有对底层Java虚拟机的实现施加任何限制，因此，Java虚拟机厂商可以在不影响虚拟机其它部分的情况下添加对JNI的支持。程序员只需编写一种版本的本地(Native)应用程序和库，就能够与所有支持JNI的Java虚拟机协同工作。JNI可以理解为Java和本地应用程序之间的中介。

7. 垃圾回收器
　　垃圾回收器是低优行级的线程，并且在后台自动过行。当它只有在内存不够时才会回收垃圾，或者程序退出时才会释放垃圾对象。可以通过如下方法，打印出回收对象：portected void finalize(){　System.out.println("test");}，可以通过System.gc()；来显示的打印垃圾回收过程。

8. 接口
　　当一个类实现接口时，该类接口中的方法必须是public。同样，声明一个接口时，该接口下的所有方法必须是public  abstract 修饰符，或者方法不加认识修饰符（默认的为：public abstract）。

9. 内部类
　　1. 在一个类中定义另外一个类，这个类就叫做内部类或内置类 (inner class) 。内部类可以让我们将逻辑上相关的一组类组织起来，并由外部类(outer class)来控制内部类的可见性。当我们建立一个inner class时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的 this reference 形成的，使得内部类对象可以随意的访问外部类中所有的成员。
　　2. 在一个内部类中，可以访问它的外部类对应的私有成员变量．
　　3. 如果在一个内部类中，类中定义了变量a，该内部类的方法中也定义了一个变量a，同样该内部类所对应的外部类也定义了变量a，则在内部类的方法中，得到的次序分别为：a；this.a；outer.this.a（outer是类名）．
　　注：
　　一、如果在另外一个类中，需要访问具有内部类并且访问该内部类中的方法时
　　第一种方法：必须做两点，第一：在具有内部类的类中定义一个返回内部类对象的方法。第二：实例化对部的对象时，采用：
Outer outer=new Outer();　　　
Outer.Inner inner=outer.getInner();　
其中getInner（）是Outer类定义的一个返回Outer类中内部类的一个对象。由于另外的类，对于一个内部类来说是隐藏的，所以必须用Outer.Inner。
　　第二种方法：直接实例化
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner()；
　　
　　二、当将一个类a，定义在一个类b中的某一个方法　C(　)　里面时，限定了该类的使用范围，即只能在该类a 的方法C( )中才能访问该类。类a，也可以放在类b中的方法 c( )某一个 if 条件中。所以内部类的定义是非常灵活的，无论内部类的嵌套层次有多深，类a都可以访问类b的所有成员变量。如：类名.this.成员变量名
　　在方法中 C( ) 定义的内部类，如果要访问方法中定义的本地变量或方法的参数，则变量必须被声明final（即声明为常量）。才能使用C( )方法中的变量被该方法中的内部类所访问。

　　三、内部类可以声明为private或protected；还可以声明为abstract或final。内部类可以声明为static的，但此时就不能再使用外部类的非static的成员变量和非static的成员方法；非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员。

　　四、我们为什么使用内部类
　　1、在内部类（inner class）中，可以随意的访问外部类的成员，这可以让我们更好地组织管理我们的代码，增强代码的可读性。
　　2、内部类可以用于创建适配器类，适配器类是用于实现接口的类。使用内部类来实现接口，可以更好地定位与接口关联的方法在代码中的位置。
　　3、内部类的更多用法。（通过内部类定义成private，实施细节的隐藏，通过接口类来实现内部类priavte的访问）如下所示：

interface Animal {  void eat();  void sleep(); } class Zoo {  private class Tiger implements Animal  {   public void eat()   {    System.out.println("tiger eat");   }   public void sleep()   {    System.out.println("tiger sleep");   }  }  Animal getAnimal()  {   return new Tiger();  } } class Test {  public static void main(String[] args)  {   Zoo z=new Zoo();   Animal an=z.getAnimal();   an.eat();   an.sleep();  } }

　　总之，内部类的好处不止这些，真正参与到项目的实践应用，你会发现内部类的实用价值。再举例如下，一个类通过内部类实现了多重继承。

class A {  void fn1()  {  } } abstract class B {  abstract void fn2(); } class C extends A {  B getB()  {   return new B()   {    public void fn2()    {    }   };  } } class Test {  static void method1(A a)  {   a.fn1();  }  static void method2(B b)  {   b.fn2();  }  public static void main(String[] args)  {   C c=new C();   method1(c);   method2(c.getB());  } }

　　五、当一个类Ａ继承另一个类Ｂ的内部类Ｃ时，必须要先实例化类Ｂ。如下代码所
class B
{
 class C
 {
 }
}
class A extends B.C
{
 A(B b)
 {
  b.super();  // 建立一个从内部类对象到指定的一个外部类对象的引用关系
 }
 public static void main(String[] args)
 {
  B b=new B();
  A a=new A(b);
 }
}