JAVA学习笔记(九)- 初始化块与静态代码块

初始化块

/*
* 初始化块
* 初始化变量方式：声明时、构造函数、代码块
* 使用static关键字修饰的代码块，称为静态代码块
*
* 执行顺序：静态代码块>代码块>构造方法
*
* 静态代码块在类加载时执行，且只会执行一次，主要用于初始化静态变量
* 代码块和构造方法在创建对象时执行
*/
public class Test01
{
public static void main(String[] args)
{
Car car = new Car(60000);// 创建一个对象
car.show();// 调用对象的方法
System.out.println("-------华丽的分隔线-------\n");

Car car2=new Car(80000);
car2.show();
}
}

/*
* 汽车类
*/
class Car
{
// 属性
String brand = "奇瑞";// 品牌，实例变量
double price;// 价格
String color;// 颜色
static int seat;// 座位数，静态变量

public Car()
{
System.out.println("无参的构造方法");
}

// 带参的构造方法，用来初始化成员
public Car(double price)
{
System.out.println("通过构造方法初始化变量price");
this.price = price;
}

// 代码块
{
System.out.println("通过代码块初始化变量color");
color = "red";
}

// 静态代码块
static
{
System.out.println("通过静态代码块初始化变量seat");
seat=5;
}

public void show()
{
System.out.println("品牌：" + brand);
System.out.println("价格：" + price);
System.out.println("颜色：" + color);
System.out.println("座位数："+seat);
}
}

静态变量与代码块

/*
* static
* 静态变量（类变量）
* 静态变量为类的所有对象所共有，即为类所有
*
* 静态成员访问方式：对名名.静态变量  或  类名.静态变量
*
* 结论：
* 1.static可以修饰变量、方法、代码块、匿名类
* 2.静态成员在类加载时初始化
* 3.静态方法中只能访问静态成员，不能访问非静态成员
* 4.普通成员方法中可以访问静态成员
*
*
* 变量类型
* 从作用域上划分：局部变量、成员变量
* 从变量所属上划分：实例变量、静态变量
*/
public class Test02
{
public static void main(String[] args)
{
Student stu1 = new Student("赵信");
stu1.age = 20;
stu1.hobby = "学习Java编程";
System.out.println("赵信的爱好：" + stu1.hobby);// 通过对象名访问静态变量
stu1.show();
stu1.hobby="爱好打魔兽";

Student stu2 = new Student("盖伦", 35);
//stu2.hobby = "学习Java编程";
System.out.println("盖伦的爱好：" + Student.hobby);// 通过类名访问静态变量
stu2.show();

Student stu3 = new Student("寒冰", 18, "学习Java编程");
stu3.show();

stu3.print();// 通过对象访问静态方法
Student.print();// 通过类名访问静态方法
}
}

/*
* 学生类
*/
class Student
{
String name;// 实例变量
int age;// 实例变量
static String hobby; // 静态变量

// 无参的构造方法
public Student()
{

}

// 带一个参数的构造方法
public Student(String name)
{
this.name = name;
}

// 带两个参数的构造方法
public Student(String name, int age)
{
this.name = name;
this.age = age;
}

// 带三个参数的构造方法
public Student(String name, int age, String hobby)
{
super();
this.name = name;
this.age = age;
this.hobby = hobby;
}

// 输出学生信息，普通的成员方法
public void show()
{
System.out.println("姓名：" + name + ",年龄：" + age + ",爱好：" + hobby + "\n");
/*
* 可以在普通成员方法中访问静态成员
*/
print();
System.out.println(hobby);
}

// 静态方法
public static void print()
{
System.out.println("俺是静态方法。。。。。");
//System.out.println("静态方法中输出-姓名："+name);//静态方法中不能访问非静态成员
System.out.println("静态方法中输出-爱好："+hobby);//静态方法中只能访问静态成员
}
}

类中成员

/*
* 类中成员
*
* this表示当前对象
* 1.访问类中的成员
* 2.解决局部变量和成员变量名称冲突
* 3.调用类中重载的构造方法
*/
public class Test03
{
public static void main(String[] args)
{
Dog dog = new Dog("旺财", 2, "雌");
dog.show();
}
}

/*
* 狗狗类
*/
class Dog
{
// 静态变量
static String hobby;

// 成员变量
String name;
int age;
String sex;

// 自定义无参的构造方法
public Dog()
{
super();// 调用父类无参的构造方法
System.out.println("无参的构造方法");
}

public Dog(String name)
{
this();// 调用类中重载的构造方法
System.out.println("带有一个参数的构造方法");
this.name = name;
}

// 重载的构造方法，带有两个参数的构造方法
public Dog(String name, int age)
{
this(name);// 调用类中重载的构造方法
this.age = age;
System.out.println("带有两个参数的构造方法");
}

// 重载的构造方法，带参的构造方法，用于初始化成员信息
public Dog(String name, int age, String sex)
{
this(name, age);// 调用类中重载的构造方法
this.sex = sex;
System.out.println("带有三个参数的构造方法");
}

// 成员方法
public void show()
{
System.out.println("名称：" + name + "，狗龄：" + age + "性别：" + sex);
}

// 静态方法
public static void play()
{
System.out.println("你正在接飞盘。。。。");
}

// 普通代码块
{
System.out.println("普通代码块");
sex = "雄";
}

// 静态代码块（静态初始化块）
static
{
System.out.println("静态代码块");
hobby = "接飞盘 ";
}
}