9.3 代码块
9.3.1 基本介绍
代码化块又称为初始化块，属于类中的成员【即 是类的一部分】，类似于方法，将逻辑语封装在方法体中，通过=={}==，包围起来。
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类时，或创建对象时隐式调用。
9.3.2 基本语法
9.3.3 代码块的好处和案例演示
-
相当于另一种形式的构造器（对构造器的补充机制），可以做初始化的操作
-
场景：如果多个构造器中都重复的语句，可以抽取到初始块中，提代码的重用性。
-
代码块的快速入门
package com.whw.codeblock_; public class CodeBlock01 { public static void main(String[] args) { Movie movie = new Movie("你好，李焕英"); System.out.println("==============="); Movie movie2 = new Movie("唐探 3", 100, "陈思诚"); } } class Movie { private String name; private double price; private String director; //3 个构造器-》重载 //(1) 下面的三个构造器都有相同的语句 //(2) 这样代码看起来比较冗余 //(3) 这时我们可以把相同的语句，放入到一个代码块中，即可 //(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容 //(5) 代码块调用的顺序优先于构造器.. { System.out.println("电影屏幕打开..."); System.out.println("广告开始..."); System.out.println("电影正是开始..."); }; public Movie(String name){ System.out.println("Movie(String name) 被调用..."); this.name=name; } public Movie(String name,double price){ this.name=name; this.price=price; } public Movie(String name,double price,String director){ System.out.println("Movie(String name, double price, String director) 被调用..."); this.name=name; this.price=price; this.director=director; } }
9.3.4 代码块使用注意事项和细节讨论 CodeBlockDetail01.java
public class CodeBlockDetail01 {
public static void main(String[] args) {
//类被加载的情况举例
//1. 创建对象实例时(new)
// AA aa = new AA();
//2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
// AA aa2 = new AA();
//3. 使用类的静态成员时(静态属性，静态方法)
// System.out.println(Cat.n1);//输出的结果为：1. Animal 的静态代码 1 被执行... 2. Cat 的静态代码 1 被执行... 3.999
//static 代码块，是在类加载时，执行的，而且只会执行一次. // DD dd = new DD();
// DD dd1 = new DD();
//普通的代码块，在创建对象实例时，会被隐式的调用。
// 被创建一次，就会调用一次。
// 如果只是使用类的静态成员时，普通代码块并不会执行
System.out.println(DD.n1);//8888, 静态模块块一定会执行
//输出的结果为：
//1. DD 的静态代码 1 被执行...
//2. 8888
}
}
class DD {
public static int n1 = 8888;//静态属性
//静态代码块
static {
System.out.println("DD 的静态代码 1 被执行...");//
}
//普通代码块, 在 new 对象时，被调用，而且是每创建一个对象，就调用一次
//可以这样简单的，理解 普通代码块是构造器的补充
{
System.out.println("DD 的普通代码块...");
}
}
class Animal {
//静态代码块
static {
System.out.println("Animal 的静态代码 1 被执行...");//
}
}
class Cat extends Animal {
public static int n1 = 999;//静态属性
//静态代码块
static {
System.out.println("Cat 的静态代码 1 被执行...");//
}
}
class BB {
//静态代码块
static {
System.out.println("BB 的静态代码 1 被执行...");//1
}
}
class AA extends BB {
//静态代码块
static {
System.out.println("AA 的静态代码 1 被执行...");//2
}
}
public class CodeBlockDetail02 {
public static void main(String[] args) {
A a = new A();// (1) A 静态代码块 01 (2) getN1 被调用...(3)A 普通代码块 01(4)getN2 被调用...(5)A() 构造器被调
用
}
}
class A {
{ //普通代码块
System.out.println("A 普通代码块 01");
}
private int n2 = getN2();//普通属性的初始化
static { //静态代码块
System.out.println("A 静态代码块 01");
}
//静态属性的初始化
private static int n1 = getN1();
public static int getN1() {
System.out.println("getN1 被调用...");
return 100;
}
public int getN2() { //普通方法/非静态方法
System.out.println("getN2 被调用...");
return 200;
}
//无参构造器
public A() {
System.out.println("A() 构造器被调用");
}
}
public class CodeBlockDetail03 {
public static void main(String[] args) {
new BBB();//(1)AAA 的普通代码块(2)AAA() 构造器被调用(3)BBB 的普通代码块(4)BBB() 构造器被调用
}
}
class AAA { //父类 Object
{
System.out.println("AAA 的普通代码块");
}
public AAA() {
//(1)super()
//(2)调用本类的普通代码块
System.out.println("AAA() 构造器被调用....");
}
}
class BBB extends AAA {
{
System.out.println("BBB 的普通代码块...");
}
public BBB() {
//(1)super()
//(2)调用本类的普通代码块
System.out.println("BBB() 构造器被调用....");
}
}
public class CodeBlockDetail04 {
public static void main(String[] args) {
//老师说明
//(1) 进行类的加载
//1.1 先加载 父类 A02 1.2 再加载 B02
//(2) 创建对象
//2.1 从子类的构造器开始
//new B02();//对象
new C02();
}
}
class A02 { //父类
private static int n1 = getVal01();
static {
System.out.println("A02 的一个静态代码块..");//(2)
}
{
System.out.println("A02 的第一个普通代码块..");//(5)
}
public int n3 = getVal02();//普通属性的初始化
public static int getVal01() {
System.out.println("getVal01");//(1)
return 10;
}
public int getVal02() {
System.out.println("getVal02");//(6)
return 10;
}
public A02() {//构造器
//隐藏
//super()
//普通代码和普通属性的初始化...... System.out.println("A02 的构造器");//(7)
}
}
class C02 {
private int n1 = 100;
private static int n2 = 200;
private void m1() {
}
private static void m2() {
}
static {
//静态代码块，只能调用静态成员
//System.out.println(n1);错误
System.out.println(n2);//ok
//m1();//错误
m2();
}
{
//普通代码块，可以使用任意成员
System.out.println(n1);
System.out.println(n2);//ok
m1();
m2();
}
}
class B02 extends A02 { //
private static int n3 = getVal03();
static {
System.out.println("B02 的一个静态代码块..");//(4)
}
public int n5 = getVal04();
{
System.out.println("B02 的第一个普通代码块..");//(9)
}
public static int getVal03() {
System.out.println("getVal03");//(3)
return 10;
}
public int getVal04() {
System.out.println("getVal04");//(8)
return 10;
}
//一定要慢慢的去品..
public B02() {//构造器
//隐藏了
//super()
//普通代码块和普通属性的初始化...
System.out.println("B02 的构造器");//(10)
// TODO Auto-generated constructor stub
}
}
9.3.5 习题
下面代码输出什么？
class Sample {
Sample(String s) {
System.out.println(s);
}
Sample() {
System.out.println(“Sample 默认构造函数被调用");
}
}
//===
class Test {
Sample sam1 = new Sample("sam1 成员初始化");//
static Sample sam = new Sample("静态成员 sam 初始化 ");//
static {
System.out.println("static 块执行");//
if (sam == null) System.out.println("sam is null");
}
Test()//构造器
{
System.out.println("Test 默认构造函数被调用");//
}
}
//主方法
public static void main(String str[]) {
Test a = new Test();//无参构造器
}
//运行结果， 输出什么内容，并写出. 2min 看看
运行结果先后顺序：
- 静态成员 sam 初始化
- static 块执行
- sam1 成员初始化
- Test 默认构造函数被调用
1340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
