代码块
静态代码块 和 非静态代码块
/*
* 类的成员之四:代码块(或初始化块)
*
* 1. 代码块的作用:用来初始化类、对象
* 2. 代码块如果有修饰的话,只能使用static.
* 3. 分类:静态代码块 vs 非静态代码块
*
* 4. 静态代码块
* >内部可以有输出语句
* >随着类的加载而执行,而且只执行一次
* >作用:初始化类的信息
* >如果一个类中定义了多个静态代码块,则按照声明的先后顺序执行
* >静态代码块的执行要优先于非静态代码块的执行
* >静态代码块内只能调用静态的属性、静态的方法,不能调用非静态的结构
*
* 5. 非静态代码块
* >内部可以有输出语句
* >随着对象的创建而执行
* >每创建一个对象,就执行一次非静态代码块
* >作用:可以在创建对象时,对对象的属性等进行初始化
* >如果一个类中定义了多个非静态代码块,则按照声明的先后顺序执行
* >非静态代码块内可以调用静态的属性、静态的方法,或非静态的属性、非静态的方法
*
*/
public class BlockTest {
public static void main(String[] args) {
String desc = Person.desc;
System.out.println(desc);
Person p1 = new Person();
Person p2 = new Person();
System.out.println(p1.age);
Person.info();
}
}
class Person{
//属性
String name;
int age;
static String desc = "我是一个人";
//构造器
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//非static的代码块
{
System.out.println("hello, block - 2");
}
{
System.out.println("hello, block - 1");
//调用非静态结构
age = 1;
eat();
//调用静态结构
desc = "我是一个爱学习的人1";
info();
}
//static的代码块
static{
System.out.println("hello,static block-2");
}
static{
System.out.println("hello,static block-1");
//调用静态结构
desc = "我是一个爱学习的人";
info();
//不可以调用非静态结构
// eat();
// name = "Tom";
}
//方法
public void eat(){
System.out.println("吃饭");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public static void info(){
System.out.println("我是一个快乐的人!");
}
}
习题
第一题
//总结:由父及子(先去找父类,执行父类的),静态先行,然后代码块->构造器
class Root{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root(){
super();
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
super();
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器,其参数值:"
+ msg);
}
}
class Leaf extends Mid{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("尚硅谷");
System.out.println("Leaf的构造器");
}
}
public class LeafTest{
public static void main(String[] args){
new Leaf();
System.out.println();
new Leaf();
}
}
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器,其参数值:尚硅谷
Leaf的普通初始化块
Leaf的构造器
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器,其参数值:尚硅谷
Leaf的普通初始化块
Leaf的构造器
第二题
class Father {
static {
System.out.println("11111111111");
}
{
System.out.println("22222222222");
}
public Father() {
System.out.println("33333333333");
}
}
public class Son extends Father {
static {
System.out.println("44444444444");
}
{
System.out.println("55555555555");
}
public Son() {
System.out.println("66666666666");
}
public static void main(String[] args) {
// 由父及子 静态先行
System.out.println("77777777777");
System.out.println("************************");
new Son();
System.out.println("************************");
new Son();
System.out.println("************************");
new Father();
}
}
11111111111
44444444444
77777777777
************************
22222222222
33333333333
55555555555
66666666666
************************
22222222222
33333333333
55555555555
66666666666
************************
22222222222
33333333333
先执行静态代码块,因为main方法也是个静态方法
属性赋值顺序
/*
* 对属性可以赋值的位置:
* ①默认初始化
* ②显式初始化/⑤在代码块中赋值
* ③构造器中初始化
* ④有了对象以后,可以通过"对象.属性"或"对象.方法"的方式,进行赋值
*
*
* 执行的先后顺序:① - ② / ⑤ - ③ - ④
*/
public class OrderTest {
public static void main(String[] args) {
Order order = new Order();
System.out.println(order.orderId);
}
}
class Order{
int orderId = 3;
{
orderId = 4;
}
}
static、final、代码块 复习
1. static 修饰的属性,相较于实例变量,有哪些特别之处(>=3点)
随着类的加载而加载;
早于对象的创建;
只要权限允许,可以通过”对象.static属性”的方式进行调用;
存在于方法区的静态域
2. final 可以用来修饰哪些结构,分别表示什么意思
final标记的类不能被继承。提高安全性,提高程序的可读性。
final标记的方法不能被子类重写。
final标记的变量(成员变量或局部变量)即称为常量。名称大写,且只
能被赋值一次。
3. 代码实现单例模式的饿汉式
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single = new Singleton();
// 3.提供公共的静态的方法,返回当前类的对象
public static Singleton getInstance() {
return single;
}
}
4. 代码实现单例模式的懒汉式 -目前还是线程不安全的。
要是想线程安全用双重校验的懒汉式。
5. 类的属性赋值的位置有哪些?先后顺序为何?
默认初始化
显式初始化 、代码块中初始化
构造器中初始化
通过”对象.属性” 或”对象.方法”的方式赋值
static复习
static:静态的
1.可以用来修饰的结构:主要用来修饰类的内部结构
属性、方法、代码块、内部类
用static修饰的就是属于类的
2.static修饰属性:静态变量(或类变量)
2.1 属性,是否使用static修饰,又分为:静态属性 vs 非静态属性(实例变量)
-
实例变量:我们创建了类的多个对象,每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时,不会导致其他对象中同样的属性值的修改。
-
静态变量:我们创建了类的多个对象,多个对象共享同一个静态变量。当通过某一个对象修改静态变量时,会导致其他对象调用此静态变量时,是修改过了的。
-
2.2 static修饰属性的其他说明:
-
① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
-
② 静态变量的加载要早于对象的创建。
-
③ 由于类只会加载一次,则静态变量在内存中也只会存在一份:存在方法区的静态域中。
-
④ 类变量 实例变量
-
类 yes no
-
对象 yes yes
-
2.3 静态属性举例:System.out; Math.PI;
3.静态变量内存解析:
4.static修饰方法:静态方法、类方法
① 随着类的加载而加载,可以通过"类.静态方法"的方式进行调用
② 静态方法 非静态方法
-
类 yes no
-
对象 yes yes
③ 静态方法中,只能调用静态的方法或属性
非静态方法中,既可以调用非静态的方法或属性,也可以调用静态的方法或属性
5. static的注意点:
5.1 在静态的方法内,不能使用this关键字、super关键字。
5.2 关于静态属性和静态方法的使用,大家都从生命周期的角度去理解。
6.如何判定属性和方法应该使用static关键字:
6.1 关于属性
属性是可以被多个对象所共享的,不会随着对象的不同而不同的。
类中的常量也常常声明为static
6.2 关于方法
操作静态属性的方法,通常设置为static的
工具类中的方法,习惯上声明为static的。 比如:Math、Arrays、Collections
7.使用举例:
举例一:Arrays、Math、Collections等工具类
举例二:单例模式
举例三:
class Circle{
private double radius;
private int id;//自动赋值
public Circle(){
id = init++;
total++;
}
public Circle(double radius){
this();
// id = init++;
// total++;
this.radius = radius;
}
private static int total;//记录创建的圆的个数
private static int init = 1001;//static声明的属性被所对象所共享
public double findArea(){
return 3.14 * radius * radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public int getId() {
return id;
}
public static int getTotal() {
return total;
}
}
代码块 复习
类的成员之四:代码块(初始化块)(重要性较属性、方法、构造器差一些)
1.代码块的作用:用来初始化类、对象的信息
2.分类:代码块要是使用修饰符,只能使用static
3.分类:静态代码块 vs 非静态代码块
静态代码块:
内部可以输出语句
随着类的加载而执行,而且只执行一次
作用:初始化类的信息
如果一个类中定义了多个静态代码块,则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法,不能调用非静态的结构
非静态代码块:
内部可以输出语句
随着对象的创建而执行
每创建一个对象,就执行一次非静态代码块
作用:可以在创建对象时,对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块,则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法,或非静态的属性、非静态的方法
4. 实例化子类对象时,涉及到父类、子类中静态代码块、非静态代码块、构造器的加载顺序:
对应的练习:LeafTest.java / Son.java
由父及子,静态先行。
先执行父类的静态代码块,然后子类的静态。然后父类的非静态,子类的非静态
属性的赋值顺序
-
①默认初始化
-
②显式初始化/⑤在代码块中赋值
-
③构造器中初始化
-
④有了对象以后,可以通过"对象.属性"或"对象.方法"的方式,进行赋值
-
执行的先后顺序:① - ② / ⑤ - ③ - ④
final:最终的 复习
1.可以用来修饰:类、方法、变量
2.具体的:
2.1 final 用来修饰一个类:此类不能被其他类所继承。
-
比如:String类、System类、StringBuffer类
2.2 final 用来修饰方法:表明此方法不可以被重写
-
比如:Object类中getClass();
2.3 final 用来修饰变量:此时的"变量"就称为是一个常量
-
- final修饰属性:可以考虑赋值的位置:显式初始化、代码块中初始化、构造器中初始化
-
- final修饰局部变量:
-
尤其是使用final修饰形参时,表明此形参是一个常量。当我们调用此方法时,给常量形参赋一个实参。一旦赋值以后,就只能在方法体内使用此形参,但不能进行重新赋值。
static final 用来修饰属性:全局常量