this 和 static 详解

lwj_07

已于 2022-03-06 23:22:54 修改

阅读量1.1k

点赞数 2

分类专栏：笔记文章标签： java

于 2022-02-28 13:43:25 首次发布

本文链接：https://blog.csdn.net/lwj_07/article/details/123164324

版权

笔记专栏收录该内容

144 篇文章 18 订阅

订阅专栏

static:
   1、static翻译为"静态"
   2、所有的static关键字修饰的都是类相关的,类级别的
   3、所有static修饰的,都采用"类名."的方式访问
   4、static修饰的变量：静态变量
   5、static修饰的方法：静态方法

变量的分类：
   变量根据声明的位置进行划分：
   在方法体当中声明的变量叫做：局部变量
   在方法体外中声明的变量叫做：成员变量

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

class VarTest{
	// 以下实例的,都是对象相关的,访问时采用"引用."的方式访问,需要先new对象
	// 实力相关的,必须先有对象,才能访问,可能会出现空指针异常
	// 成员变量中的实例变量
	int i;
	// 实例方法
	public void m1(){		
	}
	
	// 成员变量中的静态变量
	static int k;
	// 静态方法
	public static void m2(){
		
	}
}

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

   一个对象一份的是实例变量
   多个对象一份的是静态变量

public class staticTest02
{
	public static void main(String[] args){
		 Chinese c1 =new Chinese("123456","junker","中国");
		 Chinese c2 =new Chinese("00000","jun","中国");
		 System.out.println(c1.id);
		 System.out.println(c1.name);
		 System.out.println(c1.country);
		 System.out.println(c2.id);
		 System.out.println(c2.name);
		 System.out.println(c2.country);		
}
}
// 定义一个类：中国人

class Chinese{
	// 身份证号
	// 每个人的身份证号不同,所以身份证号应该是实例变量,一个对象一份
	String id;
	// 姓名
	// 姓名也是一个人一个姓名,姓名也应该为实例变量
	String name;
	// 国籍
	// 对于"中国人"这个类来说,国籍都是"中国",不会随着对象的改变而改变
	// 显然国籍并不是对象级别的特征
	// 国籍属于整个类的特征
	String country;
	
	// 无参数
	public Chinese(){
		
	}

	// 有参数
	public Chinese(String s1,String s2,String s3){
		id =s1;
		name =s2;
		country =s3;
	}
}

当变量 country不为static静态的时候的内存图如下所示：

当变量country为static静态变量时的代码演练和内存图如下所示：

代码演练2：(为static静态变量,应该使用"类名."的方式访问)

public class staticTest02
{
	public static void main(String[] args){
		
		// 访问中国人国籍
		// 国籍为static静态变量,应该使用"类名."的方式访问
		 Chinese c1 =new Chinese("123456","junker");
		 System.out.println(Chinese.country);
		 
		 // 报错[id,name是实例变量,应该先new一个对象 通过"引用."的方式访问]
		 //System,out.println(Chinese.id);
		 
		 System.out.println(c1.id);
		 System.out.println(c1.name);
		 
		 Chinese c2 =new Chinese("00000","jun");
		 System.out.println(c2.id);	
		 System.out.println(c2.name);
		 System.out.println(Chinese.country);
		 		
}
}
// 定义一个类：中国人

class Chinese{
	// 身份证号
	// 每个人的身份证号不同,所以身份证号应该是实例变量,一个对象一份
	String id;
	// 姓名
	// 姓名也是一个人一个姓名,姓名也应该为实例变量
	String name;
	// 国籍
	// 重点五颗星:加有static的变量叫做静态变量
	// 静态变量在类加载时初始化,不需要new对象,静态变量的空间就开出来了
	// 静态变量存储在方法区
	// 静态变量一般会给一个值
	static String country ="中国";
	
	// 无参数
	public Chinese(){
		
	}

	// 有参数
	public Chinese(String s1,String s2){
		id =s1;
		name =s2;
	}
}

代码演练3：

实例的：一定需要使用"引用."来访问
静态的：建议使用"类名."来访问,但使用"引用."也可以 ,如果使用"引用."来访问会让别人产生困惑：程序员以为是实例的呢

public class staticTest02
{
	public static void main(String[] args){
		 Chinese c1 =new Chinese("123456","junker");
		 
		 // 报错[id,name是实例变量,应该先new一个对象 通过"引用."的方式访问]
		 //System,out.println(Chinese.id);
		 
		 System.out.println(c1.id);
		 System.out.println(c1.name);
	 // 访问中国人国籍
	// 国籍为static静态变量,应该使用"类名."的方式访问
		 System.out.println(Chinese.country);
		 
		 Chinese c2 =new Chinese("00000","jun");
		
		 System.out.println(c2.id);	
		 System.out.println(c2.name);
		 
		 // 使用"引用."的方式访问依然通过 
		 System.out.println(c2.country);	// 中国
		 		
}
}
// 定义一个类：中国人

class Chinese{
	String id;
	
	String name;

	static String country ="中国";
	
	// 无参数
	public Chinese(){
		
	}

	// 有参数
	public Chinese(String s1,String s2){
		id =s1;
		name =s2;
	}
}

空引用访问静态不会空指针异常

public class staticTest02
{
	public static void main(String[] args){
		 Chinese c1 =new Chinese("123456","junker");
		 System.out.println(c1.id);
		 System.out.println(c1.name);
		 System.out.println(Chinese.country);
		 
		 Chinese c2 =new Chinese("00000","jun");	
		 System.out.println(c2.id);	
		 System.out.println(c2.name);
		 
		 // c2 是空引用
		 c2 =null;

		 // 不会出现空指针异常
		 // 因为静态变量不需要对象的存在
		 // 实际上以下的代码运行的时候,还是：System.out.println(Chinese.country);
		 System.out.println(c2.country);// 依然通过	

		 // 出现空指针异常 因为name为实例变量
		 // System.out.println(c2.name);
		 		
}
}
// 定义一个类：中国人

class Chinese{
	String id;
	
	String name;

	static String country ="中国";
	
	// 无参数
	public Chinese(){
		
	}

	// 有参数
	public Chinese(String s1,String s2){
		id =s1;
		name =s2;
	}
}

补充【掌握】

public class staticTest03
{
	public static void main(String[] args){
		User u =new User();
		int i =u.getId();
		System.out.println(i);
	}
}


class User
{	
	// 实例变量又称为对象变量
	private int id; // id为对象级别的变量
	
	/*
	// 会报错
	// 不能使用静态方法 因为返回的id、id本身就是对象级别需要new对象
	// 而静态方法只需要"类名."方式访问 所以会报错
	public static int getId(){
		return id;
	}
	*/
	public int getId(){
		return id;
	}

}

静态方法时变量也要是静态的：

一、静态代码块

   1、使用static关键字可以定义:静态代码块

   2、什么是静态代码块,语法是什么？
   static{
       java语句;
       ...
   }

   3、static静态代码块在什么时候执行呢？
   特点：类加载的时候执行,并且只执行一次

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

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

   6、静态代码块有啥作用,有什么用？

   具体的业务：
       项目经理说：所有的我们编写的程序中,只要是类加载了,请记录一下类加载的日志信息
       (在哪年哪月哪日几时几分,哪个类加载到JVM当中了) 就需要用到静态代码块

代码演练：

public class staticTest04
{	
	// 静态代码块
	static{
		System.out.println("A");
	}
	// 一个类中可以编写多个静态代码块
	static{
		System.out.println("B");
	}
	static{
		System.out.println("C");
	}

	// 程序入口
	public static void main(String[] args){
		System.out.println("come on~");
		}

	// 再编写一个静态代码块
	static{
		System.out.println("D");
	}
}

运行结果：(结论：静态代码块在类加载的时候执行)

二、代码执行顺序

(结论：静态代码块1 和静态代码块2 有先后顺序、静态代码块和静态变量也有先后顺序)

代码演示：

public class staticTest05
{	
	// 静态变量在什么时候初始化？	类加载时
	// 静态变量储存在哪里？	方法区
	static int i =100;
	
	// 静态代码块在什么时候执行？	类加载的时候
	static{
		System.out.println("i:"+i);
	}
	
	/*
	实例变量 k变量是实例变量,在构造方法(隐藏的对象方法)执行时(new时候)内存空间才会开辟
	错误: 无法从静态上下文中引用非静态 变量 k
	int k =6;
	static{
		// static静态代码块在类加载时候执行,k是实例变量 因此会报错
		System.out.println(k);

		System.out.println("name:"+name); // 此处同样报错：非法前向引用
	}
	

	// 报错：非法前向引用
	//static{System.out.println("name:"+name);}
	//static String name ="junker";
	
	*/
	//程序入口
	public static void main(String[] args){
		System.out.println("main begin~");
	}	
}

三、this的内存结构

1、this 是一个关键字,全部小写

   2、this 是什么,在内存方面是怎样的？
       一个对象一个this。
       this是一个变量,是一个引用，this保存当前对象的内存地址,指向自身,
       所以,严格意义上来说,this代表的就是"当前对象"

       this储存在堆内存当中的对象内部

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

   4、this 大部分情况下是可以省略的

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

代码演练：[掌握]

public class ThisTest01
{	
	public static void main(String[] args){
	// new一个对象
	Customer c1 =new Customer("junker");
	Customer c2 =new Customer("jun");
	c1.shopping();
	c2.shopping();
	
	}
}




// 顾客类
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(name+"正在购物");
		// 疑问： String name是实例变量(必须采用"引用."的方式访问)
		// 为什么这里的(name+"正在购物");不是(引用.name+"正在购物")呢 
		// 此程序中为什么不是(c1.name+"正在购物");呢？
		// [注意：new出来的引用c1 是在ThisTest01方法体 这个是Customer类体当中 ];

		// 解答：其实(name+"正在购物");当中隐藏了当前对象this (详看内存图)
		//System.out.println(this.name+"正在购物");
	}
}

扩展：

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

public class ThisTest02{	

	int i =100;	// 实例变量是对象级别的 必须先new对象才能使用
	static String k; 
	public static void main(String[] args){
		// 错误: 无法从静态上下文中引用非静态
		//System.out.println(this.i);
		//System.out.println(i);	// 同样报错 因为i是实例变量 而main方法是静态的
		
		// 如果真的想在main方法中访问实例变量 那么需要手动new一个对象
		ThisTest02 t =new ThisTest02();
		System.out.println(t.i);
		// 访问静态变量 "类名."的方式访问
		System.out.println(ThisTest02.k);
	}
}

this在哪些情况下不能省略：

/*
1、this可以使用在实例方法中,不能使用在静态方法中。
2、this关键字大部分情况下都可以省略,什么时候不能省略呢？
*/

public class ThisTest06
{
	public static void main(String[] args){
		// 无参
		Student s1 =new Student();
		s1.setName("jun");
		s1.setNo(11111);
		System.out.println(s1.getNo());
		System.out.println(s1.getName());
		// 有参
		Student s2 =new Student(22222,"junker");
		System.out.println("学号："+s2.getNo());
		System.out.println("姓名"+s2.getName());

		
	}
}

// 分析以下代码哪些地方写的不好？
// 形参描述的不太清楚
class Student
{	
	private int no;
	private String name;
	
	// 构造器
	public Student(){}
	public Student(int no,String name){
		this.no =no;
		this.name =name;
	}
	
	/*
	// 报错
	public Student(int no,String name){ // 形参里面的是局部变量
		no =no;	// 左边的no是实例变量 二者虚拟机可能会认为变量相同,因此
		name =name;// 实例变量是对象级别的变量 需要"引用."形式访问 this刚好是:当前对象
	}
	*/

	// 构造方法
	public int getNo(){
		return no;
	}
	public void setNo(int no){	// 形参n表达的意思不太明显 有的不知道是no
		this.no =no;
	}

	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name =name;
	}
}

运行结果：

this除了可以使用在实例方法中,还可以用在构造方法中

新语法：通过当前的构造方法去调用另一个本类的构造方法,可以使用以下语法格式：
       this(实际参数列表);
       通过一个构造方法1去调用构造方法2,可以做到代码复用
       注意："构造方法1"和"构造方法2"都是在同一类当中

需求：
   1、定义一个日期类,可以表示年月日信息。
   2、需求中要求：
   如果调用无参数构造方法,默认创建的日期为：1970年1月1日。
   当然,除了调用无参数构造方法外,也可以调用有参数构造方法来创建日期对象。

public class ThisTest07
{
	public static void main(String[] args){
		// 无参数
		Date d1 =new Date();
		d1.doSome();
		// 有参数
		Date d2 =new Date(1949,3,6);
		d2.doSome();
	}
}

class Date
{
	private int year;
	private int month;
	private int day;
	
	/*
		发现无参数构造器和有参数构造器当中this.year this.month this.day 重复
		那么就可以用无参数构造方法调用有参数构造方法 语法：this(实际参数列表);
		实际参数列表对应有参数构造方法的参数
	*/
	// 无参数构造器
	public Date(){
		/*
		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;
	}
	// 设立关卡
	// 读取数据
	public int getYear(){
		return year;
	}
	public void setYear(int year){
		this.year =year;
	}
	
	
	public int getMonth(){
		return month;
	}
	public void setMonth(int month){
		this.month =month;
	}

	public int getDay(){
		return day;
	}
	public void setDay(int day){
		this.day =day;
	}
	
	public void doSome(){
		
		//System.out.println(year); // 本类当中封装无效 1970(有缺省构造器传进1970)
		// 没有构造器的时候结果输出int型为0 String-> null

		System.out.println(year+"年"+month+"月"+day+"日");
	}
}

运行结果：