Java基础 参数传递 this关键字

鳄鱼君

发表文章数:643

Vieu四代商业主题

高扩展、安全、稳定、响应式布局多功能模板。

¥69 现在购买
首页 » Java » Java基础 参数传递 this关键字

参数传递

在java程序中,参数传递的是变量中保存的值,例如以下程序,传递的是变量i保存的值10:

public class ParamTest {
	public static void main(String[] args) {
		int i = 10;
		add(i);
		System.out.println("main -->" + i);// 10
	}

	// add方法
	private static void add(int i) {
		i++;
		System.out.println("i -->" + i);// 11
	}

}

以下程序,传递的是变量user1中保存的值,只不过这个值是java对象的内存地址,指向User对象

public class ParamTest {
	public static void main(String[] args) {
		User user1 = new User(10);
		add(user1); //参数传递的是user1对象保存的值,即内存地址
		System.out.println("user1.age -->" + user1.age);// 11
		
	}

	// u和user1是两个不同的局部变量,但是内存地址是相同的
	private static void add(User u) {
		u.age ++;
		System.out.println("user1.age -->" + u.age);// 11
	}

}
class User{
	//实例变量
	int age;
	
	//构造方法
	public User(int a){
		age = a;
	}
}

总结:方法调用的时候,传递的是变量中保存的值,只不过这个值有的时候是一个字面值10,有的时候是一个java对象的内存地址

int i = 10;
int j = i; //i传给j,是将i中的字面值10传递给j,相当于复制重新开辟内存空间保存j

User user1 = new User();
User user2 = user1; //user1传递给user2,也是将值赋值给user2,user1的值指向堆内存中的User对象,所以user2也是指向它

this关键字

this是一个关键字,翻译为:这个。this是一个引用,this是一个变量中保存了内存地址指向自身,this存储在JVM堆内存java对象内部,如果创建100个对象,每个对象都有this,也就是说有100不同的this。

注意:

  1. this可以出现在“实例方法”中,this指当前正在执行这个动作的对象(this代表当前对象)
  2. this在多数情况下都是可以省略不写的
  3. this不能使用带有static的方法中
public class Customer {
	// 实例变量,存储再堆内存中,访问该数据:创建对象,通过引用方式访问
	//姓名
	String name;
	
	// 无参数构造方法
	public Customer(){
		
	}
	
	/* 
	 * 没有static关键字的方法被称为实例方法
	 * 没有static关键字的变量被称为实例变量
	 * 
	 */
	public void shopping(){
		System.out.println(this.name + "正在购物");
	}

}
public class CustomerTest {
	public static void main(String[] args){
		// 创建一个顾客对象
		Customer cus1 = new Customer();
		// 使用cus1访问该对象,this指的就是cus1
		cus1.name = "鳄鱼君1";
		cus1.shopping();
		
		//再创建一个顾客对象
		Customer cus2 = new Customer();
		// 使用cus2访问该对象,this指的就是cus2
		cus2.name = "鳄鱼君2";
		cus2.shopping();
		
	}
}

带有static的方法:

public class Customer {
	// 实例变量,存储再堆内存中,访问该数据:创建对象,通过引用方式访问
	//姓名
	String name;
	
	// 无参数构造方法
	public Customer(){
		
	}

	public static void doSome(){
		// 这个执行过程没有“当前对象”,因为带有static的方法是通过类名的方式访问的
		// 或者说这个“上下文”当中没有“当前对象”,自然也不存在this,this代表当前正在执行这个动作的对象
		
		// doSome方法调用不是对象去调用,是一个类名去调用,执行过程没有“当前对象”
		// name是一个实例变量,访问实例变量需要对象,没有当前对象,所以不能访问
		// System.out.println(name);
		
	}
}
public class CustomerTest {
	public static void main(String[] args){
		// 创建一个顾客对象
		Customer cus1 = new Customer();
		// 使用cus1访问该对象,this指的就是cus1
		cus1.name = "鳄鱼君1";
		// 修饰符列表上有static “类名.”,这个方法执行的过程不需要对象参加
		Customer.doSome();
	}
}

如果现在想在带有static的方法中访问实例变量,则需要创建对象,通过引用.的方式:

public class Customer {
	// 实例变量,存储再堆内存中,访问该数据:创建对象,通过引用方式访问
	//姓名
	String name;
	
	// 无参数构造方法
	public Customer(){
		
	}

	public static void doSome(){
		// 访问实例变量
		// 创建对象,通过引用.的方式
		Customer c1 = new Customer();
		
		System.out.println(c1.name);
		
	}
}
public class CustomerTest {
	public static void main(String[] args){
		// 修饰符列表上有static “类名.”,这个方法执行的过程不需要对象参加
		Customer.doSome();
	}
}

带有static的方法中不能直接访问“实例变量和实例方法”,因为实例变量和实例方法需要对象的存在,而static的方法中是没有this的,也就是说不存在当前对象:

public class CustomerTest {
	
	public static void main(String[] args){
		// 调用doSome,可以使用类名.,如果在当前类中也可以省略类名
		CustomerTest.doSome();
		doSome();
		
		// 调用run方法
		// run属于实例方法,必须先创建对象
		CustomerTest n = new CustomerTest();
		n.run();
		
		// main方法没有this,所以不能直接调用,或者通过this调用实例方法
		// run();
		// this.run();
	}
	
	// 带有static
	public static void doSome(){
		// this表示当前对象
		System.out.println("do some");
	}
	
	// 实例方法
	// 调用run方法必须有对象,通过对象调用run方法
	public void run(){
		// 代码在这里执行的时候,一定是存在“当前对象”的
		// 也就是一定是有this
		System.out.println("running");
		
		doSome();
		
	}
}

this用来区分局部变量和实例变量的时候,不能省略:

public class Customer {
	// 属性,id
	public int id;
	public String name;
	
	
	
	// 以下代码的id和实例变量的id无关,所以不能采用这种写法
	/*public void setId(int id){
		id = id; // 自己赋值给自己
	}*/
	
	// 可以这样写,但是a指的就是实例变量的id,但是别人不知道
	/*public void setId(int a){
		id = a; // 自己赋值给自己
	}*/
	
	// this不能省略
	public void setId(int id){
		// 实例变量id = 局部变量id;
		this.id = id;
	}

}

在构造方法中也可以调用其它构造方法,这里不能使用new直接创建对象,需要借助this:

public class Data {
	private int year;
	private int month;
	private int day;
	// 当调用无参数的构造方法的时候,默认生成2020-1-1
	
	//无参数构造方法
	public  Data(){
		/*this.year = 2020;
		this.month = 1;
		this.day = 1;*/
		// 不能创建一个全新的对象
		// new Data(2020,1,1)
		this(2020,1,1);
	}
	// 带参数构造方法
	public  Data(int year, int month, int day){
		this.year = year;
		this.month = month;
		this.day = day;
		
	}
	// 提供一个将日期输出到控制台的方法
	// 实例方法
	public void print(){
		System.out.println(this.year + "年" + this.month + "月" + this.day + "日");
	}
	//setter和getter

	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 class DataTest {
	public static void main(String[] args){
		//创建日期对象,无参
		Data d1 = new Data();
		d1.print(); 
		
		//有参数
		Data d2 = new Data(1999,1,1);
		d2.print();
	}
}

需要注意:this()只能出现在构造方法的第一行!

public class StaticTest {
	public static void main(String[] args){
		StaticTest.doSome();
		//在同一个类中,可以省略类名
		doSome();
		
	}
	
	// 带有static关键字的方法,需要使用“类名.”的方式访问
	public static void doSome(){
		System.out.println("do some");
	}
}

测试一下能否通过引用.的方式访问:

public class StaticTest {
	public static void main(String[] args){
		StaticTest s = new StaticTest();
		s.doSome();
		
		// 引用设置为空
		s = null;
		s.doSome();
		
	}
	
	// 带有static关键字的方法,需要使用“类名.”的方式访问
	public static void doSome(){
		System.out.println("do some");
	}
}

结果是可以访问的,在这里需要再次解释一下空指针异常:空引用访问实例相关(实例变量,实例方法)的数据,需要对象参与才行,当空引用的时候,对象不存在,访问这些实例数据一定会出现空指针异常

带有static的方法,可以通过类名.的方式访问,也可以采用引用.的方式访问,但是采用引用.方式访问的时候,跟引用指向的对象无关

未经允许不得转载:作者:鳄鱼君, 转载或复制请以 超链接形式 并注明出处 鳄鱼君
原文地址:《Java基础 参数传递 this关键字》 发布于2020-08-07

分享到:
赞(0) 赏杯咖啡

评论 抢沙发

4 + 5 =


文章对你有帮助可赏作者一杯咖啡

支付宝扫一扫打赏

微信扫一扫打赏

Vieu4.6主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。
切换注册

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录
切换登录

注册