2.javathis关键词的作用是什么(Java中的关键字static和final的作用)
各位老铁们好，相信很多人对2.javathis关键词的作用是什么都不是特别的了解，因此呢，今天就来为大家分享下关于2.javathis关键词的作用是什么以及Java中的关键字static和final的作用的问题知识，还望可以帮助大家，解决大家的一些困惑，下面一起来看看吧！
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.leizhimin;
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{
privatestaticfinalStringstrStaticFinalVar="aaa";
privatestaticStringstrStaticVar=null;
privatefinalStringstrFinalVar=null;
privatestaticfinalintintStaticFinalVar=0;
privatestaticfinalIntegerintegerStaticFinalVar=newInteger(8);
privatestaticfinalArrayList<String>alStaticFinalVar=newArrayList<String>();
privatevoidtest(){
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=newInteger(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");
}
publicstaticvoidmain(Stringargs[]){
newTestStaticFinal().test();
}
}
看了上面这个例子，就清楚很多了，但必须明白：通过static final修饰的容器类型变量中所“装”的对象是可改变的。这是和一般基本类型和类类型变量差别很大的地方。
java抽象类中的构造方法作用如何理解
/*学好java基础,学深java基础,才能走的更远(为什么呢?百度有更好的解释),愿我们共同探讨学习,用通俗易懂的话语来了解java
1.抽象类也是类，只不过本身不能实例化，要通过子类实例化。
2.是类就有构造方法，如果我们没有给出构造方法，系统将自动提供一个无参构造方法，如果我们给出了构造方法，系统将不会提供。
那么问题来了,为什么非得有构造方法呢?
构造方法(函数)的作用:(1)用于创建对象,初始化参数;(2)接受子类传来的参数,初始化参数,子类堆内存的某块位置存放父类的初始化参数
那么问题又来了,问题1:抽象类有构造方法怎么不能创建对象?问题2:它与接口又有什么关系呢?
问题1:请看构造函数的作用,还要补充下,用抽象类就要写个继承它的子类,然后通过父类引用指向子类这也是多态的表现,Father f= new Son();引用地址f就可以调用抽象类中的一般方法;
那么问题又来了抽象类怎么访问子类的方法呢?好了,自己考虑去
对于抽象类和一般类,接口来个例子
话说我去兰州拉面馆吃面,拿着菜单
抽象类的说法:
我:老板来碗面
老板:你需要什么面?
我:就是面啊?---------->描述抽象,既然抽象类都这么抽象了,那它有什么作用呢?简单来说,就是抽取某个类的共性功能,方便分类调用(编程就需要逻辑思维清晰,可读性强,就像书为什么要目录);举个例子,假如有哥们想吃面,想吃辣点的(面的共性辣),就快速选个方向去四川面馆,到了面馆就有查渣面,鸡丝凉面(具体类)选择...
老板:...
类的说法:
我:老板来碗面
老板:你需要什么面?
我:油泼面------------>描述具体
接口:从广义的角度讲对外提供规则的都是接口,来个例子
话说你家大门锁,你可以用匹配的钥匙打开锁,可我不一定非得要用你那型号的钥匙去开你家大门,我可以用铁丝就可以了,想想,实际生活中当真可以么,去问盗贼,他们"接口"倒是学的不赖
为什么用铁丝也可以开门呢?因为实现了锁孔内几个顶针同时顶上然后什么什么的方法,现在我们来看,我们可以用钥匙这个对象可以开锁,用铁丝这个对象开锁,他们共同的特点就是实现了
开锁的一些规则要求,也就是实现了开锁的要求的方法
需要说明的是:接口是没有构造方法的,它只是用来对外提供规则,其他类都可以实现这个接口,重写里面的方法
问题2:抽象类和接口的关系?
一般类继承抽象类,extends
一般类也可继承一般类----->类与类可以继承，单继承,儿子和父亲的关系(一个儿子不能来自两个父亲的基因,能吗?)
一般类和抽象类可以实现一个或多个接口,implements--->....干儿子和干爹的关系
那么问题来了:有没有人有个奇葩的问题,接口可不可以有父亲?干爹呢?
......收住,回到正题
3.子类中所有的构造方法默认都会访问父类中空参构造方法-->为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据,
所以，子类初始化之前，一定要先完成父类数据的初始化。
4.那么问题来了，要是父类没有无参构造呢？
不会有人认为父类没构有造方法吧？。。。
系统会默认加的（前面有提到），这里是指父类手动写了有参构造，子类继承也要手动写出构造方法(请看下面例子)
5.继承的注意事项
(1):子类只能继承父类所有非私有的成员(成员方法和成员变量)--->皇帝老儿的妃子,你太子能继承享用,恩...只代表大众的想法,特殊的除外,不钻牛角尖
(2):子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
*/
/* 1.父类没有无参构造方法,子类怎么办?
super解决
this解决
2.注意事项
super(…)或者this(….)必须出现在构造方法的第一条语句上
*/
class test{
public static void main(String[] args){
Son son= new Son("张三",23);
System.out.print(son.name+":"+son.age);
}
}
class Father{
String name="李四";//姓名
int age=24;//年龄
/*public Father(){//空参构造
System.out.println("Father空参构造");
}*/
public Father(String name,int age){//有参构造
//super();系统默认的,你知道是继承谁的吗?最高父类Object
this.name= name;
this.age= age;
}
public void setName(String name){//设置姓名
//super();系统默认的,你知道是继承谁的吗?最高父类Object
this.name= name;
}
public String getName(){//获取姓名
return name;
}
public void setAge(int age){//设置年龄
this.age= age;
}
public int getAge(){//获取年龄
return age;
}
}
class Son extends Father{
//String name="张三";
//int age=23;
/*public Son(){//由于父类没有无参构造(子类不继承父类构造放法),但是可以通过加this(值)或super(值)去访问父类构造方法
//super();系统默认的,你知道是继承谁的吗?可惜上面 Father类没有无参构造
//this(name,age);//注意,这种写法错误,虽然name,和age为成员变量,但是,无参构造方法没有参数传进来,(说到底无参构造方法终究还是个方法而已)
this("张三",23);//这种方法可以,为什么?因为它会在本类中寻找有参构造,通过 super(name,age)将值传入父类(因为父类只有有参构造)
//留下个疑问?要是下面有参构造,形参少了参数,即public Son(String name){ super(name,age);}还起作用吗?试试
//super(name,age);//同上
super("李四",24);//同上,注意this(值)和super(值)不能同时在构造方法的第一条语句上,但系统默认super()除外
}
public Son(String name,int age){
//super(name);
//super();系统默认的,你知道是继承谁的吗?可惜上面 Father类没有无参构造
super(name,age);
System.out.print(name+":"+age);
}
}
//子类构造方法另外种写法对吗?
class test{
public static void main(String[] args){
Son son= new Son("王五");
System.out.print(son.name+":"+son.age);
}
}
class Father{
String name;//姓名
int age;//年龄
/* public Father(){//空参构造
System.out.println("Father空参构造");
}
*/
public Father(String name,int age){//有参构造
//super();系统默认的,你知道是继承谁的吗?最高父类Object
this.name= name;
this.age= age;
}
public void setName(String name){//设置姓名
//super();系统默认的,你知道是继承谁的吗?最高父类Object
this.name= name;
}
public String getName(){//获取姓名
return name;
}
public void setAge(int age){//设置年龄
this.age= age;
}
public int getAge(){//获取年龄
return age;
}
}
class Son extends Father{
//String name="张三";
//int age=23;
/* public Son(){//由于父类没有无参构造(子类不继承父类构造放法),但是可以通过加this(值)或super(值)去访问父类构造方法
//super();系统默认的,你知道是继承谁的吗?可惜上面 Father类没有无参构造
//this(name,age);//注意,这种写法错误,虽然name,和age为成员变量,但是,无参构造方法没有参数传进来,(说到底无参构造方法终究还是个方法而已)
this("张三",23);//这种方法可以,为什么?因为它会在本类中寻找有参构造将值传入父类(因为父类只有有参构造)
//留下个疑问?要是下面有参构造,形参少了参数,即public Son(String name){ super(name,age);}还起作用吗?试试
//super(name,age);//同上
super("李四",24);//同上,注意this(值)和super(值)不能同时在构造方法的第一条语句上,但系统默认super()除外
}*/
public Son(String name){//我们说子类不继承父类的构造方法,也可以这样写对吗?
//super(name);
//super();系统默认的,你知道是继承谁的吗?可惜上面 Father类没有无参构造
super(name,24);
System.out.print(name+":"+age);
}
}
//就写这么多吧,不断的为什么,我都要疯了,有错误的和遗漏的希望指正
static关键字的作用
static关键字主要有两种作用：
第一，为特定数据类型或对象分配单一的存贮空间，而与创建对象的个数无关。第二，希望某个方法或属性与类而不是对象关联在一起，也就是说，
在不创建对象的情况下就可以通过类来直接调用方法或使用类的属性。具体而言，static在java中主要有四种使用情况：成员变量、成员方法、代码块及内部类。
（1）static成员变量
虽然java语言中没有全局的概念，但可以通过static关键字来达到全局的效果。java类提供了两种类型的变量：用static关键字修饰的静态变量和没有static关键字修饰的实例变量。静态变量
属于类，在内存中只有一个副本（所有实例都指向同一个内存地址）。只要静态变量所在的类被加载，这个静态类就会被分配空间，因此就可以被使用。对静态变量的引用有两种方式，分别为“类.静态变量”和“对象.静态变量”。
实例变量属于对象，只有对象被创建后，实例变量才会被分配空间，才能被使用，他在内存中存在多个副本，只能用“对象.静态变量”的方式来引用。
静态变量只有一个，被类所拥有，所有的对象都共享这个静态变量，而实例对象与具体对象有关。
（2） static成员方法
与变量类似，java类同时也提供了static方法与非static方法。static方法是类的方法，不需要创建对象就可以被使用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用。
static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用的时候，这个类的对象可能还没有被创建，即使已经被创建，
也无法确定调用哪个对象的方法。同理static方法也不能访问非static类型的变量。
static的一个很重要的的用途的是实现单例模式。单例模式的特点是该类只能有一个实例，为了实现这功能，必须隐藏类的构造方法，即把构造方法声明为private，并提供一个创建对象的方法。由于构造方法被声明为private，外界无法直接创建这个类型对象，只能通过该类提供的方法来获取类的对象
OK，关于2.javathis关键词的作用是什么和Java中的关键字static和final的作用的内容到此结束了，希望对大家有所帮助。