static,final,代码块

static,final,代码块

static

static 为静态的，是Java当中的关键字

可作用在

• 变量
• 方法
• 类
• 匿名方法块

static 变量

• static变量只依赖于类而存在（即通过类即可访问）
• 所有的对象实例的统一个变量都存储在同一个栈当中

static方法

• 无需通过对象来访问
• 在静态方法当中，只能使用静态变量
• 里面不可以调用非静态的方法

直接用类名直接应用，不需要在new对象来引用

static类

由于这种方法非常少见所以我们暂且不做讲解

static块

• 只能再类第一次被加载的时候被调用
• 换句话说：再程序运行期间，这个代码块只能运行依稀
• 执行顺序如下：static块—>匿名块->构造函数

/**
 * Authored by Gary on 2020/09/29.
 **/

public class MyBlock {
    
    
    static
    {
    
    
        System.out.println("static block");
    }
    {
    
    
        System.out.println("匿名块");
    }

    public MyBlock() {
    
    
        System.out.println("constructor");
    }
}

public class Main {
    
    

    public static void main(String[] args) {
    
    
        MyBlock block = new MyBlock();

    }
}

单例模式

设计模式：是经过验证的，用于某些特定场合的解决方案

GoF提出了23种设计模式：创建型，结构型和行为型

单例模式保证在一个类在内存空间中只有一个对象

/**
 * Authored by Gary on 2020/09/29.
 **/

public class Singleton {
    
    
    private static Singleton obj=new Singleton();//共享同一个对象
    private String content;

    private Singleton() {
    
    
        this.content = "abc";
    }
    

    public String getContent() {
    
    
        return content;
    }

    public void setContent(String content) {
    
    
        this.content = content;
    }

    public static Singleton getObj() {
    
    
        return obj;
    }
}

public class Main {
    
    

    public static void main(String[] args) {
    
    
        Singleton obj1=Singleton.getObj();
        System.out.println(obj1.getContent());
    }
}

final

final关键字同样可以修饰

• 字段
• 类
• 方法

final类

• final类不能再被继承
• 父类中如果有final方法，子类当中它不能再被改写

final变量

• 如果是基本类型的变量，不能修改他的值
• 如果是对象实例，不可以修改它的指针（但是可以修改对象内部的值）

具体代码我就不实现了

常量设计

Java没有constant关键字，因此它的常量应该为 public static final 建议后面的变量名字全部大写，ex：UPPER_BOUND

基础

特殊的常量：接口内定义的变量默认为常量！！！！

常量池

Java为很多基本类型的包装类、字符串都建立了常量池

常量池：相同的值只会存储一份，节省内存，共享来访问

包装类：Boolean，Byte，…

Float,Double没有缓存！！！

import java.time.Instant;

public class Main {
    
    

    public static void main(String[] args) {
    
    
        //n1,n2被常量化，放在栈内存当中
        Integer n1=127;
        Integer n2=127;
        System.out.println(n1==n2);
        Integer n3=128;
        Integer n4=128;
        System.out.println(n3==n4);
        //new出来的不会被常量化，放在堆内存当中
        Integer n5=new Integer(127);
        System.out.println(n1==n5);
    }
}

//String也是一样的，看到底是不是new出来的，决定是否放到常量池当中

//true
//false
//false

不可变对象

• 一旦创建，这个对象（状态/值）不能背更改了
• 其内在的成员变量的值就不能修改了
• 典型的不可变对象：八个基本类型的包装类对象+String，BigInteger，BigDecimal

• 不可变对象，也是传指针（引用的）
• 有不可变，临时变量指向新的内存，外部是实参的指针是不改变的

如何创建不可变对象

• immutable对象是不可能改变的，需要改变，请使用clone/new一个对象进行修改
• 所有的属性都是final和private
• 不提供setter的方法
• 类是final的，或者所有的方法都是final的
• 类中包含mutable对象，那么返回拷贝需要深度clone

优点：

• 只读，线程安全
• 并发读取，提高性能
• 可以重复使用

缺点：

• 制造垃圾，浪费空间

字符串

Java中字符串可以分为两大类：
1）String类
2）StringBuffer和StringBuilder类

String类是immutable，不可修改的，所以当我们用+，=这些运算的时候会重新生成一个新的String类的实例，在循环中使用String类的+=运算会带来一定的效率问题。

String类的常用方法

字符串的分割

分析一个字符串并将字符串分解成可被单独使用的单词时，可以使用java.util包中的StringTokenizer类。该类有两个常用的构造方法：

• 1）StringTokenizer(String s) 为字符串s构造一个分析器 ，使用默认的分隔标记，即空格（若干个连续的空格视为一个空格），换行符，回车符，Tab符等。
• 2）StringTokenizer(String s，String delim) 为字符串s构造一个分析器，参数delim中的字符任意排列分隔标记

package Liu;

import java.util.StringTokenizer;

public class TestString {

public static void main(String[] args) {
    
    
	// TODO Auto-generated method stub
	StringTokenizer st = new StringTokenizer("I promice love baiyan forever");
	System.out.println("分析器分隔出：" + st.countTokens() + "个单词");
	while(st.hasMoreTokens()) {
    
    
		System.out.println(st.nextToken());
	}
}
}

//分析器分隔出：5个单词
//I
//promice
//love
//baiyan
//forever