final和static的区别（final int i和static final int i）

本文目录

• final int i和static final int i
• Java中static和final的区别
• “static”和“final”的区别是什么
• Java中static，final和static final的区别
• java语言中 final和static 的 区别是什么
• final和static的区别
• final，static,const在使用上有什么区别
• static，final和static final的区别
• C++ 中static 和final的区别是什么

final int i和static final int i

final int i表示i是一个整形常量
static final int i表示i是一个静态整形常量
二者都是不可改变的常量，区别在于后者可以通过类名.i这种方式直接访问，而前者只能通过实例化出对象来，然后对象名.i去访问，当然前者也能通过后者这种方式去访问，static修饰之后，存放的内存位置不一样了。

Java中static和final的区别

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

“static”和“final”的区别是什么

final定义的变量可以看做一个常量，不能被改变； 

final定义的方法不能被覆盖； 

final定义的类不能被继承。 

final static 就是再加上static的特性就可以了

static 和final是没有直接关系的

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

static 和final的区别 

一、static ： 

什么情况下我们要使用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 类不可被继承。

那么，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和static final的区别

static：静态成员，存放在静态存储区中，不属于任何对象，独立于对象而存在。
final：修饰类时，该类不可被继承；修饰方法时，该方法不可被子类覆盖；修饰变量时，该变量为常量，不可被修改。
static final：既具有static属性又具有final属性的类/方法/变量。

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

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

final和static的区别

一：final
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
二：static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
　static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

final，static,const在使用上有什么区别

网上找到的,保留了
JAVA中final、staticfinal:final修饰类：该类不可继承
final修饰方法：该方法不能被子类覆盖（但它不能修饰构造函数）
final修饰字段属性：属性值第一次初始化后不能被修改
使用final可以提高程序执行的效率，将一个方法设成final后编译器就可以把对那个方法的所有调用都置入嵌入调用里。
static:static修饰成员函数则该函数不能使用this对象
static不能修饰构造函数、函数参数、局部成员变量
static修饰成员字段则当类被虚拟机加载时按照声明先后顺序对static成员字段进行初始化。
static修饰语句块：当类被虚拟机加载时按照声明先后顺序初始化static成员字段和static语句块
static所修饰的方法和字段只属于类，所有对象共享，java不能直接定义全局变量，是通过static来实现的。
java中没有const，不能直接定义常量，是通过static final组合来实现的。
C#中readonly、const
readonly、const是c#中的两种常量
readonly:为运行时常量，程序运行时进行赋值，赋值完成后便无法更改，也称为只读变量。
const:为编译时常量，程序编译时将对常量值进行解析，并将所有常量引用替换为相应值。

static，final和static final的区别

static修饰变量表示静态变量，修饰方法表示静态方法；
final通常用于修饰局部变量，表示不可变；
static final修饰变量表示常量，值不变。

C++ 中static 和final的区别是什么

• static 是静态变量，它在编译时系统就分配内存，程序结束时才释放。

1、在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在类加载的时候被创建并初始化（只被创建初始化一次），对于该类的所有对象来说，staitic成员变量只有一份。

2、用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非静态的成员。

3、可以通过对象引用或类名访问静态成员。也就是说即可使用对象引用也可使用类名来访问静态的成员变量和成员方法。

• final 是常量，不变的。

1、final的成员变量不能改变。

2、final的局部变量不能改变。（当是形参时：目的是当形参是引用型变量时，防止改变其引用型变量指向其他的对象）。