java new对象 代码块_Java基础之：OOP——代码块

Java基础之：OOP——代码块

代码块又称初始化块，是类中的成员(即类的一部分)，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来，也是通过调用执行。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法

[修饰符]{

代码(方法体)

};

说明：

修饰符可选是否添加，但只能添加static

代码块分为两种，加了static的静态代码块，没加static的普通代码块

逻辑语句可以是任何逻辑语句(输入、输出、方法调用、循环、判断等)

结尾的“;”号可以不写，[建议不写]

代码块优点

代码块相当于另外一种形式的构造器(对构造器的补充机制)，可以作初始化的操作。

当构造器重载时，可以提取多个构造器重复执行的代码，放入代码块中。

简单案例

电影放映

public class CodeBlockTest02 {

​

public static void main(String[] args) {

​

new Movie();

System.out.println("----------------");

new Movie("唐人街探案3..");

System.out.println("---------------");

new Movie("我和我的祖国...", 80, "张艺谋");

}

​

}

​

class Movie {

private String name;

private double price;

private String director;

//代码块

{

System.out.println("电影开始播放广告...");

System.out.println("电影屏幕拉下来.");

System.out.println("电影播放.");

}

public Movie() {

}

public Movie(String name) {

this.name = name;

}

public Movie(String name, double price, String director) {

this.name = name;

this.price = price;

this.director = director;

}

}

结果输出

代码块使用说明

static代码块又称静态代码块，静态代码块在类加载时就会执行且仅执行一次，和静态属性/静态方法相同。静态代码块的作用就是初始化类。

普通的代码块，在每次对象被声明时执行，所以每声明一个对象执行一次普通代码块。

如果只使用类的静态成员，则不会执行普通代码块。因为只要不声明对象，普通代码块就不会执行。

什么时候类被加载：

创建对象时： Person p = new Person();

创建子类对象时，父类也会被加载：Student s = new Student(); (Student extends Person，Student和Person都会被加载)

使用类的静态成员(静态属性，静态方法)时：Student.totalFee; (private static double totalFee)

创建对象时，类的调用顺序

调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)

调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

调用构造方法。

构造方法(构造器) 的最前面其实隐含了 super()和 调用普通代码块。

class Person{

public Person(){

super();

//调用普通代码块

System.out.println("Person");

}

}

静态相关的代码块，属性初始化，在类加载时，就执行完毕, 因此是优先于 构造器和普通代码块执行的。

静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。(因为在静态代码块执行时，只有静态成员已经被加载了)

对象加载顺序案例

package codeBlock;

​

public class Extends_blockTest {

​

public static void main(String[] args) {

new C();

}

​

}

class A{

private String name = nameA();

private static int age = ageA();

static {

System.out.println("A .... static Block");

}

{

System.out.println("A .... ordinary Block");

}

public String nameA() {

System.out.println("A .... ordinary Args");

return "AAA";

}

public static int ageA() {

System.out.println("A .... static Args");

return 18;

}

​

public A() {

System.out.println("A .... constructor");

}

}

​

class B extends A{

static {

System.out.println("B .... static Block");

}

private String name = nameB();

private static int age = ageB();

​

{

System.out.println("B .... ordinary Block");

}

public String nameB() {

System.out.println("B .... ordinary Args");

return "BBB";

}

public static int ageB() {

System.out.println("B .... static Args");

return 18;

}

​

public B() {

System.out.println("B .... constructor");

}

}

​

class C extends B{

private String name = nameC();

private static int age = ageC();

static {

System.out.println("C .... static Block");

}

{

System.out.println("C .... ordinary Block");

}

public String nameC() {

System.out.println("C .... ordinary Args");

return "CCC";

}

public static int ageC() {

System.out.println("C .... static Args");

return 18;

}

​

public C() {

System.out.println("C .... constructor");

}

​

}

输出结果

A .... static Args

A .... static Block

B .... static Block

B .... static Args

C .... static Args

C .... static Block

A .... ordinary Args

A .... ordinary Block

A .... constructor

B .... ordinary Args

B .... ordinary Block

B .... constructor

C .... ordinary Args

C .... ordinary Block

C .... constructor

内容来源于网络如有侵权请私信删除