Syntax basis: Keywords final and static

Syntax basis: Keywords final and static

final

The meaning of final is final and unchanged

Modifier variable

Once the final variable is initialized, it cannot be modified

attribute

Assignment can be declared and directly assigned private final string name="zhangsan";, You can also assign values in constructors or non static code blocks

class Al {
	private final String name = "zhangsan" ;
}

class B1 {
	private final String name;

    public B1(){
		name ="No parameters";
	}
	public B1(int kk) {
		name ="integer argument ";
	}
}

class C1 {
	private final String name;
    {
		name ="Non static code block";
	}
}

syntax error

class B1 {
	private final String name;
	{ //Non static code blocks are executed before the constructor executes. The fina1 attribute is initialized in a non static code block, but modified in the constructor
		name="Non static code block";
	}
	public B1() {
		name ="No parameters";
	}
	public B1(int kk){
		name ="integer argument ";
	}
}
  • final method. It is not allowed to override definitions in subclasses
class Parent{
	public final void pp(){}
}

class son extends Parent{
	public void pp(){}//Syntax error. Because the pp method in the parent class has been declared final, modification is not allowed
}

  • The final class indicates that this class is not allowed to be inherited
final class Parent{}

class son extends parent{}//Syntax error, because the parent class has been declared as fina1 type, it is not allowed to define a child class

It is not allowed to be inherited. It can also be implemented by using private constructors [all constructors must be private]

//Cannot inherit
public class Parent{
	private Parent(){}//Because it is used for custom constructors, the system no longer provides constructors. There is only one private constructor in this class
public class Son extends Parent{}//Syntax error

Allow inheritance

public class Parent{
	private Parent(){}
	public Parent(int age){}
}
public class Son extends Parent{
	public Son(){
		super(100);//Call the constructor Parent(int) in the Parent class
}

Note: String, StringBuilder and StringBuffer are final classes, so subclasses are not allowed to be defined

summary

The final attribute can be declared and assigned directly or in the constructor

The final temporary variable can be assigned at the same time as the declaration or before the first use

Note: once a variable of final type is assigned, it is not allowed to modify, but if it is a complex type, it is not allowed to modify the address. but
Yes, attributes can be modified

The final method indicates that this method does not allow redefinition (override \ override) in subclasses

The final class indicates that this class is not allowed to be inherited

static

  • Mainly used to decorate members

  • It is generated as the class is loaded and destroyed as the class disappears

  • It takes precedence over the object and is accessed directly with the class name

Static properties

There is only one attribute of all current classes. All current class objects share this attribute. Syntax:

public class A{

	Scope qualifier[private/package/protected/public] static Type variable name;//Simultaneous assignment of declarations is allowed
}
//The calling method can be called as the attribute of the object [new A(). Variable], or through [class name. Variable]

Typical application

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

Static method

Static methods can be called directly in the form of "class name. Method name". Static methods may not build objects during execution, so this/super and other keywords used to specify objects are not allowed in static methods

Of course, it is allowed to create objects and call object methods in static methods

Static methods can only directly access static members, not non static members

grammar

public class class{
	Scope qualifier static Return value type method name(parameter list){}
}
    //You can call with [new class (). Method name (argument)] or [class. Method name (argument)]

  • It is not allowed to use super or this to refer to objects in static methods. Of course, it is allowed to create objects and call them in static methods

  • Static methods can only directly access static members, not non static members, unless they create their own objects

public class A{
	private int age;
	private static int count=O ;
	public void dd(){}//Non static method
    
	public static void ff(){}//Static method
	public static void pp(){
		this.name ;//Syntax error, because this and super are not allowed in static methods
		dd();//Syntax error, because only static members can be accessed directly in static methods
		System.out.println(age);//Syntax error, because only static members can be accessed directly in static methods
        
		System.out. println(count);//correct
		ff();//correct
		A.ff();//correct
        
		System.out.print1n(new A().age); //Correct grammar
		new A().dd();//Correct grammar
		new A().count;//correct
		new A().ff();//correct
      }
}

Static code block

It is actually an anonymous method, but it will be executed automatically after the class is loaded. Syntax can only be executed once because of anonymity

public class class{
	static {//Static code blocks can be defined multiple times, and all static code blocks will be automatically executed after class loading
    	processing logic ;
	}
}

Non static code block

It's actually an anonymous method, but it's automatically executed once before building the object. Syntax can only be executed once because of anonymity

public class class{
	 {//Static code blocks can be defined multiple times, and all static code blocks will be automatically executed after class loading
		processing logic ;
	}
}

Special execution timing

  • When the class is loaded, it will automatically give priority to static static attributes and static static code blocks. These two priorities are the same, so whoever defines them before will implement them first

  • Non static attributes and non static code blocks are processed only when the new object is executed. These two priorities are the same, so whoever defines them first will implement them first

  • The constructor is executed last. When executing constructors, the father is first followed by the child

class A2 {
	static {
		System.out.println("A2 Static code block");
    }
	public A2(){
		System.out.println("A2 Parameterless constructor");
    }
    {
		System.out.println("A2 Non static code block");
    }
    
class B2 extends A2{
	static {
		System.out.println("B2 Static code block");
    }
    {
        System.out.println("B2 Non static code block");
    }
	public B2() {
		System.out.println("B2 Parameterless constructor");
    }

results of enforcement

  • A2 static code block

  • B2 static code block

  • A2 non static code block

    A2 parameterless constructor

  • B2 non static code block

    B2 parameterless constructor

Using static

  • When the data of all member variables are the same, you can use static to modify the static property, so that multiple objects can share a static property

  • Method is non static if it accesses unique data (non static members). If it is required that the method does not hold data, the method is static. For example, Math.abs(-123)

  • If all the methods in the class are static, there is no point in building the object of this class, so the constructor will generally be set to private, such as tool class

Variable number of parameters

When the parameters of the method are uncertain, you can define a variable number of parameter methods

Syntax: variable type... Variable name

public class A{
	public void pp(int. . . args){//args can be used directly as an integer array
		for(int i=0;i < args.length; i++){
			System.out.println(args[i]);
        }
    }
    
	public static void main(string[] args){
		new A().pp();//Can be called, but not through pp(nu11)
		new A().pp(1);//Can call
		new A().pp(1,2,3,4,5)//Can call
      }
}

Tags: Java

Posted on Sun, 05 Dec 2021 01:36:52 -0500 by darthbutternutz