javafinal与static

⑴ java中的关键字static和final的作用是什么

java中static方法自动的就是final的吗？是不对的，他们两个是不同的定义，你可以再网上找一些资料对比下，下面简单说下static与final的作用：
static作用
是静态修饰符，什么叫静态修饰符呢？大家都知道，在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，也就是只要程序在运行，那么这块内存就会一直存在

final作用
final关键字是最终的、最后的意思，在程序中可以用来修饰类、成员变量和方法的声明，由该关键字修饰的内容都是不可变的。

⑵ Java中static和final的区别

static是静态修饰关键字，可以修饰变量和程序块以及类方法：
当定义一个static的变量的时候jvm会将将其分配在内存堆上，所有程序对它的引用都会指向这一个地址而不会重新分配内存；
当修饰一个程序块的时候(也就是直接将代码写在static{...}中)时候，虚拟机就会优先加载静态块中代码，这主要用于系统初始化；
当修饰一个类方法时候你就可以直接通过类来调用而不需要新建对象。
final可以修饰变量、方法及类：
当定义一个final变量时，jvm会将其分配到常量池中，程序不可改变其值；
当修饰一个方法时，该方法在子类中将不能被重写；
当修饰一个类时，该类不能被继承。

⑶ Java中的关键字static和final的作用

final

根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

final类不能被继承，没有子类，final类中的方法默认是final的。

final方法不能被子类的方法覆盖，但可以被继承。

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final不能用于修饰构造方法。

注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类

final类不能被继承，因此final类的成员方法没有机会被覆盖

，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2、final方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。

使用final方法的原因有二：

第一、把方法锁定，防止任何继承类修改它的意义和实现。

第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

例如：

publicclassTest1{
publicstaticvoidmain(String[]args){
//TODO自动生成方法存根
}
publicvoidf1(){
System.out.println("f1");
}
//无法被子类覆盖的方法
publicfinalvoidf2(){
System.out.println("f2");
}
publicvoidf3(){
System.out.println("f3");
}
privatevoidf4(){
System.out.println("f4");
}
}
publicclassTest2extendsTest1{

publicvoidf1(){
System.out.println("Test1父类方法f1被覆盖!");
}
publicstaticvoidmain(String[]args){
Test2t=newTest2();
t.f1();
t.f2();//调用从父类继承过来的final方法
t.f3();//调用从父类继承过来的方法
//t.f4();//调用失败，无法从父类继承获得
}
}

3、final变量（常量）

用final修饰的成员变量表示常量，值一旦给定就无法改变！

final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。

另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

packageorg.leimin;
publicclassTest3{
privatefinalStringS="final实例变量S";
privatefinalintA=100;
publicfinalintB=90;
publicstaticfinalintC=80;
privatestaticfinalintD=70;
publicfinalintE;//final空白,必须在初始化对象的时候赋初值
publicTest3(intx){
E=x;
}
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
Test3t=newTest3(2);
//t.A=101;//出错,final变量的值一旦给定就无法改变
//t.B=91;//出错,final变量的值一旦给定就无法改变
//t.C=81;//出错,final变量的值一旦给定就无法改变
//t.D=71;//出错,final变量的值一旦给定就无法改变
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C);//不推荐用对象方式访问静态字段
System.out.println(t.D);//不推荐用对象方式访问静态字段
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E);//出错,因为E为final空白,依据不同对象值有所不同.
System.out.println(t.E);
Test3t1=newTest3(3);
System.out.println(t1.E);//final空白变量E依据对象的不同而不同
}
privatevoidtest(){
System.out.println(newTest3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
publicvoidtest2(){
finalinta;//final空白,在需要的时候才赋值
finalintb=4;//局部常量--final用于局部变量的情形
finalintc;//final空白,一直没有给赋值.
a=3;
//a=4;出错,已经给赋过值了.
//b=2;出错,已经给赋过值了.
}
}

4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

publicclassTest4{
publicstaticvoidmain(String[]args){
newTest4().f1(2);
}
publicvoidf1(finalinti){
//i++;//i是final类型的,值不允许改变的.
System.out.print(i);
}
}

二、static

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表...)

类名.静态变量名

用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。

1、static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：

对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！

因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

publicclassTest5{
privatestaticinta;
privateintb;
static{
Test5.a=3;
System.out.println(a);
Test5t=newTest5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
publicstaticvoidmain(String[]args){
//TODO自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
publicvoidf(){
System.out.println("hhahhahah");
}
}

运行结果：
3
hhahhahah
1000
4
5

利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4、static和final一块用表示什么

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！

对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

对于方法，表示不可覆盖，并且可以通过类名直接访问。

特别要注意一个问题：

对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象，这一点在编程中用到很多。

也许说了这么多，反倒把你搞晕了，还是看个例子吧：

publicclassTestStaticFinal{
="aaa";
=null;
privatefinalStringstrFinalVar=null;
=0;
=newInteger(8);
privatestaticfinalArrayList<String>alStaticFinalVar=newArrayList<String>();
privatevoidtest(){
System.out.println("-------------值处理前----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
//strStaticFinalVar="哈哈哈哈";//错误，final表示终态,不可以改变变量本身.
strStaticVar="哈哈哈哈";//正确，static表示类变量,值可以改变.
//strFinalVar="呵呵呵呵";//错误,final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//intStaticFinalVar=2;//错误,final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//integerStaticFinalVar=newInteger(8);//错误,final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
alStaticFinalVar.add("aaa");//正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
alStaticFinalVar.add("bbb");//正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
System.out.println("-------------值处理后----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
}
publicstaticvoidmain(Stringargs[]){
newTestStaticFinal().test();
}
}

看了上面这个例子，就清楚很多了，但必须明白：通过static final修饰的容器类型变量中所“装”的对象是可改变的。这是和一般基本类型和类类型变量差别很大的地方。

⑷ Java中static 和final的区别

static 表示的是静态方法
final 表示最终的
final常用在常量上, 让这个值固定, 不修改的 上面.
static常用在
1、只想用一个存储区域来保存一个特定的数据
2、我们需要一个特殊的方法，它没有与这个类的任何对象关联。可以直接调用的

⑸ java语言中 final和static 的 区别是什么

final 被修饰的变量为常量一旦赋值不能修改,被修改的方法为最终方法不能

被重写，被修饰的类是最终类，不能被继承

static 被修饰的变量和方法，为该整个类及其类的对象所共享，一个类或对

象修改了被定义的类或方法，其他的也会跟着变量。。这就是说被static修饰的

是大家共用的。。

就一块肥皂多个人用，每个人用都会少而不是像不用static修饰的是每个人有

每个人的肥皂，你用自己的和别人没有关系。。

祝你好运！

如果还是不很明白，到我空间转转也许会更明白。。。

⑹ final和static的区别 java

当修饰一个类方法时候你就可以直接通过类来调用而不需要新建对象。
final可以修饰变量、方法及类：
当定义一个final变量时，jvm会将其分配到常量池中，程序不可改变其值；
当修饰一个方法时，该方法在子类中将不能被重写；
当修饰一个类时，该类不能被继承。

⑺ Java中 final和static修饰的变量有什么区别

final定义的变量可以看做一个常量，不能被改变；
final定义的方法不能被覆盖；
final定义的类不能被继承。
final static 就是再加上static的特性就可以了

static 和final是没有直接关系的

static 是在内存中分配一块区域，供整个类通用，所有的类的对象都享有共同的值static 和final的区别 。

一、static ：

1、只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创 建对象。

2、需要一个特殊的方法，没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。
为满足这两方面的要求，可使用static（静态）关键字。
下面先举个例子：

一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起。所以尽管从未创建那个类的一个对象，仍能调用一个static方法，或访问一些static数据。
为了将数据成员或方法设为static，只需在定义前置和这个关键字即可。
例如，下述代码能生成一个static数据成员，并对其初始化：

class StaticTest {
Static int i = 47;
}

现在，尽管制作了两个StaticTest对象，但仍然只占据StaticTest.i的一个存储空间。这两个对象都共享同样的i。请考察下述代码：
StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();
此时，无论st1.i还是st2.i都有同样的值47，因为引用的是同样的内存区域。
有两个办法可引用一个static变量。正如上面展示的那样，可通过一个对象命名，如st2.i。亦可直接用类名引用，而这在非静态成员里是行不通的（最好用这个办法引用static变量，因为强调了那个变量的“静态”本质）。
StaticTest.i++;
其中，++运算符会使变量增值。此时，无论st1.i还是st2.i的值都是48。

类似的逻辑也适用于静态方法。既可象对其他任何方法那样通过一个对象引用静态方法，亦可用特殊的语法格式“类名.方法()”加以引用。静态方法的定义是类似的：
class StaticFun {
static void incr() { StaticTest.i++; }
}
从中可看出，StaticFun的方法incr()使静态数据i增值。可用典型的方法调用incr()：

StaticFun sf = new StaticFun();
sf.incr();

或者，由于incr()是一种静态方法，所以可通过类直接调用：
StaticFun.incr();
对方法来说，static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法。

举简单一例如下：
public class TestStatic {
public static void main(String args[]){
PhoneCard mycard_1 = new PhoneCard();//创建第一张卡对象
PhoneCard mycard_2 = new PhoneCard();//创建第二张卡对象

mycard_1.addFee = 0.8;//给第一张卡的附加费addFee赋值为0.8
//注意到我们没有给第二张卡赋值

System.out.println("第一张卡的附加费：" + mycard_1.addFee);
System.out.println("第二张卡的附加费：" + mycard_2.addFee);
//发现没有？输出结果中第二张卡的附加费也是0.8 了。
System.out.println("卡的附加费：" + PhoneCard.addFee);
//该句的打印输出表明卡类的附加费都是0.8
}
}

class PhoneCard{
static double addFee;//静态域addFee
}

该例创建了两个类，PhoneCard类只定义了一个变量，TestStatic类里创建了两个PhoneCard类对象，并给其中的一个对象的附加费addFee赋值，而另一个对象没赋值。

由上例可以看出，静态域保存在类的公共存储单元，而不是保存在对象的存储单元内。

static 修饰方法时是同理。

二、final:

final可修饰类、域（变量和常量）、方法 （而static不修饰类)

1、final修饰类，表示该类不可被继承。
如定义了一个final类：
final class SnowBird{
int i;
String s;
static void fly(){
System.out.println("snowbird is flying");
}
}

//现在定义一个类，试图继承SnowBird类:

public class Bird extends SnowBird{
public static void main(String[] args){
SnowBird.fly();
}
}

把上面的两个类拷贝到文件中，文件名保存为Bird.java

出错信息是：cannot inherit from final SnowBird
表明final 类不可被继承。

2、final修饰变量
程序中经常需要定义各种类型的常量，如：3.24268,"201"等等。这时候就用final来修饰一个类似于标志符名字。如：final String connectNumber = "201";

final表明 connectNumber是一个常量，取值在整个过程都不会改变。

如果把final 去掉则connectNumber就成为变量了。

有时为了节省空间，常量通常声明为 static .因为如上所说的 static 用的是类的内存空间。

3、修饰方法：
final修饰的方法，称为最终方法。最终方法不可被子类重新定义，即不可被覆盖。
如父类定义了public void fly(){ ....}
则子类就不能定义
public void fly(){。。。。。。}
但注意覆盖与重载的区别。不能被覆盖并不是不能被重载，如你还可以定义
public void fly(int i){.....}，

举个例子如下：

class FinalValue {
static final int i = 1;
final void fly(){
System.out.println("SnowBird is flying over FinalValue ");
}
}

class TestFinal extends FinalValue {
int i = 2;
void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}
void fly(String s){
System.out.println("fly("+ s + ")");
}
}

public class Test {
public static void main(String args[]){
TestFinal tf = new TestFinal();
tf.fly();
tf.fly("ok");
System.out.println(tf.i);
}
}
把上面的程序保存为Test.java编译看看，出现什么错误？
然后，把TestFinal类中的 void fly(){ ... } 注解掉
即 如下
/* void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}*/

⑻ Java中static final与final的不同。

1、final可以修饰：属性，方法，类，局部变量（方法中的变量）

2、final修饰的属性的初始化可以在编译期，也可以在运行期，初始化后不能被改变。

3、final修饰的属性跟具体对象有关，在运行期初始化的final属性，不同对象可以有不同的值。

4、final修饰的属性表明是一个常数（创建后不能被修改）。

5、final修饰的方法表示该方法在子类中不能被重写，final修饰的类表示该类不能被继承。

6、对于基本类型数据，final会将值变为一个常数（创建后不能被修改）；但是对于对象句柄（亦可称作引用或者指针），final会将句柄变为一个常数（进行声明时，必须将句柄初始化到一个具体的对象。而且不能再将句柄指向另一个对象。

7、但是，对象的本身是可以修改的。这一限制也适用于数组，数组也属于对象，数组本身也是可以修改的。方法参数中的final句柄，意味着在该方法内部，我们不能改变参数句柄指向的实际东西，也就是说在方法内部不能给形参句柄再另外赋值）。

⑼ java语言中 final和static 的 区别是什么

final
被修饰的变量为常量一旦赋值不能修改,被修改的方法为最终方法不能
被重写，被修饰的类是最终类，不能被继承
static
被修饰的变量和方法，为该整个类及其类的对象所共享，一个类或对
象修改了被定义的类或方法，其他的也会跟着变量。。这就是说被static修饰的
是大家共用的。。
就一块肥皂多个人用，每个人用都会少而不是像不用static修饰的是每个人有
每个人的肥皂，你用自己的和别人没有关系。。
祝你好运!
如果还是不很明白，到我空间转转也许会更明白。。。

⑽ java 中的static和final怎么使用它们的区别

static是静态修饰关键字，可以修饰变量和程序块以及类方法：当你定义一个static的变量的时候jvm会将将其分配在内存堆上，所有程序对它的引用都会指向这一个地址而不会重新分配内存；修饰一个程序块的时候(也就是直接将代码写在static{...}中)时候，虚拟机就会优先加载静态块中代码，这主要用于系统初始化；当修饰一个类方法时候你就可以直接通过类来调用而不需要新建对象。
final可以修饰变量、方法及类，当你定义一个final变量时，jvm会将其分配到常量池中，程序不可改变其值；当你定义一个方法时，改方法在子类中将不能被重写；当你修饰一个类时，该类不能被继承。