新手小白学JAVA static final 静态/构造/局部代码块之间的关系

Posted 2021-05-17 程序媛 泡泡

1 static

1.1 概念

是java中的一个关键字
用于修饰成员（成员变量和成员方法）

1.2 特点

1. 可以修饰成员变量与成员方法
2. 随着类的加载而加载，优先于对象加载
3. 只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失
4. 静态资源也叫做类资源,全局唯一,被全局所有对象共享
5. 可以直接被类名调用
6. 静态只能调用静态，非静态可以随意调用
7. static不能和this或者super共用，因为有static时可能还没有对象

1.3 练习：static入门案例

创建包: cn.tedu.oopstatic
创建类: TestStatic1.java

package cn.tedu.oopstatic;
/**本类用于测试静态的入门案例*/
public class Test_Static1 {
	//4.创建程序的入口函数main()
	public static void main(String[] args) {
		/**3.静态资源可以通过类名直接调用*/
		/**4.静态资源是优先于对象进行加载的,随着类的加载而加载
		 * 比对象先加载进入内存,没对象时也可以被类名直接调用
		 * */
		//9.通过类名直接调用静态资源进行测试
		System.out.println(Student.name);
		Student.study();
		//5.创建Student类对象进行测试
		Student s = new Student();
		//6.更改并查看name属性的值
		s.name = "黄桃罐头";
		System.out.println(s.name);
		//7.调用学生类的方法
		s.study();
		s.speak();
		//8.创建多个对象进行测试
		Student s2 = new Student();
		/**5.静态全局共享*/
		System.out.println(s2.name);
		System.out.println(Student.name);
	}
}
//1.创建学生类
class Student{
	/**1.可以通过static关键字将普通资源修饰成静态资源*/
	/**2.static可以用来修饰成员变量和方法,一般写在权限修饰符之后*/
	//2.定义属性--成员变量--无需手动初始化
	int sno;
	static String name;
	
	//3.定义方法--修饰符 返回值类型 方法名(参数列表){方法体}
	public static void study() {
		System.out.println("别闹~学JAVA呢~");
	}
	public void speak() {
		System.out.println("大声说出来~");
	}
	
}

1.4 练习：static静态调用关系

创建包: cn.tedu.oopstatic
创建类: TestStatic2.java

package cn.tedu.oopstatic;
/**本类用于测试静态的调用关系*/
//总结:
//1.静态资源只能调用静态资源
//2.非静态资源既可以调用静态资源,也可以调用非静态资源
public class Test2_Static2 {
}
//1.创建Teacher类
class Teacher{
	//2.定义普通资源
	//2.1定义普通属性
	String name;
	//2.2定义普通方法
	public void teach() {
		/**1.普通资源能否调用静态资源?--可以!!!*/
		System.out.println(age);//普通资源可以调用静态属性
		sleep();//普通资源可以调用静态方法
		System.out.println("正在教学ing...");
	}
	/**Ctrl+O 查看类结构信息*/
	//3.定义静态资源
	//3.1定义静态属性
	static int age;
	//3.2定义静态方法
	public static void eat() {
		System.out.println("扶朕起来,还能干饭~~~");
	}
	public static void sleep() {
		/**2.静态资源能否调用普通资源--不可以!!!*/
//		System.out.println(name);
//		teach();
		/**3.静态资源能否调用静态资源?--可以!!!*/
		System.out.println(age);//静态资源可以调用静态属性
		eat();//静态资源可以调用静态方法
		System.out.println("再累也要好好休息哦~~~");
	}
}

2 静态代码块、构造代码块、局部代码块

2.1 静态代码块格式

静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
特点: 被static修饰,位置在类里方法外

2.2 三种代码块的比较

1. 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2. 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
3. 局部代码块：方法里的代码块,限制局部变量的范围

2.3 练习：几种代码块的关系

创建包: cn.tedu. block
创建类: TestBlock.java

package cn.tedu.oopstatic;
//总结:
//1.代码之间的执行顺序:
//静态代码块-->构造代码块-->构造方法-->局部代码块
//2.为什么是这样的顺序呢?
/**静态代码块要优先于对象进行加载
 * 是随着类的加载而加载到内存中的
 * 只加载一次,并且一直存在,直到类消失,它才会消失
 */
//3.每个元素的作用:
//3.1)静态代码块:专门用来完成一些需要第一时间加载并且只加载一次的资源
//3.2)构造代码块:创建对象时才会触发,用来提取构造方法中的共性内容
//3.3)构造方法:创建对象时调用,用来创建对象,在构造代码块执行后执行
//3.4)局部代码块:调用所在的方法时才会调用,用来控制变量的作用范围

/**本类用于测试代码块之间的关系*/
public class TestBlook {
	public static void main(String[] args) {
		//7.创建对象进行测试
		/**1.在创建对象之前,会自动执行静态代码块,而且此代码块只加载一次*/
		/**2.在创建对象时,会自动调用构造代码块和构造方法,构造代码块先执行*/
		Person p = new Person();
		/**3.当通过对象调用方法时,若方法里有局部代码块,局部代码块才会执行*/
		p.study();
		System.out.println("******我是一个无情的分界线*********************");
		//8.再创建一次对象进行测试
		Person p2 = new Person();//再去创建对象,静态代码块也不会再次加载了
	}
}

//1.创建Person类
class Person{
	//2.创建静态代码块
	/**静态代码块:
	 * 位置:类里方法外+触发节点:随着类的加载而加载,只加载一次*/
	static {
		System.out.println("我是静态代码块~");
	}
	//3.创建构造代码块
	/**构造代码块:
	 * 位置:类里方法外+触发节点:创建对象时立即执行
	 * */
	{
		System.out.println("我是构造代码块~");
	}
	//4.创建构造方法
	/**构造方法:
	 * 位置:类里方法外+触发节点:创建对象时立即执行,让构造代码块先执行
	 * */
	public Person() {
		System.out.println("我是构造方法~~");
	}
	
	//5.创建普通方法
	public void study() {
		System.out.println("我是普通方法~~");
		//6.创建局部代码块
		{
			/**局部代码块:
			 * 位置:方法里+触发节点:调用此方法时执行
			 * */
			System.out.println("我是局部代码块");
		}
	}
}

结论:执行顺序:静态代码块 --> 构造代码块 --> 构造方法 --> 局部代码块

3 final

3.1 概念

1. 是java提供的一个关键字
2. final是最终的意思
3. final可以修饰类，方法，成员变量
   初衷：java出现继承后，子类可以更改父类的功能，当父类功能不许子类改变时,可以利用final关键字修饰父类。

3.2 特点

1. 被final修饰的类，不能被继承
2. 被final修饰的方法，不能被重写
3. 被final修饰的变量是个常量，值不能被改变
4. 常量的定义形式：final 数据类型 常量名 = 值

3.3 练习：final入门案例

创建包: cn.tedu.oopfinal
创建类: TestFinalDemo.java

package cn.tedu.oopstatic;
/**本类用于测试final的入门案例*/
public class TestFinalDemo {
	public static void main(String[] args) {
		//5.创建子类对象进行测试
		Son4 s = new Son4();
		s.work();
//		s.name = "干饭人";//报错:常量的值不可以被修改
	}
}
/**1.final表示最终,可以用来修饰类
 * 但是被final修饰的类无法被继承
 * 也就是没有子类,它自己就是最终类
 * */
//1.创建父类
//final class Father4{//报错:Son4类不能是final修饰的Father4的子类
class Father4{
	//3.创建成员变量并赋值
	/**2.final可以用来修饰成员变量,被final修饰的变量值不可以被修改--常量*/
	final String name = "打工人";
	//4.创建成员方法
	/**3.final可以用来修饰成员方法,但是被final修饰的方法是最终实现,子类无法重写*/
	final public void work() {
		System.out.println("Father4...打工人,打工魂");
	}
}

//2.创建子类
class Son4 extends Father4{
	//子类重写父类的work方法
//	public void work() {
//		System.out.println("Son4...打工人要用计算机打工~");
//	}
}