Java中为什么会有final变量】:

final这个关键字的含义是“这是无法改变的”或者“终态的”;

那么为什么要阻止改变呢?

java语言的发明者可能由于两个目的而阻止改变:

1).效率问题:

jdk中的某些类的某些方法,是不允许被用户覆盖的,设计者可能认为,所用方法已经是最好的方法,

用户私自覆盖,或是由于疏忽而覆盖,就会影响JVM或是系统的系能;

2). 设计所需:

众所周知,有些情况必须使用final关键字,比如方法中的匿名内部类的参数传递;

【final关键字的使用方法】:

【修饰变量】:

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

【修饰方法】:

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

【修饰类】:

final类不能被继承,没有子类,final类中所有方法都是final的。

【final的内存分配方式】:

【修饰变量】:

通常情况下,final变量有3个地方可以赋值:直接赋值,构造函数中,或是初始化块中。

【初始化】:

由于在java的语法中,声明和初始化是联系在一起的,

也就是说:如果你不显示的初始化一个变量,系统会自动用一个默认值来对其进行初始化。(如int就是0)

对于final变量,在声明时,如果你没有赋值,系统默认这是一个空白域,在构造函数进行初始化,

如果是静态的,则可以在初始化块。

【内存】:

常量(final变量)和非final变量的处理方式是不一样的。

每一个类型在用到一个常量时,都会复制一份到自己的常量池中。

常量也像类变量(static)一样保存在方法区,只不过他保存在常量池。

(可能是,类变量被所有实例共享,而常量池是每个实例独有的。)

【修饰方法】:

保存在方法区,并且可以被函数代码直接替换,而不用等到执行时再决定具体是那个函数。

【修饰类】:

保存在方法区。

【java中变量的初始化顺序】:

变量的初始化次序优于任何方法,甚至在构造方法的前面。对于static变量也是一样,

如果变量是原始类型,那么它得到一个标准的原始类型的初始值,

如果是一个对象的引用,除非你创建了一个新的对象给这个引用,否则就是null。

static变量在需要的时候才会初始化,并且在这个类的构造函数和所有其他普通变量之前调用,static之后就不再进行初始化了,

static变量在类初始化时(注意不是实例),就必须分配内存空间,

static变量单独划分一块存储空间。

java类首次装入时,会对静态成员变量或方法进行一次初始化,

先初始化父类的静态代码-->初始化子类的静态代码-->

(创建使历史,如果不创建实例,则后面的不执行)初始化父类的非静态代码-->初始化父类的构造

-->初始化子类的非静态代码-->初始化子类的构造

类只有在使用new调用创建的时候才会被java类装载器装入。

【final方法为何会高效】:

final方法会在编译的过程中利用内嵌机制进行inline优化。

inline优化是指:在编译的时候直接调用函数代码替换,而不是在运行时调用函数。

inline需要在编译的时候就知道最后要用哪个函数,

显然,非final是不行的。

非final方法可能在子类中被重写,由于可能出现多态的情况,编译器在编译阶段

并不能确定将来调用方法的对象的真正类型,也就无法确定到底调用哪个方法。

【什么是多态】:

按字面的意思是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。

简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。

【非final方法为什么会出现多态】:

显然,如果派生出一个子类,覆盖非final方法,就会出现2个这样的方法可供调用,这就是多态。

【final变量的变与不变】:

有人说final变量在赋值后就不可变,

那么这个不变到底指的是什么呢?

这个不变指的是引用,是地址,而所引用的对象的内容仍然是可变的。

就是说,这个final变量永远指向某个对象,是一个常量指针,而不是指向常量的指针。

一、final
        根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。
        final类不能被继承,没有子类,final类中的方法默认是final的。
        final方法不能被子类的方法覆盖,但可以被继承。
        final成员变量表示常量,只能被赋值一次,赋值后值不再改变。
        final不能用于修饰构造方法。
        注意:父类的private成员方法是不能被子类方法覆盖的,因此private类型的方法默认是final类型的。
1、final类
        final类不能被继承,因此final类的成员方法没有机会被覆盖,默认都是final的。在设计类时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会载被扩展,那么就设计为final类。
2、final方法
        如果一个类不允许其子类覆盖某个方法,则可以把这个方法声明为final方法。
        使用final方法的原因有二:
        第一、把方法锁定,防止任何继承类修改它的意义和实现。
        第二、高效。编译器在遇到调用final方法时候会转入内嵌机制,大大提高执行效率。
        例如:
publicclass Test1 {
publicstaticvoid main(String[] args) {
// TODO 自动生成方法存根
}
publicvoid f1() {
    System.out.println("f1");
}
//无法被子类覆盖的方法
publicfinalvoid f2() {
    System.out.println("f2");
}
publicvoid f3() {
    System.out.println("f3");
}
privatevoid f4() {
    System.out.println("f4");
}
}
publicclass Test2 extends Test1 {
publicvoid f1(){    
    System.out.println("Test1父类方法f1被覆盖!");
}
publicstaticvoid main(String[] args) {
    Test2 t=new Test2();
    t.f1();    
    t.f2(); //调用从父类继承过来的final方法
    t.f3(); //调用从父类继承过来的方法
//t.f4(); //调用失败,无法从父类继承获得
}
}
3、final变量(常量)
        用final修饰的成员变量表示常量,值一旦给定就无法改变!
        final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。
        从下面的例子中可以看出,一旦给final变量初值后,值就不能再改变了。

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

package org.leizhimin;
publicclass Test3 {
privatefinal String S = "final实例变量S";
privatefinalint A = 100;
publicfinalint B = 90;
publicstaticfinalint C = 80;
privatestaticfinalint D = 70;
publicfinalint E; //final空白,必须在初始化对象的时候赋初值
public Test3(int x) {
                E = x;
        }
/**
         * @param args
         */
publicstaticvoid main(String[] args) {
                Test3 t = new Test3(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);
                Test3 t1 = new Test3(3);
                System.out.println(t1.E); //final空白变量E依据对象的不同而不同
        }
privatevoid test() {
                System.out.println(new Test3(1).A);
                System.out.println(Test3.C);
                System.out.println(Test3.D);
        }
publicvoid test2() {
finalint a;     //final空白,在需要的时候才赋值
finalint b = 4;    //局部常量--final用于局部变量的情形
finalint c;    //final空白,一直没有给赋值.    
                a = 3;
//a=4;    出错,已经给赋过值了.
//b=2; 出错,已经给赋过值了.
        }
}
4、final参数
        当函数参数为final类型时,你可以读取使用该参数,但是无法改变该参数的值。
publicclass Test4 {
publicstaticvoid main(String[] args) {
new Test4().f1(2);
        }
publicvoid f1(finalint i) {
//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将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。例如:

publicclass Test5 {
privatestaticint a;
privateint b;
static {
                Test5.a = 3;
                System.out.println(a);
                Test5 t = new Test5();
                t.f();
                t.b = 1000;
                System.out.println(t.b);
        }
static {
                Test5.a = 4;
                System.out.println(a);
        }
publicstaticvoid main(String[] args) {
// TODO 自动生成方法存根
        }
static {
                Test5.a = 5;
                System.out.println(a);
        }
publicvoid f() {
                System.out.println("hhahhahah");
        }
}
运行结果:
3
hhahhahah
1000
4
5
        利用静态代码块可以对一些static变量进行赋值,最后再看一眼这些例子,都一个static的main方法,这样JVM在运行main方法的时候可以直接调用而不用创建实例。
4、static和final一块用表示什么
        static final用来修饰成员变量和成员方法,可简单理解为“全局常量”!
        对于变量,表示一旦给值就不可修改,并且通过类名可以访问。
        对于方法,表示不可覆盖,并且可以通过类名直接访问。
        特别要注意一个问题:
        对于被static和final修饰过的实例常量,实例本身不能再改变了,但对于一些容器类型(比如,ArrayList、HashMap)的实例变量,不可以改变容器变量本身,但可以修改容器中存放的对象,这一点在编程中用到很多。
        也许说了这么多,反倒把你搞晕了,还是看个例子吧:
publicclass TestStaticFinal {
privatestaticfinal String strStaticFinalVar = "aaa";
privatestatic String strStaticVar = null;
privatefinal String strFinalVar = null;
privatestaticfinalint intStaticFinalVar = 0;
privatestaticfinal Integer integerStaticFinalVar = new Integer(8);
privatestaticfinal ArrayList<String> alStaticFinalVar = new ArrayList<String>();
privatevoid test() {
                System.out.println("-------------值处理前----------\r\n");
                System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
                System.out.println("strStaticVar=" + strStaticVar + "\r\n");
                System.out.println("strFinalVar=" + strFinalVar + "\r\n");
                System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
                System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n");
                System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
//strStaticFinalVar="哈哈哈哈";        //错误,final表示终态,不可以改变变量本身.
                strStaticVar = "哈哈哈哈";                //正确,static表示类变量,值可以改变.
//strFinalVar="呵呵呵呵";                    //错误, final表示终态,在定义的时候就要初值(哪怕给个null),一旦给定后就不可再更改。
//intStaticFinalVar=2;                        //错误, final表示终态,在定义的时候就要初值(哪怕给个null),一旦给定后就不可再更改。
//integerStaticFinalVar=new Integer(8);            //错误, final表示终态,在定义的时候就要初值(哪怕给个null),一旦给定后就不可再更改。
                alStaticFinalVar.add("aaa");        //正确,容器变量本身没有变化,但存放内容发生了变化。这个规则是非常常用的,有很多用途。
                alStaticFinalVar.add("bbb");        //正确,容器变量本身没有变化,但存放内容发生了变化。这个规则是非常常用的,有很多用途。
                System.out.println("-------------值处理后----------\r\n");
                System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
                System.out.println("strStaticVar=" + strStaticVar + "\r\n");
                System.out.println("strFinalVar=" + strFinalVar + "\r\n");
                System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
                System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n");
                System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
        }
publicstaticvoid main(String args[]) {
new TestStaticFinal().test();
        }
}
运行结果如下:
-------------值处理前----------
strStaticFinalVar=aaa
strStaticVar=null
strFinalVar=null
intStaticFinalVar=0
integerStaticFinalVar=8
alStaticFinalVar=[]
-------------值处理后----------
strStaticFinalVar=aaa
strStaticVar=哈哈哈哈
strFinalVar=null
intStaticFinalVar=0
integerStaticFinalVar=8
alStaticFinalVar=[aaa, bbb]
Process finished with exit code 0
        看了上面这个例子,就清楚很多了,但必须明白:通过static final修饰的容器类型变量中所“装”的对象是可改变的。这是和一般基本类型和类类型变量差别很大的地方。

成员内部类:
相当于类的非静态成员,可以用权限修饰符来修饰,包括private、protected、public.

1、定义成员内部类

class Outter {

//非静态内部类

class Inner {

//内部类成员

int i = 12;

}

//外部类的普通成员

int j = 0;

}

2、外部类之内创建成员内部类对象

语法和普通的创建对象相同,用new操作符调用相应的构造方法即可。注意的是,非静态内部类属于外部类的非静态成员,不能在静态上下文使用。

例子:

class Outter {

//非静态内部类

class Inner {

//内部类成员

int i = 12;

public void innerTest() {

System.out.println(“Inner Class Method”);

}

}

//外部类的普通成员

int j = 0;

public void test() {

Inner inner = new Inner();

inner.innerTest();

}

}

3、外部类之外创建成员内部类对象

既然是外部类的非静态成员,就必须在外部类对象存在的情况下使用。

基本语法是

<外部类类名>.<内部类类名> 引用变量名称 = <外部类对象的引用>.new <内部类构造器>;

<外部类类名>.<内部类类名> 引用变量名称 = new <外部类构造器>.new <内部类构造器>;

(1)、创建内部类对象时对象引用必须是<外部类类名>.<内部类类名>

(2)、调用内部类的构造方法不能直接用new 而是要用<外部类对象的引用>.new调用

例子:

class Outter {

//非静态内部类

class Inner {

//内部类成员

int i = 12;

public void innerTest() {

System.out.println(“Inner Class Method”);

}

}

//外部类的普通成员

int j = 0;

}

class MainTest {

public static void main(String[] args) {

Outter outter = new Outter();

Outter.Inner inner = outter.new Inner();

inner.innerTest();

}

}

在外部类之外访问内部类时需要注意权限修饰符的限制,这点和类成员一样。

3、内部类编译后生成的.class文件名称格式是<外部类类名>$<内部类类名>。

4、内部类与外部类之间的成员互相访问

内部类可以访问外部类的任何成员,包括private成员。

外部类访问内部类的成员需要创建内部类的对象,之后可以访问内部类的任何成员,包括private成员,需要注意的是成员内部类不可以有静态成员。

当外部类的成员和内部类的成员重名时单单用this是区分不了的。在内部类中访问外部类的成员时可以用如下语法区分

<外部类类名>.this.<外部类中需要被访问的成员名>;

局部内部类

内部类定义在方法中成为局部内部类,只在局部有效。该类只为所在的方法块服务。

局部内部类和成员内部类一样可以访问外围类的所有成员,但是不可以访问同在一个局部块的普通局部变量。如果要访问,此局部变量要被声明称final的。

代码块结束后普通的局部变量会消亡,而创建的局部内部类对象并不会随着语句块的结束而消亡。final的局部变量的存储方式和普通的局部变量不同,其不会因为语句块的结束而消失,还会长期存在,因此可以被局部内部类访问。

例子:

public class InnerClassTest1 {

public static void main(String[] args) {

Outter outter = new Outter();

ForInner forInner = outter.getInner();

forInner.sayHello();

}

}

class Outter {

ForInner forInner;

public ForInner getInner() {

class Inner implements ForInner {

public void sayHello() {

System.out.println("你好,我是局部内部类对象,我还存在!");

}

}

forInner = new Inner();

return forInner;

}

}

interface ForInner {

void sayHello();

}

由于局部内部类只在局部有效,所以不能在外面用局部内部类的引用指向局部内部类的对象,只能用局部内部类实现接口并创建局部内部类对象,在外面用接口引用指向局部内部类对象。

静态方法中的局部内部类只能访问外围类的静态成员,访问不了非静态成员。

局部内部类生成的.class文件名称是<外部类类名>$<n><内部类类名>其中n是该局部的第几个内部类

静态内部类

静态内部类的定义

class Outter {

static class Inner {

/****/

}

}

由于静态内部类是外部类的静态成员,所以静态内部类只能访问外部类的静态成员。并且创建静态内部类的对象不依赖外部类的对象。在外部类之外创建静态内部类对象的语法如下

<外部类类名>.<内部类类名> 引用变量名 = new <外部类类名>.<内部类构造器>;

例子:

class Outter {

static class Inner {

public void sayHello() {

System.out.println(“成功创建静态内部类对象!”);

}

}

public void getInner() {

//在外部类中创建静态内部类的对象

Inner ii = new Inner();

ii.sayHello();

}

}

public class MainTest {

public static void main(String[] args) {

//在外部类外创建静态内部类的对象

Outter.Inner i = new Outter.Inner();

i.sayHello();

//在外部类中使用静态内部类的对象

new Outter().getInner();

}

}

静态内部类实际上已经脱离了外部类的控制,创建对象时也不再需要外部类对象的存在,实质上只是一个放置在别的类中的普通类而已。

匿名内部类

基于继承的匿名内部类,语法如下:

new <匿名内部类要继承父类的对应构造器> {

//匿名内部类类体

};

基于实现接口的匿名内部类,语法如下:

new <接口名> {

//匿名内部类类体,实现接口中的所有方法

}

匿名内部类中使用外面的变量要被声明成final的。

匿名内部类对象初始化的代码可以写在其非静态块中

匿名内部类生成的.class文件是<外部类类名>$<n>.class n是该类的第几个匿名内部类。

各种内部类可用的修饰符

成员内部类

final、abstract、public、private、protected、static

静态内部类

final、abstract、public、private、protected

局部内部类

final、abstract

匿名内部类

不能对匿名内部类使用修饰符

内部接口

定义在类中的内部接口无论是否被static修饰都是静态成员。

内部接口声明成private的意味着只能被外部类中的某个内部类来实现。

内部接口不能扮演局部的角色,否则编译报错。因为接口的设计初衷是对外公布,让很多类实现,而局部的角色违背了接口的设计初衷。

接口中的内部接口属于接口的成员,具有接口成员的所有属性,不能用private进行修饰。

外部接口外实现内部接口的语法如下:

class <类名> implements <外部接口名>.<内部接口名> {

//类体

}

接口(interface)可以说成是抽象类的一种特例,接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型,接口中的成员变量类型默认为public static final (这里需要说一点,既然一个变量被final修饰了,那么这个变量就是一个常量!!!!!变量必须初始化成常量!!!!!)

下面比较一下两者的语法区别:

1.抽象类可以有构造方法,接口中不能有构造方法。

2.抽象类中可以有普通成员变量,接口中没有普通成员变量!!!!!!!(注意重点在 普通 即 非静态  和  变量!!!!)

3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public,protected和(默认类型,虽然eclipse下不报错,但应该也不行),但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法(static),接口中不能包含静态方法.

6. 抽象类和接口中都可以包含静态成员变量(static),抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。

7. 一个类可以实现多个接口,但只能继承一个抽象类。

参数

  抽象类 接口
默认的方法实现 它可以有默认的方法实现 接口完全是抽象的。它根本不存在方法的实现
实现 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。 子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器 抽象类可以有构造器 接口不能有构造器
与正常Java类的区别 除了你不能实例化抽象类之外,它和普通Java类没有任何区别 接口是完全不同的类型
访问修饰符 抽象方法可以有publicprotecteddefault这些修饰符 接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法 抽象方法可以有main方法并且我们可以运行它 接口没有main方法,因此我们不能运行它。
多继承 抽象方法可以继承一个类和实现多个接口 接口只可以继承一个或多个其它接口
速度 它比接口速度要快 接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。
添加新方法 如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。 如果你往接口中添加方法,那么你必须改变实现该接口的类。

final 内部类 static的更多相关文章

  1. final、static、代码块、静态代码块、内部类、代码执行顺序

    final final域使得确保初始化安全性(initialization safety)成为可能,初始化安全性让不可变形对象不需要同步就能自由地被访问和共享 作用在类上               ...

  2. Java学习--final与static

    final是java的关键字,它所表示的是“这部分是无法修改的”. 编译期常量,它在类加载的过程就已经完成了初始化,所以当类加载完成后是不可更改的,编译期可以将它代入到任何用到它的计算式中,也就是说可 ...

  3. 深入理解final和static关键字

    深入理解final和static关键字 参考:http://blog.csdn.net/qq1028951741/article/details/53418852 final关键字 final关键字可 ...

  4. Java中static、final、static final的区别(转)

    说明:不一定准确,但是最快理解. final: final可以修饰:属性,方法,类,局部变量(方法中的变量) final修饰的属性的初始化可以在编译期,也可以在运行期,初始化后不能被改变. final ...

  5. 每天写两个的java常见面试题—final 和static 的用法

    第一次写随笔,可能写的比较乱,更多的是作为自己记忆一些知识的方式.所有记录的东西都是自己的一些理解,很多语言可能还是从其他大牛的博客里面搬过来的. 一.static的作用: static的的作用从三个 ...

  6. Java基础(basis)-----关键字final和static的作用

       1.关键字final      final修饰类:这个类就不能被继承      final修饰方法:不能被重写      final修饰属性:此属性就是一个常量,一旦初始化后,不可再被赋值.习惯 ...

  7. Java中static、final、static final的区别【转】

    说明:不一定准确,但是最快理解. final: final可以修饰:属性,方法,类,局部变量(方法中的变量) final修饰的属性的初始化可以在编译期,也可以在运行期,初始化后不能被改变. final ...

  8. [转] Java中的final、static、this、super

    final 关键字 final关键字主要用在三个地方:变量.方法.类. 对于一个final变量,如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改:如果是引用类型的变量,则在对其初始化之后便 ...

  9. Java中static、final、static final的区别(转)+transient

    说明:不一定准确,但是最快理解. final: final可以修饰:属性,方法,类,局部变量(方法中的变量) final修饰的属性的初始化可以在编译期,也可以在运行期,初始化后不能被改变. final ...

随机推荐

  1. vue2.0+node.js+mongodb全栈打造商城

    Github地址:https://github.com/ccyinghua/vue-node-mongodb-project 一.构建项目所用: vue init webpack vue-node-m ...

  2. 数据库查询服务DBCacheServer

    各个业务系统,都需要查询各类数据库; 一般查询数据库都是客户端自己连接,根据现在的情况,存在以下几点问题 1.客户端连接很多,连接大小,峰值不可控 2.客户端SQL程序员自己写,参差不齐 3.SQL书 ...

  3. Webpack Tapable原理详解

    directory - src - sim ---- 简单的模拟实现 - /.js$/ ---- 使用 代码已上传github, 地址 Detailed Webpack 就像一条生产线, 要经过一系列 ...

  4. [USACO1.5]数字三角形 Number Triangles

    题目描述 观察下面的数字金字塔. 写一个程序来查找从最高点到底部任意处结束的路径,使路径经过数字的和最大.每一步可以走到左下方的点也可以到达右下方的点. 7 3 8 8 1 0 2 7 4 4 4 5 ...

  5. oracle12c管理作业资源的一种方式

    数据库:12.1.0.2,rac,cdb模式 笔者负责移动两个12.1.0.2的cdb集群,一个在aix上,一个在linux上,不幸的是,它们都是混合型,数据有100多T. 由于其它部门交付的时候,已 ...

  6. DevOps - 项目构建 - Maven

    Maven介绍Apache Maven是一个创新的软件项目管理和综合工具.Maven提供了一个基于项目对象模型(POM)文件的新概念来管理项目的构建,可以从一个中心资料片管理项目构建,报告和文件.Ma ...

  7. web前端逻辑计算,血的教训

    在web前端进行页面开发的过程中,难免的遇到逻辑问题,这不是什么大问题,既然走上IT条黑道,那小伙伴们的逻辑推理能力及逻辑计算能力是不会有太大问题的. 然而,有的逻辑计算,就算你逻辑计算能力超强,也不 ...

  8. Centos6.5 安装python2.7.14

    2018-06-30 因为Centos6.5系统默认使用,python2.6.6.最近在学python.老师推荐将2.6.6升级至2.7.14.所以以留此文,怕哪天脑子短路好回来看看... >1 ...

  9. spring boot打包问题

    java.lang.IllegalArgumentException: No auto configuration classes found in META-INF/spring.factories ...

  10. 简单整理React的Context API

    之前做项目时经常会遇到某个组件需要传递方法或者数据到其内部的某个子组件,中间跨越了甚至三四层组件,必须层层传递,一不小心哪层组件忘记传递下去了就不行.然而我们的项目其实并没有那么复杂,所以也没有使用r ...