java关键字

static

基本介绍：
static 修饰的成员统称为静态成员，被static修饰的属性称为类变量(静态变量)，被static修饰的方法称为类方法（静态方法）。

一、static修饰属性
定义类变量：
访问修饰符 static 数据类型 变量名;

调用类变量：
类名.变量名

类变量的注意事项
1.什么时候使用类变量
当需要让某个类的所有对象都共享一个变量时，可以考虑使用类变量
2.类变量是类的所有对象共享，而实例变量是每个对象独享
3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
4.类变量可以通过类名直接访问，也可以通过对象名来访问，推荐使用类名访问[满足访问修饰符的权限和范围]
5.实例变量不能通过类名直接访问
6.类变量是在类加载时就初始化了，即使没有创建对象，只要类加载了，就可以使用类变量
7.类变量的生命周期时随类的加载开始，随类的消亡而销毁，普通变量是随着对象的创建而存在，对象被垃圾回收而消失

二、static修饰方法

定义类方法：
访问修饰符 static 数据类型 方法名(){};

调用类方法：
类名.方法名

类方法的注意事项
1.什么时候使用类方法
当方法中不涉及到任何和对象相关的成员时，可以将方法设计成静态方法，提高开发效率
例如：工具类中的方法utils. Math类、Arrays类、Collections类等
2.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区中：
类方法中无this参数
普通方法中隐含this参数
3.普通方法和对象有关，需要通过对象名调用，不能通过类名调用
4.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法可以。

final

一、基本介绍：
final可以修饰类、属性、方法和局部变量
在某些场景下，会使用到final
1.当不希望类被继承时，可以用final修饰，修饰后的类不能被继承，但是能实例化
2.当不希望父类的某个方法被子类覆盖/重写时，可以用final修饰，修饰后的方法不能重写，可以被继承
3.当不希望类的某个属性值被修改时，可以用final修饰
4.当不希望某个局部变量被修改时，可以用final修饰

二、final使用注意事项和细节
final修饰普通属性
1.定义时直接赋值：如 public final int MAX = 10;
2.在普通代码快中赋值
3.在构造器中赋值
final修饰的是静态属性
1.定义时直接赋值
2.在静态代码块中赋值
3.不能在构造器中赋值

tips:
final和static一起使用，不会导致类加载，因为底层编译器做了优化

abstract

一、基本介绍：
1.当父类方法不确定如何实现时，可以定义为抽象方法
2.当一个类中存在抽象方法时，需要将该类声明为抽象类
3.一般来说抽象类会被继承，由其子类实现抽象方法

二、抽象类的特点：
1。抽象类不能被实例化
2。抽象类可以没有抽象方法
3。一旦类包含了abstract方法，则这个类必须声明为abstract抽象类
4。abstract只能修饰类和方法，不能修饰属性和其他的。
5。抽象类可以有任意成员，比如：非抽象方法，构造器，静态属性等等
6。抽象方法不能有主体{}，也就是不能实现
7。如果一个类继承了抽象类，则它必须实现抽象类的所有方法，除非它自己也声明为abstract类
8。抽象方法不能使用private,static,final来修饰，因为这些关键字和重写相违背

三、抽象类–模版设计模式
1.Template.java

public abstract class Template {

    /**
     * 抽象类最佳时间-模版设计模式
     */
    public abstract void job();

    public void calculateTimes() {
        long startTime = System.currentTimeMillis();
        job(); //动态绑定机制，看运行类型
        long endTime = System.currentTimeMillis();
        System.out.println("job耗时：" + (endTime - startTime));
    }
}

2.Manage.java

public class Manage extends Template{

	public static void main(String[] args) {
        Manage manage = new Manage();
        manage.calculateTimes();
    }
    
    @Override
    public void job() {
        long num = 0;
        for (int i = 1; i <= 100; i++) {
            num *= i;
        }
        System.out.println("manager job very happy" + num);
    }
}

单例模式

一、饿汉式
1。先私有化构造器，防止外部直接创建对象
2。在类的内部创建对象，该对象用static修饰
3。提供一个公共的static方法：getInstance()供外部使用

SingleGirlFriend.java

public class SingleGirlFriend {
    public static void main(String[] args) {
        System.out.println(GirlFriend.getInstance());
        System.out.println(GirlFriend.getInstance());
    }
}


class GirlFriend{

    private String name;
	
	//私有化构造器
    private GirlFriend(String name){
        System.out.println("构造器被调用");
        this.name = name;
    }
	
	//类内部创建对象
    private static GirlFriend girlFriend = new GirlFriend("mm");

	//提供对外的获取实例静态方法
    public static GirlFriend getInstance(){
        return girlFriend;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

tips:
饿汉式在类加载时就会创建对象，造成资源浪费，例如：直接调用类属性时，类加载执行到
private static GirlFriend girlFriend = new GirlFriend(“mm”);

二、懒汉式
1。先私有化构造器，防止外部直接创建对象
2。定义一个变量，用来接收GirlFriend
3。提供一个公共的static方法：getInstance()供外部使用

SingleGirlFriend.java

public class SingleGirlFriend {
    public static void main(String[] args) {
    	//访问静态属性不会创建对象
    	System.out.println(GirlFriend.age);
        System.out.println(GirlFriend.getInstance());
        System.out.println(GirlFriend.getInstance());
    }
}

class GirlFriend{

    private String name;
	
	public static int age = 22;
	
	//私有化构造器
    private GirlFriend(String name){
        System.out.println("构造器被调用");
        this.name = name;
    }
	
	//类内部创建对象
    private static GirlFriend girlFriend;

    public static GirlFriend getInstance(){
        //存在线程安全问题
        if (girlFriend==null){//如果没有创建对象，则new对象
            girlFriend = new GirlFriend("mm");
        }
        //已经创建了对象，则直接返回cat对象
        return girlFriend;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

tips:
懒汉式存在线程安全问题，可优化
懒汉式只有在调用getInstance()时才会创建对象
懒汉式在访问静态变量时不会创建对象