JAVA中final和static关键字

关键字final

含义是最终的、不变的

final属性和临时变量，一旦赋值则不能修改

属性赋值可以声明的同时直接赋值private final string name=“zhangsan”;，还可以在构造器或者非静态代码块中进行赋值

class Al {
private final String name = "zhangsan" ;\
}
class B1 {
private final String name;
public B1(){
name ="无参数";
	}
public B1(int kk) {
name ="整型参数";
	}
}
class C1 {
private final String name;
    {
name ="非静态代码块";
	}
}

语法错误

class B1 {
private final String name;
{ //非静态代码块在构造器执行之前执行。在非静态代码块中进行fina1属性的初始化，但是在构造器中进行修改
name="非静态代码块";
}
public B1() {
name ="无参数";
}
public B1(int kk){
name ="整型参数";
	}
}

final方法，不允许子类中覆盖定义

class Parent{
public final void pp()[}
class son extends Parent{
public void pp(){}//语法报错，因为在父类中pp方法已经声明为final的，所以不允许修改
}

final类表示这个类不允许被继承

final class Parent{}
class son extends parent{}//语法报错，因为父类已经声明为fina1类型的，所以不允许定义子类

不允许被继承还可以使用私有构造器的方式来实现【必须所有的构造器都是私有】

//不能继承
public class Parent{
private Parent(){}//因为用于自定义构造器，所以系统不再提供构造器，这个类中只有一个私有构造器
public class Son extends Parent{}//语法报错

允许继承

public class Parent{
private Parent(){}
public Parent(int age){}
}
public class Son extends Parent{
public Son(){
super(100);//调用Parent类中的Parent(int)这个构造器
}

注意: String.StringBuilder、StringBuffer是final类，所以不允许定义子类

总结
final属性上可以声明的同时直接赋值或者在构造器中赋值
final临时变量，可以声明的同时赋值或者在第━次使用之前进行赋值
注意: final类型的变量一旦赋值则不允许修改，但是如果是复杂类型是不允许修改地址。但
是可以修改属性

​ final方法表示这个方法不允许在子类中重新定义〔覆盖\重写)

​ final类表示这个类不允许被继承

static关键字

主要用于修饰成员
随着类的加载而产生，随着类的消失而销毁·优先于对象，用类名直接访问

静态属性

所有当前类的这个属性只有一个，所有当前类对象共享这个属性语法:

public class A{

范围限定词[private/package/protected/public] static类型变量名;//允许声明的同时赋值
}
//调用方法即可以当作对象的属性进行调用【new A().变量】，也允许通过【类名.变量】的方式进行调用

典型应用

public class Ai
	private static int count=0;
	public A(){
		count++;
	}
public int getcount({ return count;}
}

静态方法

因为可以直接使用类名.方法名"的形式直接调用静态方法，静态方法执行时很有可能并没有构建对象，所以在静态方法中不允许使用this/super之类用于指定对象的关键字

当然在静态方法中允许创建对象，并调用对象方法

静态方法只能直接访问静态成员，不能直接访问非静态成员

语法

public class 类{
范围限定词 static 返回值类型方法名称(参数列表){}
}
    //调用可以使用【new类().方法名(实参)】调用，也可以使用【类.方法名(实参)】进行调用

在静态方法中不允许使用super或者this指代对象，当然允许在静态方法中自行创建对象进行调用

静态方法只能直接访问静态成员，不能直接访问非静态成员，除非是自行创建对象

public class A{
private int age;
private static int count=O ;
public void dd(){}//非静态方法
public static void ff(){}//静态方法,类方法
public static void pp(){
this.name ;//语法报错，因为在静态方法中不允许使用this和super
dd();//语法报错，因为在静态方法中只能直接访问静态成员
System.out.println(age);//语法报错，因为在静态方法中只能直接访问静态成员
System.out. println(count);//正确
ff();//正确
A.ff();//正确
system.out.print1n(new A().age); //语法正确
new A().dd();//语法正确
new A().count;//正确
new A().ff();//正确
      }
}

静态代码块

实际上就是一个匿名的方法，但是在类加载完成后会自动执行一次。由于匿名只能执行一次语法

public class 类{
static {//静态代码块允许定义多次，而且所有的静态代码块在类加载完成后都会自动执行
    处理逻辑;
	}
}

非静态代码块

实际上就是一个匿名的方法，但是在构建对象之前会自动执行一次。由于匿名只能执行一次语法

public class 类{
 {//静态代码块允许定义多次，而且所有的静态代码块在类加载完成后都会自动执行
    处理逻辑;
	}
}

特殊的执行时机

当类加载完毕则会自动优先处理static静态属性和static静态代码块，这两个优先级相同，所以谁在前定义的,先实行谁

new对象时才执行处理非静态属性和非静态代码块，这两个优先级相同，所以谁在前定义的，先实行谁

最后才执行构造器。执行构造器时时先父后子

class A2 {
static {
System.out.println("A2静态代码块");
public A2(){
System.out.println("A2无参数构造器");
System.out.println("A2非静态代码块");
class B2 extends A2{
static {
System.out.println("B2静态代码块"");
System.out.println("B2非静态代码块");
public B2() {
System.out.println("B2无参数构造器");

执行结果
A2静态代码块

B2静态代码块

A2非静态代码块

A2无参数构造器.

B2非静态代码块

B2无参数构造器

使用static

当所有成员变量的数据都相同时，可以使用static修改静态属性，从而实现多个对象共享一个静态属性
方法如果访问了特有数据（非静态成员)，则这个方法就是非静态的。如果需要方法不持有数据，则方法是静态的。例如Math.abs(-123)
如果类中的所有方法都是静态的，那么构建这个类的对象则是没有任何意义，所以构造器━般会设置为私有的。例如工具类

可变个数的参数

		方法的参数当不确定时，可以可变个数的参数方法进行定义语法:变量类型...变量名称

public class Af
public void pp(int. . . args){//直接可以将args当作整型数组使用
for(int i=0;i < args.length; i++)
System.out.println(args[i]);
public static void main(string[] args){
new A().pp();//可以调用,但是不能通过pp(nu11)调用
new A().pp(1);//可以调用
new A().pp(1,2,3,4,5)//可以调用
      }
}