final和static的使用

Final:

1.       final修饰变量：通常用final定义的变量为常量，其值在定义时就要赋值。Final的常量需要定义时使用大写字母命名，且中间需要使用下划线进行连接，这是java的编程规则。

2.       fianl与static联用：既用static又用final修饰的字段只占一段不可改变的存储空间。

3.       修饰引用：用final修饰的引用只能恒定指向一个对象，无法将其指向其它对象。但对象的值可以改变。

4.       修饰方法：将方法定义为final类型可以防止任何子类修改该类的定义与实现方式，且运行效率高。如果父类的一个方法被设置为private，子类将无法访问该方法，自然无法覆盖该方法，所以一个定义为private的方法隐式被指定为final类型，这样的话无需将一个定义为private的方法再定义为final类型。

但是在父类中定义为final的方法似乎可以被子类覆盖。见下例代码。从表面上看是子类覆盖了父类的doit方法，但是覆盖必须满足一个对象向上转型为它的基本类型并调用相同方法这样的条件。结果是只是子类生成了一个新的方法而已。子类并不能继承父类中的doit方法，

public class FinalMethod

{

       public static void main(String args[])

       {

              Sub s=new Sub();

       s.doit();

              Parents p=s;

              //p.doit();//不能调用private方法，也就是不能继承父类的私有类

              p.doit2();//可以覆盖父类的final方法

              p.doit3();

       }

}

       class Parents

       {

              private final void doit()

              {

             

              System.out.println("fulei.doit");

       }

              final void doit2()

              {

                     System.out.println("fulei.doit2");

             

       }

              public void doit3()

              {

                     System.out.println("fulei.doit3");

       }

       }

      

       class Sub extends Parents

       {

              public final void doit()

              {

                     System.out.println("子类.doit");

       }

       /*    final void doit2()//final方法不能被覆盖

              {

                     System.out.println("子类.doit2");

              }*/

              public void doit3()

              {

                     System.out.println("子类.doit3");

              }

       }

程序分析：

/*public class FinalEX{

       public static void main(String args[]){

              B b=new B();

       //     b.sum(5,6);

       b.kk();

       b.a.sum(5,7);

       final int z=8;//final修饰的变量就成了常量，其值不能在改变

       System.out.println("z="+z);

       }

}

final class A{//final类 后不能被继承

   public final void sum(int x,int y){

     System.out.println("x+y="+(x+y));

   }      

}

class B //extends A

{

       A a=new A();

       void kk(){

              a.sum(5,6);//final类的方法可以调用

       }

       /*void sum(int x,int y)//final修饰的方法无法被继承

       {

              System.out.println("x+y="+(x+y));

       }*/

//}*/

public class FinalEX{

       public static void main(String args[])

       {

              A a=new A();

              System.out.println("a.i="+a.i);

              B b=new B();

              System.out.println("b.i="+b.i);

       }

}

class A

{

       final int i=8;

}

class B extends A

{

        int i=78;

}

Static:

Static用法分析

public class Test1{

       public static void main(String args[])

       {

              Person a=new Person();

             

              System.out.println(Person.sclass);//可以直接调用静态变量

              System.out.println(a.sname);//非静态变量需要先创建对象后调用

           Person.kk();

           a.yy();

       }

}

class Person{

       String sname;

       static int sclass=10;

       static void kk()

       {

              System.out.println("static kk"+sclass);//静态方法中可以访问静态变量，但不可访问非//静态变量

       }

       void yy()

       {

              System.out.println("yy"+sclass+sname);//非静态方法可以访问静态和非静态变量

       }

}