java面向对象-代码块

37 阅读10分钟

代码块

静态代码块 和 非静态代码块

/*
 * 类的成员之四:代码块(或初始化块)
 * 
 * 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 用来修饰变量:此时的"变量"就称为是一个常量

    1. final修饰属性:可以考虑赋值的位置:显式初始化、代码块中初始化、构造器中初始化
    1. final修饰局部变量:
  • 尤其是使用final修饰形参时,表明此形参是一个常量。当我们调用此方法时,给常量形参赋一个实参。一旦赋值以后,就只能在方法体内使用此形参,但不能进行重新赋值。

static final 用来修饰属性:全局常量