语法基础：关键字final及static

final

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 A{
	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)//可以调用
      }
}