语法形式第四种成员终于出现了
[修饰符]
{
//可执行性代码...
}
- 修饰符
- 省略
- 普通初始化块
- 负责对对象执行初始化(实例相关)
- static
- 静态初始化块
- 类初始化块
- 负责对类执行初始化(类相关)
- 省略
普通初始化块只在创建实例对象时才隐式调用,且总在构造器之前执行
public class HelloWorld
{
{
int a = 10;
if(a > 5)
{
System.out.println(1);
}
System.out.println(2);
}
{
System.out.println(3);
}
public HelloWorld()
{
System.out.println(4);
}
public static void main(String[] args)
{
new HelloWorld();
}
}
- 先定义的普通初始化块先执行
- 应该尽量把多个普通初始化块合并成一个,从而让程序更加简洁,可读性更强
当 Java 创建一个对象时,系统先为该对象的所有实例变量分配内存空间(前提是该类已经被加载过了),接着程序开始对这些实例变量执行初始化
public class HelloWorld
{
int a = 1;
{
a = 2; //省略 int ,表明 a 为实例变量
}
public static void main(String[] args)
{
System.out.println(new HelloWorld().a);
}
}
public class HelloWorld
{
int a = 1;
{
int a = 2; //声明 int ,表明 a 为局部变量
}
public static void main(String[] args)
{
System.out.println(new HelloWorld().a);
}
}
- 实例变量初始化顺序:
- 声明指定(源代码顺序)
- 初始化块(源代码顺序)
- 最后才执行构造器中指定的初始化处理
使用 javac 编译 Java 类后,初始化块中的代码会被“还原”到每个构造器中,且位于构造器中所有的代码之前
public class HelloWorld
{
{
a = 2; //提取出来的初始化块会被声明指定影响
}
int a = 1;
public static void main(String[] args)
{
System.out.println(new HelloWorld().a);
}
}
public class HelloWorld
{
public HelloWorld()
{
a = 2; //显式还原到构造器中的初始化块不会被声明指定影响
}
int a = 1;
public static void main(String[] args)
{
System.out.println(new HelloWorld().a);
}
}
- 如果有一段初始化处理对同一类的所有对象完全相同
- 且无须接受任何参数
- 就可以把这段初始化处理提取成一个普通初始化块
- 以提高初始化处理的复用以及整个应用的可维护性
系统将在类初始化阶段执行静态初始化块,而不是在创建实例对象时才执行
class A
{
static
{
System.out.println(111);
}
{
System.out.print(1);
}
public A()
{
System.out.print(2);
}
}
class B extends A
{
static
{
System.out.println(222);
}
{
System.out.print(3);
}
public B()
{
System.out.print(4);
}
}
public class HelloWorld extends B
{
static
{
System.out.println(333);
}
{
System.out.print(5);
}
public HelloWorld()
{
System.out.println(6);
}
public static void main(String[] args)
{
new HelloWorld();
new HelloWorld();
}
}
- 静态初始化块总是比普通初始化块先执行
- 应该尽量把多个静态初始化块合并成一个,从而让程序更加简洁,可读性更强
当 JVM 第一次主动使用某个类时,系统会在类的准备阶段为该类的所有类变量分配内存空间,在类的初始化阶段则负责对这些类变量执行初始化
- 一个类需要在加载并初始化之后才能使用
- 一旦类初始化阶段完成,该类将在虚拟机中一直存在
- 即一旦类初始化阶段完成,静态初始化块将永远不会再获得执行的机会
- 类变量初始化顺序:
- 声明指定(源代码顺序)
- 初始化块(源代码顺序)
public class HelloWorld
{
static int a = 1;
{
a = 18; //省略 int ,表明 a 为类变量
}
public static void main(String[] args)
{
System.out.println(HelloWorld.a);
System.out.println(new HelloWorld().a);
System.out.println(HelloWorld.a);
}
}
- 静态初始化块不能对实例变量进行初始化处理
- 普通初始化块却可以对类变量进行初始化处理
- 但最好不要这样做
- 否则需要等到第一次创建实例对象时
- 类变量的初始化才真正完成
当某个方法签名中为 Object 类型的形参,但实际需要却是2、3等数值时…
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
public class HelloWorld
{
public static void main(String[] args)
{
Integer a = 18;
Object b = 18;
int c = a;
System.out.println(a.getClass());
System.out.println(b.getClass());
System.out.println(c);
}
}
- Autoboxing:
- 可以把一个基本数据类型的值直接赋给对应的包装类变量
- Autoboxing —> Integer
- 可以把一个基本数据类型的值直接赋给 Object 类型的变量
- Autoboxing —> Integer —> upcasting
- 可以把一个基本数据类型的值直接赋给对应的包装类变量
- AutoUnboxing:
- 可以把一个包装类对象直接赋值给一个对应的基本数据类型变量
- AutoUnboxing —> int
- 可以把一个包装类对象直接赋值给一个对应的基本数据类型变量
调用时需要使用类名作为前缀
public static Integer valueOf(String s) public static Integer valueOf(int i) public static int parseInt(String s) public static String valueOf(...) 基本数据类型 + ""
$包装类实例与数值的比较
public class HelloWorld
{
public static void main(String[] args)
{
Integer a = Integer.valueOf(1);
int b = 2;
System.out.println(a > b);
System.out.println( new Integer(2) == new Integer(2));
System.out.println( new Integer("2") == new Integer("2"));
Integer c = 2;
Integer d = 2;
System.out.println(c == d);
Integer e = 200;
Integer f = 200;
System.out.println(e == f);
System.out.println(Integer.valueOf(-129) == Integer.valueOf(-129));
System.out.println(Integer.valueOf(-128) == Integer.valueOf(-128));
System.out.println(Integer.valueOf(127) == Integer.valueOf(127));
System.out.println(Integer.valueOf(128) == Integer.valueOf(128));
System.out.println((Integer.valueOf(18)).equals(18));
System.out.println((Integer.valueOf(18)).equals(18.0f));
}
}
//java.lang.Integer 类的一段源码
static final Integer[] cache = new Integer[-(-128) + 127 + 1]
static
{
for(int i = 0 ; i < cache.length ; i++)
{
cache[i] = new Integer(i - 128)
}
}
}
}
-
public String toString() 方法是 Object 类中定义的实例方法
-
因此所有的 Java 对象都具有该方法
-
且所有的 Java 对象都可以和字符串进行连接运算
-
此时系统将自动调用该对象的 toString() 方法返回值
-
-
Object 类提供的 toString() 方法返回值
- 类名 + @ + hashCode
-
String 类已经重写了 Object 的 toString() 方法
- 输出该字符串对象的字符序列
数值型相等,即返回 true
引用变量指向同一个对象,即返回 true
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println(18 == 18.0f);
System.out.println(97 == 'a');
System.out.println("Hi~" == "Hi~");
System.out.println(new String("Hi~") == new String("Hi~"));
}
}
- == 不可用于比较类型上没有继承关系的两个对象
重写此方法以提供自定义的相等标准
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println(Integer.valueOf(18) == 18);
System.out.println(Integer.valueOf(18) == 18.0);
System.out.println((Integer.valueOf(18)).equals(18));
System.out.println((Integer.valueOf(18)).equals(18.0));
System.out.println((Integer.valueOf(18)).equals(18.0f));
}
}
public class HelloWorld
{
private String id;
private String name;
public HelloWorld(String id , String name)
{
this.id = id;
this.name = name;
}
public String getId()
{
return this.id;
}
public String toString()
{
return "HelloWorld[" + name + " = "+id+"]";
}
public boolean equals(Object obj)
{
if(this == obj) //如果两个对象为同一个对象
{
return true;
}
if(obj != null && obj.getClass() == HelloWorld.class)
{
System.out.println(obj.getClass());
System.out.println(HelloWorld.class);
HelloWorld h = (HelloWorld)obj;
if(this.getId().equals(h.getId())) //两个对象的 id 相等
{
return true;
}
}
return false;
}
public static void main(String[] args)
{
HelloWorld h1 = new HelloWorld("123" , "Hi" );
HelloWorld h2 = new HelloWorld("123" , "Hi~" );
HelloWorld h3 = new HelloWorld("1234" , "Hi~" );
System.out.println(h1.equals(h2));
System.out.println(h1.equals(h3));
System.out.println(h2.equals(h3));
}
}
- public boolean equals(Object obj) 方法是 Object 类中定义的实例方法
- 因此所有的 Java 对象都具有该方法
- Object 类提供的 equals() 方法
- 和 == 差不多
- 比较的是实例对象的地址
- String 类已经重写了 Object 的 equals() 方法
- 判断标准为两个字符串所包含的字符序列相同
- equals() 方法重写的几条规则:
- 自反性
- x.equals(x) == true
- 对称性
- x.equals(y) == y.equals(x)
- 传递性
- x.equals(y) == true && y.equals(z) == true —> x.equals(z) == true
- 一致性
- 如果实例对象 x 、y 用于等价比较的信息没有改变,则无论调用多少次,x.equals(y) 要么一直是 true ,要么一直是 false
- x != null
- x.equals(null) == false
- 自反性
始终只能创建一个实例对象
class A
{
private static A instance;
private A(){}
public static A getInstance()
{
if(instance == null)
{
instance = new A();
}
return instance;
}
}
public class HelloWorld
{
public static void main(String[] args)
{
A a1 = A.getInstance();
A a2 = A.getInstance();
System.out.println(a1 == a2);
System.out.println(a1.equals(a2));
}
}
-
频繁地创建对象带来的系统开销问题,可能会导致系统性能下降
-
良好封装的原则:
-
构造器使用 private 修饰
-
然后再提供一个方法作为访问点
-
设置为 public ,用于创建实例对象
-
设置为 static ,该方法的主调只能是类本身,因为调用该方法时还不存在实例
-
然后在提供一个成员变量来缓存创建的实例对象
-
设置为 static ,因为该成员变量需要被上述的访问点方法访问
-



