JavaSE 基础 - 第11章 this和static

佬涛

已于 2023-06-02 10:35:32 修改

阅读量319

点赞数

分类专栏： JavaSE 文章标签： java 编程语言 javase

于 2020-07-16 23:55:38 首次发布

本文链接：https://blog.csdn.net/W1324926684/article/details/107397182

版权

JavaSE 专栏收录该内容

34 篇文章 4 订阅

订阅专栏

JavaSE 基础 - 第11章 this和static

1、static关键字
2、代码执行顺序
3、this关键字
4、【总结】：目前为止，所有的变量怎么访问？所有的方法怎么访问？
传送门

1、static关键字

1.1、static修饰的统一都是静态的，都是类相关的，不需要new对象。直接采用“类名.”访问。

	static:
		1、static翻译为“静态”
		2、所有static关键字修饰的都是类相关的，类级别的。
		3、所有static修饰的，都是采用“类名.”的方式访问。
		4、static修饰的变量：静态变量
		5、static修饰的方法：静态方法
	
	变量的分类：
		变量根据声明的位置进行划分：
			在方法体当中声明的变量叫做：局部变量。
			在方法体外声明的变量叫做：  成员变量。	

		成员变量又可以分为：
			实例变量
			静态变量

【例】

class VarTest{

		// 以下实例的，都是对象相关的，访问时采用“引用.”的方式访问。需要先new对象。
		// 实例相关的，必须先有对象，才能访问，可能会出现空指针异常。
		
			int i; // 成员变量中的实例变量
			
			public void m2(){     // 实例方法				
				int x = 200; // 局部变量
			}


		// 以下静态的，都是类相关的，访问时采用“类名.”的方式访问。不需要new对象。
		// 不需要对象的参与即可访问。没有空指针异常的发生。
			
			static int k; // 成员变量中的静态变量
			
			public static void m1(){   // 静态方法				
				int m = 100;  // 局部变量
			}	
		}

1.2 什么时候变量声明为实例的，什么时候声明为静态（static）的？

	如果这个类型的所有对象的某个属性值都是一样的，不建议定义为实例变量，浪费内存空间。
	建议定义为类级别特征，定义为静态变量，在方法区中只保留一份，节省内存开销。

	一个对象一份的是实例变量。
	所有对象一份的是静态变量。

　【总结】：当一个属性是类级别的属性，并且所有对象的这个属性的值是一样的，建议定义为静态变量。
016-变量什么时候声明为静态变量
017-变量什么时候声明为静态的2
　【重点】java中一共有三种变量：局部变量、实例变量、静态变量
　　局部变量：在方法体中声明的变量 -----》保存在 栈stack 中
　　实例变量：对象级别 ----》保存在 堆内存 中-----先new对象，再通过“引用.”的方式访问
　　静态变量： static 类级别 ----》保存在 方法区 中 ----通过“类名.”的方式访问

　　成员变量：在方法体外声明的变量（分为实例变量和静态变量）

1.3 空引用访问静态不会出现空指针异常！

	实例的：一定需要使用“引用.”来访问（先new对象）。

	静态的：
		建议使用“类名.”来访问，但使用“引用.”也行（不建议使用"引用."）。
		静态的如果使用“引用.”来访问会让程序员产生困惑：程序员以为是实例的呢。
	
	结论：
		空指针异常只有在什么情况下才会发生呢?
			只有在“空引用”访问“实例”相关的，都会出现空指针异常。

1.4 总结一个类中出现的东西

从第一天开始讲解HelloWorld到目前为止，一个类当中一共就写过这些东西。

	类{
		// 实例相关的都是需要new对象的，通过"引用."访问。
		实例变量;
		实例方法;

		// 静态相关的都是采用“类名.”访问。也可以使用“引用.”，只不过不建议。
		静态变量;
		静态方法;
	}

1.5 关于实例方法的调用

	关于方法来说，什么时候定义为实例方法？什么时候定义为静态方法？
		有没有参考标准。

		此方法一般都是描述了一个行为，如果说该行为必须由对象去触发。
		那么该方法定义为实例方法。

	       【参考标准】：
			当这个方法体当中，直接访问了实例变量，这个方法一定是实例方法。就不能加static了

			我们以后开发中，大部分情况下，如果是工具类的话，工具类当中的方法
			一般都是静态的。(静态方法有一个优点，是不需要new对象，直接采用类名调用，极其方便。
			工具类就是为了方便，所以工具类中的方法一般都是static的。)

			什么是工具类？？？？？
				以后讲。（工具类就是为了方便编程而开发的一些类。）
	
	类 = 属性 + 方法
		属性描述的是：状态
		方法描述的是：行为动作
	
	一个方法代表了一个动作。

	什么时候方法定义为实例方法？
		张三考试，得分90
		李四考试，得分100
		不同的对象参加考试的结果不同。
		我们可以认定“考试”这个行为是与对象相关的行为。
		建议将“考试”这个方法定义为实例方法。

1.6 静态代码块

	1、使用static关键字可以定义：静态代码块
	2、什么是静态代码块，语法是什么？
		static {
			java语句;
			java语句;
		}
	3、static静态代码块在什么时候执行呢？
		类加载时执行。并且只执行一次。
		静态代码块有这样的特征/特点。

	4、注意：静态代码块在类加载时执行，并且在main方法执行之前执行。

	5、静态代码块一般是按照自上而下的顺序执行。

	6、静态代码块有啥作用，有什么用？
		第一：静态代码块不是那么常用。（不是每一个类当中都要写的东西。）
		第二：静态代码块这种语法机制实际上是SUN公司给我们java程序员的一个特殊的时刻/时机。
		           这个时机叫做：类加载时机。

	具体的业务：
		项目经理说了：大家注意了，所有我们编写的程序中，只要是类加载了，请记录一下类加载的日志信息
		          （在哪年哪月哪日几时几分几秒，哪个类加载到JVM当中了）。
		思考：这些记录日志的代码写到哪里呢？
			写到静态代码块当中。

1.7 目前为止，所有java程序，有顺序要求的是哪些？

	第一：对于一个方法来说，方法体中的代码是有顺序的，遵循自上而下的顺序执行。
	第二：静态代码块1和静态代码块2是有先后顺序的。
	第三：静态代码块和静态变量是有先后顺序的。

	栈：方法只要执行，会压栈。（局部变量）
	堆：new出来的对象都在堆中。垃圾回收器主要针对。（实例变量）
	方法区：类的信息，字节码信息，代码片段。（静态变量）

	方法的代码片段放在方法区，但是方法执行过程当中需要的内存在栈中。

	静态变量在什么时候初始化？类加载时初始化。
	静态代码块什么时候执行？   类加载时执行。
	实例变量，在构造方法执行时内存空间才会开辟。

1.8 实例语句块

	1、除了静态代码块之外，还有一种语句块叫做：实例语句块
	2、实例语句在类加载是并没有执行。
	3、实例语句语法？
		{
			java语句;
			java语句;
			java语句;
		}
	4、实例语句块在什么时候执行？
		只要是构造方法（方法名与类名相同的方法，详情看  【第九章 第7点】）执行，必然在
		构造方法执行之前，自动执行“实例语句块”中的代码。
		      即如果有n个构造方法执行，则有n个实例语句块执行了
			实例语句块 执行；
			构造方法1 执行；
			实例语句块 执行；
			构造方法2 执行；
			实例语句块 执行；
			构造方法3 执行；
			。。。。
			实例语句块 执行；
			构造方法n 执行；

		实际上这也是SUN公司为java程序员准备一个特殊的时机，叫做对象构建时机。

【例】 InstanceCode.java

public class InstanceCode{

	//入口
	public static void main(String[] args){
		System.out.println("main begin");
		new InstanceCode();
		new InstanceCode();

		new InstanceCode("abc");
		new InstanceCode("xyz");
	}


	//实例语句块
	{
		System.out.println("实例语句块执行！    。。。。");	
	}

	// Constructor
	public InstanceCode(){
		System.out.println("无参数构造方法");
	}

	// Constructor
	public InstanceCode(String name){
		System.out.println("有参数的构造方法");
	}

}

/*输出结果：
main begin
实例语句块执行！    。。。。
无参数构造方法  
实例语句块执行！    。。。。
无参数构造方法
实例语句块执行！    。。。。
有参数的构造方法 
实例语句块执行！    。。。。
有参数的构造方法
*/

2、代码执行顺序

　如果一个类中有静态代码块、实例语句块、构造方法、主方法等等，它的执行顺序是怎么样的？
【例】CodeOrder.java

//判断以下程序的执行顺序
public class CodeOrder{
	
	// 静态代码块1
	static{
		System.out.println("A");
	}

	// 入口
	//最终顺序： A X Y C B Z
	public static void main(String[] args){
		System.out.println("Y");
		new CodeOrder();
		System.out.println("Z");
	}

	// 构造方法
	public CodeOrder(){
		System.out.println("B");
	}

	// 实例语句块
	{
		System.out.println("C");
	}

	// 静态代码块2
	static {
		System.out.println("X");
	}

}

【代码执行顺序-总结】：
　1、多个静态代码块按代码顺序执行
　　静态代码块1
　　静态代码块2
　　　…
　2、main方法开始执行
　3、实例语句块执行
　4、构造方法1 执行
　5、实例语句块执行
　6、构造方法2 执行
　　　…
　7、main方法结尾执行

3、this关键字

3.1 this.

	1、this是一个关键字，全部小写。
	2、this是什么，在内存方面是怎样的？
		一个对象一个this。
		this是一个变量，是一个引用。this保存当前对象的内存地址，指向自身。
		所以，严格意义上来说，this代表的就是“当前对象”
		this存储在堆内存当中对象的内部。

	3、this能使用在实例方法中。谁调用这个实例方法，this就是谁。
	   所以this代表的是：当前对象。

	4、this关键字大部分情况下可以省略，什么时候不能省略呢？
		在实例方法中，或者构造方法中，为了区分局部变量和实例变量，
		这种情况下：this. 是不能省略的。
		
	  【例】public void setNo(int no){ 
			//no是局部变量
			//this.no 是指的实例变量。
			this.no = no; // this. 的作用是：区分局部变量和实例变量。
		}

	5、为什么this不能使用在静态方法中？？？？？？
		this代表当前对象，静态方法中不存在当前对象。

【例1】ThisTest01.java：

public class ThisTest01{
	public static void main(String[] args){

		Customer c1 = new Customer("张三");
		c1.shopping();

		Customer c2 = new Customer("李四");
		c2.shopping();

		Customer.doSome();
	}
}

// 顾客类
class Customer{

	// 属性
	// 实例变量（必须采用“引用.”的方式访问）
	String name;   

	//构造方法
	public Customer(){
	
	}
	public Customer(String s){
		name = s;
	}

	// 顾客购物的方法
	// 实例方法
	public void shopping(){
		// 这里的this是谁？this是当前对象。
		// c1调用shopping(),this是c1
		// c2调用shopping(),this是c2
		//System.out.println(this.name + "正在购物!");

		// this. 是可以省略的。
		// this. 省略的话，还是默认访问“当前对象”的name。
		System.out.println(name + "正在购物!");
	}

	// 静态方法
	public static void doSome(){
		// this代表的是当前对象，而静态方法的调用不需要对象。矛盾了。
		// 错误: 无法从静态上下文中引用非静态 变量 this
		//System.out.println(this);
	}
}

015-this关键字
【例2】 ThisTest02.java

// 分析：i变量在main方法中能不能访问？？？？

public class ThisTest02{

	// 实例变量
	int i = 100; // 这个i变量是不是必须先new对象才能访问。

	// 静态变量
	static int k = 111;

	// 静态方法
	public static void main(String[] args){
		// 错误: 无法从静态上下文中引用非静态 变量 i
		// System.out.println(i);

		// 怎么样访问i
		ThisTest02 tt = new ThisTest02();
		System.out.println(tt.i);

		// 静态变量用“类名.”访问。
		System.out.println(ThisTest02.k);

		// 类名. 能不能省略？
		// 可以
		System.out.println(k);
	}
}

【例3】 ThisTest03.java 3

public class ThisTest03{
	public static void main(String[] args){

		Student s = new Student();
		s.setNo(111);
		s.setName("张三");
		System.out.println("学号：" + s.getNo());
		System.out.println("姓名：" + s.getName());

		Student s2 = new Student(2222, "李四");
		System.out.println("学号：" + s2.getNo());
		System.out.println("姓名：" + s2.getName());

	}
}

// 分析一下：以下代码哪里写的不好。
// 学生类
class Student{
	//学号
	private int no;

	//姓名
	private String name;

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

	//构造方法有参
	/*
	public Student(int i, String s){
		no = i;
		name = s;
	}
	*/

	// 上面的构造方法也增强以下可读性
	public Student(int no, String name){
		this.no = no;
		this.name = name;
	}

	// setter and getter方法
	/*
	public void setNo(int i){
		no = i;
	}
	*/
	/*
	public void setNo(int no){ // 就近原则。
		no = no; //这两个no都是局部变量no，和实例变量no没关系。
	}
	*/
	public void setNo(int no){ 
		//no是局部变量
		//this.no 是指的实例变量。
		this.no = no; // this. 的作用是：区分局部变量和实例变量。
	}
	public int getNo(){
		return no;
		//return this.no;
	}
	/*
	public void setName(String s){
		name = s;
	}
	*/
	/*
	public void setName(String name){ // 就近原则
		name = name; //这两个name都是局部变量name，和实例变量name没关系。
	}
	*/
	public void setName(String name){
		this.name = name;
	}

	/*
	public String getName(){
		return name;
	}
	*/

	public String getName(){ // getName实际上获取的是“当前对象”的名字。
		//return this.name; // 严格来说，这里是有一个 this. 的。只不过这个 this. 是可以省略的。
		return name;
	}
}

3.2 this（）

	1、this除了可以使用在实例方法中，还可以用在构造方法中。
	2、新语法：通过当前的构造方法去调用另一个本类的构造方法，可以使用以下语法格式：
		this(实际参数列表);
			通过一个构造方法1去调用构造方法2，可以做到代码复用。
			但需要注意的是：“构造方法1”和“构造方法2” 都是在同一个类当中。
		
		【例】
			// 构造方法无参
			// 调用无参数构造方法，初始化的日期是固定值。
			public Date(){
				//错误: 对this的调用必须是构造器中的第一个语句
				//System.out.println(11);
				/* 这个三行相当于下面那一行
				this.year = 1970;
				this.month = 1;
				this.day = 1;
				*/
				this(1970, 1, 1);    //调用了下面那个构造方法
			}
			// 构造方法有参数
			public Date(int year, int month, int day){
				this.year = year;
				this.month = month;
				this.day = day;
			}

	3、this() 这个语法作用是什么？
		代码复用。
	
	4、死记硬背：
		对于this()的调用只能出现在构造方法的第一行。

3.2 【this 总结】

	1、this是一个关键字，是一个引用，保存内存地址指向自身。
	2、this可以使用在实例方法【this.】中，也可以使用在构造方法【this()】中。
	3、this出现在实例方法中其实代表的是当前对象。
	4、this不能使用在静态方法中。 ---this代表当前对象，静态方法中不存在当前对象。
	5、this. 大部分情况下可以省略，但是用来区分局部变量和实例变量的时候不能省略。
	6、this() 这种语法只能出现在构造方法第一行，表示当前构造方法调用本类其他的
	     构造方法，目的是代码复用。

4、【总结】：目前为止，所有的变量怎么访问？所有的方法怎么访问？

java中的三大变量：
018-java中的三大变量

1、到目前为止一个类当中可以出现的：
	类体{
		实例变量;
		实例方法;

		静态变量;
		静态方法;

		构造方法;

		静态代码块;
		实例语句块;

		方法(){
			// 局部变量
			int i = 100;
		}
	}

【实例1】

public class Review{ // 类
	// 类加载机制中，是这样的：在程序执行之前，凡是需要加载的类全部加载到JVM当中。
	// 先完成加载才会执行main方法。
	static{
		System.out.println("Review类加载时执行！");
	}

	// 入口
	// 静态方法
	public static void main(String[] args){
		// 局部变量
		int i = 100;

		// 完成一个对象的一连串动作。
		// 一个学生在教室先学习，学习完成之后去餐厅吃饭。
		Student s1 = new Student();

		// 先学习，所有调用学习这个实例方法。
		s1.study();

		Student s2 = new Student();
	}

}

// 学生类
class Student{

	static{
		System.out.println("Student类加载时执行！");
	}

	// 学号
	private int no; // 实例变量
	// 姓名
	private String name;

	// 学生有静态变量吗？
	// 类级别的属性
	static String job = "学习";

	{
		System.out.println("实例语句块，构造方法执行一次，这里就执行一次！");
	}

	// 构造方法
	public Student(){
		// 假设调用无参数的构造方法，默认创建的学生学号是100，名字是zhangsan
		this(100, "zhangsan"); // this() 在这里也使用了。
	}
	public Student(int no, String name){
		this.no = no; // 这里使用了this.
		this.name = name;
	}

	// 封装
	// setter and getter方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setNo(int no){
		this.no = no;
	}
	public int getNo(){
		return no;
	}

	// 提供两个实例方法
	public void study(){
		// 私有的是可以在本类中访问的。在其它类中必须使用set和get方法。
		//System.out.println(this.name + "正在努力的学习!");
		//System.out.println(name + "正在努力的学习!");

		// 在实例方法中调用本类其它的实例方法。
		System.out.println(this.getName() + "正在努力的学习!");
		//System.out.println(getName() + "正在努力的学习!");

		// 方法执行到此处表示学习完成了，去吃饭。
		//this.eat();		
		// this.可以省略
		// 编译器检测到eat()方法是实例方法，会自动在eat()方法前添加 this.
		eat();
	}
	
	public void eat(){ // 实例方法
		System.out.println(this.getName() + "在餐厅吃饭呢！！！");

		// 调用静态m1()方法
		// 静态方法使用“类名.”的方式访问
		// Student.m1();

		// 类名. 可以省略吗？可以。
		// java编译器会自动在m1()方法之前添加“类名.”，因为检测到m1()方法是一个静态方法。
		m1();
	}


	// 提供两个静态方法
	public static void m1(){
		System.out.println("Student's m1 method execute!");
		// 调用m2()方法
		//Student.m2();
		m2();
	}

	public static void m2(){
		System.out.println("Student's m2 method execute!");
		System.out.println("工作性质：" + job);
		// 编译器检测到job是一个静态变量，所以这里会自动在job前添加：Student.
		//System.out.println("工作性质：" + Student.job);
	}
}

/*执行结果：
Review类加载时执行！
Student类加载时执行！
实例语句块，构造方法执行一次，这里就执行一次！
zhangsan正在努力的学习!
zhangsan在餐厅吃饭呢！！！
Student's m1 method execute!
Student's m2 method execute!
工作性质：学习
实例语句块，构造方法执行一次，这里就执行一次！
*/

2、程序再怎么变化，万变不离其宗，有一个固定的规律：
		所有的实例相关的都是先创建对象，通过“引用.”来访问。
		所有的静态（static）相关的都是直接采用“类名.”来访问。
	
	你有发现一些问题吗？
		总有一些是需要记忆的，在这些记忆的基础之上进行分析。
	
	大结论：
		只要负责调用的方法a和被调用的方法b在同一个class类当中：
			this. 可以省略  --编译器检测到a()方法是实例方法，会自动在a()方法前添加 this.
			类名. 可以省略  --编译器检测到a()方法是静态方法。会自动在a()方法前添加“类名.”

【实例2】

public class Review02{

	int i = 100;

	static int j = 1000;

	public void m1(){

		// 访问其他类的静态方法
		T.t1();

		// 访问其他类的实例方法
		T t = new T();
		t.t2();
	}

	public void m2(){}

	// 实例方法
	public void x(){ // 这个方法是实例方法，执行这个方法的过程中，当前对象是存在的。
		m1();
		m2();

		m3();
		m4();

		System.out.println(i); // System.out.println(this.i);
		System.out.println(j); // System.out.println(Review02.i);
	}

	public static void m3(){}

	public static void m4(){}

	// 问？你怎么分析这个程序？
	/*
		第一步：
			main方法是静态的，JVM调用main方法的时候直接采用的是“类名.”的方式。
			所以main方法中没有this。

		第二步：
			m1() 和 m2() 方法是实例方法，按照java语法规则来说，实例方法必须先
			new对象，通过“引用.”的方式访问。
	*/
	public static void main(String[] args){
		// 编译报错。
		//m1();
		//m2();

		m3(); // 编译器会自动识别m3()静态方法，结果是：Review02.m3();
		m4(); // Review02.m4();

		//System.out.println(i); // 报错
		System.out.println(j); // 可以

		// 想访问m1() m2()还有i，你在static方法中只能自己new
		Review02 r = new Review02();
		System.out.println(r.i);
		r.m1();
		r.m2();

		// 局部变量，局部变量访问的时候是不需要“xxx.”的
		int k = 10000;
		System.out.println(k);
	}
}


class T{
	// 静态方法
	public static void t1(){
	
	}

	//实例方法
	public void t2(){
	
	}
}

传送门

上一章：JavaSE 基础 - 第十章封装
下一章：JavaSE 基础 - 第十二章继承

佬涛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE 基础 - 第11章 this和static

JavaSE 基础 - 第11章 this和static1、static关键字1.1、static修饰的统一都是静态的，都是类相关的，不需要new对象。直接采用“类名.”访问。1.2 什么时候变量声明为实例的，什么时候声明为静态（static）的？1.3 空引用访问静态不会出现空指针异常！1.4 总结一个类中出现的东西1.5 关于实例方法的调用1.6 静态代码块1.7 目前为止，所有java程序，有顺序要求的是哪些？1.8 实例语句块2、代码执行顺序3、this关键字4、总结目前为止，所有的变量怎么访问？
复制链接

扫一扫