Static and final keyword learning demo exercise

The single interest model ：

The singleton pattern （Singleton Pattern） yes Java One of the simplest design patterns in . This type of design pattern is a creation pattern , It provides the best way to create objects .

This pattern involves a single class , This class is responsible for creating its own objects , Also make sure that only a single object is created . This class provides a way to access its unique objects , You can directly access , There is no need to instantiate an object of this class .

Be careful ：

• 1、 A singleton class can have only one instance .
• 2、 The singleton class must create its own unique instance .
• 3、 The singleton class must provide this instance to all other objects .

Details can be viewed rookie

static

Static Modifiers are used to create class methods and class variables .

1、Static Features of keywords ：

（1）Static It's a modifier , Pertaining to members .

（2）Static Decorated members are shared by all objects .

（3）Static Prior to the existence of objects , because static Members of the class already exist with the loading of the class .

（4）Static There is more than one way to call the decorated members , Can be directly called by the class name . Class name , Static members .

（5）Static The decorated data is shared data , Objects store unique data .
 

final

1. keyword final Indicates final , Immutable .

2. keyword final You can modify variables 、 Method , There are also classes

3.final The decorated class cannot be inherited

4.final The decorated method cannot be overridden , Can't be rewritten

5.final Can't control the problem of whether it can be called , It means the last , Can't change , It can't be changed .

6.final The modified variable can only be assigned a value once

7.final Embellished references ：

The reference can only point to 1 Objects , And it can only point to the object forever , And cannot point to other objects .

And during the execution of this method , After the reference points to the object , This object will not be collected by the garbage collection period

Until the end of the current method , To free up space .

8. although final The reference of points to the object A after , You can't point to objects again B,

But the object A Internal data can be modified .

9.final Decorated instance variable , Can only assign once . Conclusion ： Because instance variables are not assigned manually , The system will assign a default value .

So demand final Decorated instance variables must be assigned manually . This manual assignment , Assigning values after variables can , In the constructor

You can also assign values in .（ Display assignment 、 Constructor assignment 、 Code block assignment ）

10.final Modified instance variables are generally added static modification

The ultimate conclusion ：static final The jointly modified variable is called “ Constant ”, Constant names are recommended to be capitalized , Underline each word .

Constants are the same as static variables , The difference lies in ： The value of a constant cannot be changed . The same thing is ： Are stored in the method area , And are

Initialize when the class is loaded . Constants are generally public ,public modification .
 

Override parent method

describe

Parent class Base Several are defined in get Method , And one. sum Method ,sum The method is to sum a set of numbers . Please specify a subclass Sub Rewriting in getX() Method , bring sum Method returns x*10+y

Input description ：

Integers

Output description ：

Sum of integers

specific working means ：

Sub yes Base Subclasses of , Therefore, it inherits the member variables and member methods of the parent class , In the member method ,getY() and sum() Because of the addition of final keyword , Cannot be modified , Subclasses are used directly , and getX() Functions can be found in subclasses , We rewrite it to get x The value of 10 times .

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            Sub sub = new Sub(x, y);
            System.out.println(sub.sum());
        }
    }

}

class Base {

    private int x;
    private int y;

    public Base(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public final int getY() {
        return y;
    }

    public final int sum() {
        return getX() + getY();
    }

}

class Sub extends Base {

    public Sub(int x, int y) {
        super(x, y);
    }

 // Assign to first sub Of 
    @Override
    public int getX() {
        return super.getX() * 10;
    }

Create singleton objects