Java final以及static用法简单demo

Java Final 修饰符

final 终结的，最终的。final 可以修饰类，方法和变量。

修饰类

final修饰类时表示类不可以被继承，是最终类。

public final class FinalTest {

}

//error ChildFinalTest class can not extends FinalTest, because it is final class
class ChildFinalTest extends FinalTest
{

}

修饰方法

package javaecho;

public  class FinalTest {
public final void FinalMethod()
{

}

public void NonFinalMethod()
{

}

}

//error ChildFinalTest class can not extends FinalTest, because it is final class
class ChildFinalTest extends FinalTest
{

public final void NonFinalMethod()
{

}

//error, can not override final method
public void FinalMethod()
{

}

}

修饰变量

变量只能被初始化一次，就不能改变, final 变量可以先申明，后初始化。

public  class FinalTest {
private final int money;
private final int cost =100;
FinalTest()
{
money = 10;
}

}

final作为内部类参数

变量作为内部类参数时，必须使用final修饰。其原因是非final变量和内部类的作用域不一样，final 提示编译器拷贝一份，并且保持值不变，这样就不会影响返回的内部类。

public  class FinalTest {
public static void test(final int cost)
{
FinalTestAbstract ft =  new FinalTestAbstract(cost){
public void AbstractMethod()
{
System.out.println(cost);
}
};
ft.AbstractMethod();
}

public static void main(String[] args)
{
FinalTest.test(30);
}

}

abstract class FinalTestAbstract{
private int cost;
FinalTestAbstract(int costvar)
{
this.cost = costvar;
}
public abstract void AbstractMethod();
}

Java Static 修饰符

static 修饰符提示编译器把类，方法和变量放在静态存储区域还是非静态区域。

修饰内部类

Statc 内部类的好处是，不必拥有对应的java对象，便可以使用该类，同时其他类中的静态方法也可以使用该内部类。

public  class StaticTestClass {

public static class InnerClass
{
private int cost;
public int getCost() {
return cost;
}
public void setCost(int cost) {
this.cost = cost;
}
public InnerClass(int costvar) {
this.cost = costvar;
}
}

public static InnerClass getInner(int cost)
{
return new InnerClass(cost);
}

public static void main(String[] args)
{
System.out.println(getInner(100).getCost());
InnerClass ic =new StaticTestClass.InnerClass(18);
}

}

修饰方法

静态方法可以使得，不需要实例化类也可以访问该方法。

public  class StaticTestClass {

public static void test()
{
System.out.println("test");
}

public static void main(String[] args)
{
StaticTestClass.test();
}

}

修饰变量
public静态变量可以直接暴露访问，private 静态变量可以由类中内部静态方法访问。

public class MainClass
{
public static void main(String[] args)
{
System.out.println(StaticClass.cost);
//error,can not visit private static var
//System.out.println(StaticTestClass.save);
System.out.println(StaticClass.GetSave());
}
}

class StaticClass {

private static int save;
public static int cost;
public static int GetSave()
{
return save;
}

}

Static final变量

相当于一个全局变量（前提是public的）