static
// static
pubilc class Student{
private static int age; // 静态的变量
private double score; // 非静态的变量
public void run(){
}
public static void go(){
}
public static void main(String[] args){
Student s1 = new Student();
System.out.println(Student.age);
System.out.println(s1.age);
System.out.println(s1.score);
// 非静态方法调用
new Studnet().run();
// 静态方法的调用
// 静态方法不能调用非静态方法
// 或者在当前类中直接go(); 也可以类名.静态方法名();
Studnet.go();
}
}
单独类的执行顺序
public class Person{
// 2.赋初值~
{
System.out.println("匿名代码块");
}
// 1.只执行一次
static{
System.out.println("静态代码块");
}
// 3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args){
Person p1 = new Person();
System.out.println("=================");
Person p2 = new Person();
// 执行结果为:
// 静态代码块
// 匿名代码块
// 构造方法
// =================
// 匿名代码块
// 构造方法
}
}
静态导入包
// 静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test{
public static void main(String[] args){
System.out.println(random());
System.out.println(PI);
}
}
final关键字
-
Java的final关键字用来修饰
- 类
- 方法
- 字段
-
final的类, 不能被继承
-
父类中如果有final的方法, 子类不能改写此方法
-
final的变量, 不能再次赋值
- 如果是基本类型, 不能修改其值
- 如果是对象实例, 那么不能修改其指针(但是可以修改其内部的值)
常量设计
- 常量: 一种不会修改的变量
- java没有constant关键字
- 不能修改, final
- 不会/修改/只读/只要一份, static
- 方便访问public
Java中的常量 - public static final
- 建议变量名字全大写, 以连字符相连, 如PI_NUMBER
- 一种特殊的常量: 接口内定义的变量默认就是常量
常量池
public static void main(String[] args) {
Integer n1 = 127;
Integer n2 = 127;
System.out.println(n1 == n2);// true
Integer n3 = 128;
Integer n4 = 128;
System.out.println(n3 == n4);// false
Integer n5 = new Integer(127);
System.out.println(n1 == n5);// false
}
- Java为很多基本类型的包装类/字符串都建立常量池
- 常量池: 相同的值只存储一份, 节省内存, 共享访问
- 基本类型的包装类
- Boolean, Byte, Short, Integer, Long, Character, Float, Double
- Boolean: true, false
- Byte: -128~127, Character: 0~127
- Short, Int, Long: -128~127
- Float, Double: 没有缓存(常量池)
字符串常量池
public static void main(String[] args){
String s1 = "abc";
String s2 = "abc";
String s3 = "ab" + "c";
String s4 = "a" + "b" + "c";// 都是常量, 编译器将优化, 下同
System.out.println(s1 == s2);// true
System.out.println(s1 == s3);// true
System.out.println(s1 == s4);// true
}
- 基本类型的包装类和字符串有两种创建方式
- 常量式(字面量)赋值创建, 放在栈内存(将被常量化)
- Integer a = 10;
- String b = “abc”;
- new 对象进行创建, 放在堆内存(不会常量化)
- Integer c = new Integer(10);
- String d = new String(“abc”);
- 常量式(字面量)赋值创建, 放在栈内存(将被常量化)
- 这两种创建方式导致创建的对想存放的位置不同
自动拆装箱
int 与Integer
public static void main(String[] args) {
int i1 = 10;
Integer i2 = 10; // 自动装箱
System.out.println(i1 == i2);// true
// 自动拆箱 基本类型和包装类进行比较, 包装类自动拆箱
Integer i3 = new Integer(10);
System.out.println(i1 == i3); // true
// 自动拆箱, 基本类型和包装类进行比较, 包装类自动拆箱
System.out.println(i2 == i3);// false
// 两个对象比较, 比较其地址。
// i2是常量, 放在栈内存常量池中, i3是new出对象, 放在堆内存中
Integer i4 = new Integer(5);
Integer i5 = new Integer(5);
System.out.println(i1 == (i4 + i5));// true
System.out.println(i2 == (i4 + i5));// true
System.out.println(i3 == (i4 + i5));// true
// i4 + i5操作将会使得i4 + i5自动拆箱为基本类型并运算得到10
// 基本类型10和对象比较, 将会使对象自动拆箱, 做基本类型比较
Integer i6 = i4 + i5; // +操作使得i4,i5自动拆箱, 得到10, 因此i6 == i2.
System.out.println(i1 == i6);// true
System.out.println(i2 == i6);// true
System.out.println(i3 == i6);// false
}
String类
public static void main(String[] args) {
String s0 = "abcdef";
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1 == s2); // true 常量池
System.out.println(s1 == s3); // false 一个栈内存, 一个堆内存
System.out.println(s3 == s4); // false 两个都是堆内存
System.out.println("=================");
String s5 = s1 + "def";// 涉及到变量, 故编译器不优化
String s6 = "abc" + "def";// 都是常量 编译器会自动优化成abcdef
String s7 = "abc" + new String("def");// 涉及到new对象, 编译器不优化
System.out.println(s5 == s6);// false
System.out.println(s5 == s7);// false
System.out.println(s6 == s7);// false
System.out.println(s0 == s6);// true
System.out.println("=================");
String s8 = s3 + "def";// 涉及到new对象, 编译器不优化
String s9 = s4 + "def";// 涉及到new对象, 编译器不优化
String s10 = s3 + new String("def");// 涉及到new对象, 编译器不优化
System.out.println(s8 == s9);// false
System.out.println(s8 == s10);// false
System.out.println(s9 == s10);// false
}
不可变对象
- 不可变对象(Immutable Object)
- 一旦创建, 这个对象(状态/值)不能被更改了
- 其内在的成员变量的值不能修改了。
- 八个基本类型的包装类
- String, BigInteger 和 BigDecimal等
- 可变对象(Mutable Object)
- 普通对象
String a = new String("abc");// 该值在堆中
String b = a;// 将a的指针复制给b
System.out.println(b);// abc
a = "def";// 因为string是不可变对象, 这一步相当于, 又新开了一个内存空间"def", 将a的指针指向它, 之前指向"abc"的指针断掉
System.out.println(b);// abc, b的指针还是指向abc
public static void change(String b){// b的指针指向堆中"abc"
b = "def";// 在栈中申请一个"def"内存空间, 让b指向栈中的值, 故b不指向堆中的"abc"
}
a = new String("abc");// 该值在堆中
change(a);// 值a的指针传入
System.out.println(a);// abc
如何创建不可变对象
- immutable 对象是不可改变, 有改变, 请clone/new一个对象进行更改
- 所有属性都是final 和private的
- 不提供setter方法
- 类是final, 或所有的方法都是final
- 类中包含mutable对象(可变对象), 那么返回拷贝需要深度clone
不可变对象的优缺点
优点:
- 只读, 线程安全
- 并发读, 提高性能
- 可以重复使用
缺点:
- 制造垃圾, 浪费空间
- 对不可变对象进行修改时, 会新开辟空间, 旧对象则会被搁置, 直到垃圾回收。
Java字符串
- 字符串是Java使用最多的类, 是一种典型的不可变对象
- String 定义有两种
- String a = "abc";// 常量赋值, 栈分配内存
- String b = new String("abc");// new对象, 堆分配内存
- 字符串内容比较: equals方法
- 是否指向同一对象: 指针比较==
- Java常量池
- 保存在编译期间就已经确定的数据
- 是一块特殊的内存
- 相同的常量字符只存储一份, 节省内存, 共享访问
- 注: 常量字符串, 如果是new关键字的字符串是不算上一条规则的
字符串的加法
- String a = "abc";
- a = a + "def";// 由于string不可修改, 效率差
- 使用StringBuffer/StringBuilder类的append方法进行修改
- StringBuffer/StringBuilder的对象都是可变对象
- StringBuffer(同步, 线程安全, 修改快速), StringBuilder(不同步, 线程不安全, 修改更快)
public static void main(String[] args) {
Calendar t1 = Calendar.getInstance();
String string = new String("");
for (int i = 0; i < 50000; i++) {
string += i + ",";
}
System.out.println(Calendar.getInstance.getTimeInMillis() - t1.getTimeInMillis());
Calendar t2 = Calendar.getInstance();
StringBuffer stringBuffer = new StringBuffer("");
for (int i = 0; i < 50000; i++) {
stringBuffer.append(i);
stringBuffer.append(",");
}
System.out.println(Calendar.getInstance.getTimeInMillis() - t2.getTimeInMillis());
Calendar t3 = Calendar.getInstance();
StringBuilder stringBuilder = new StringBuilder("");
for (int i = 0; i < 50000; i++) {
stringBuilder.append(i);
stringBuilder.append(",");
}
}
public static void changeValue(int a){
a = 10;
}
public static void changeValue(String string){
string = "def";// 创建一个"def", 将string的指针指向"def"
}
public static void changeValue(StringBuffer stringBuffer){
stringBuffer.append("def");// 是在原有基础增加
stringBuffer = new StringBuffer("zzz");// 可理解成新建一个stringBuffer对象, 将stringBuffer的指针指向新建的stringBuffer对象
}
public static void main(String[] args) {
int a = 5;
String s1 = "abc";
StringBuffer stringBuffer = new StringBuffer("abc");
changeValue(a);
changeValue(s1);
changeValue(stringBuffer);
System.out.println(a);// 5
System.out.println(s1);// abc
System.out.println(stringBuffer);// abcdef
}