12-8java面向对象对象之引用传递

最新推荐文章于 2021-02-13 00:55:50 发布
最新推荐文章于 2021-02-13 00:55:50 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： java 文章标签： java 面向对象 数组对象 引用传递
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baobeizhanshen/article/details/41807971
版权

今天主要说明在面向对象操作中的引用传递情况。一句话，用面向对象设计可以解释生活中的所有问题。

1.对象数组

对象数组肯定是一个数组，回顾一下我们之前使用过的数组。
int a[] = null; 显然数组的每个成员都是int型变量，那么对象数组中的每个成员就是对象了，类比得知。
定义格式如下：
类名称    对象数组名称[] = new 类名称[长度]；//使用构造方法定义数组中的对象成员。由于类本身属于引用数据类型，所以开辟对象之后都是null。
案例: 
class Info
{
	private String name;
	private int no;
	//构造方法
	Info(String name, int no)
	{
		this.name = name;
		this.no = no;
	}
	public String getInfo()
	{
		return "姓名：" + this.name + ", 编号：" + this.no ;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Info d1[] = new Info[2];		
		for (int i=0;i<d1.length ;++i )
		{
			System.out.println(d1[i]);
			//这里如果使用System.out.println(d1[i].getInfo());会产生空指向，因为对象只声明，没有实例化
		}
	}
}
结果：
下面使用对象实例化
案例： 
class Info
{
	private String name;
	private int no;
	//构造方法
	Info(String name, int no)
	{
		this.name = name;
		this.no = no;
	}
	public String getInfo()
	{
		return "姓名：" + this.name + ", 编号：" + this.no ;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Info d1[] = new Info[2];	
		d1[0]= new Info("张三",20);
		d1[1]= new Info("李四",30);
		for (int i=0;i<d1.length ;++i )
		{
			System.out.println(d1[i].getInfo());
		}
	}
}
结果：
内存关系如图:

同数组非常相似，在对象数组实例化也可以进行静态初始化。
格式：
类名称  对象数组[] =new  类名[]｛对象1，对象2｝new  类名[]可以省略
案例： 
class Info
{
	private String name;
	private int no;
	//构造方法
	Info(String name, int no)
	{
		this.name = name;
		this.no = no;
	}
	public String getInfo()
	{
		return "姓名：" + this.name + ", 编号：" + this.no ;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Info d1[] ={new Info("张三",20),new Info("李四",30)};	
		for (int i=0;i<d1.length ;++i )
		{
			System.out.println(d1[i].getInfo());
		}
	}
}
虽然对象数组可以保存多个对象，但是数组的长度是固定，只有明确知道数据量的情况下才行。不知道个数需要其他手段来实现。

2.经典例题

案例1： 
class Info
{
	private int num=10;
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return this.num;
	}

}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Info d = new Info();			//1.初始化d的num=10
		d.setNum(100);					//2.设置了num=100
		fun(d);							//3.对象的引用传递，相当于指针，此时info的变化等于d的变化
		System.out.println(d.getNum());
	}
	public static void fun(Info info)
	{
		info.setNum(30);
	}
}
结果
内存说明图：
注意：以上传递的是对象内存的使用。
案例2： 

public class TestPass 
{
	public static void main(String[] args) 
	{
		String str= "hello";
		str= "world";
		fun(str);<span style="white-space:pre">		</span>//此时把world这个字符串传递给str1
		System.out.println(str);
	}
	public static void fun(String str1)<span style="white-space:pre">		</span>
	{
		str1="nihao";
	}
}
注意：如果操作的数据是String那么就按照基本类型理解，只是传递值。
内存说明：
案例3: 
class Info
{
	private String msg = "hello";
	public void setMsg(String msg)
	{
		this.msg = msg;
	}
	public String getMsg()
	{
		return this.msg;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Info d = new Info();
		d.setMsg("world");
		fun(d);
		System.out.println(d.getMsg());
	}
	public static void fun(Info temp)
	{
		temp.setMsg("nihao");
	}
}
结果：
本题目中的属性是类的对象，同样是引用传递。同第一题类似。

3.对象的比较

在java中，一个类的属性被封装之后，外部无法通过对象直接进行访问，但是类的对象被回传到类之中，那么就可以用对象进行访问。
一个类的对象在类本身可以不受封装的限制，直接用对象.属性操作。
案例： 
class Info
{
	private String msg = "hello";
	public void setMsg(Info d)		//接收本类的对象
	{
		d.msg= "world";				//直接访问私有属性，并不是this.属性访问
	}
	public String getMsg()
	{
		return this.msg;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Info d = new Info();
		d.setMsg(d);
		System.out.println(d.getMsg());
	}
}
结果：
程序要求：判断两个Person对象是否是相等的？ 
class Person
{
	//进行封装
	private String name;
	private int age;
	//构造方法
	public Person(String name, int age)
	{
		this.setName(name);
		this.setAge(age);
	}
	//普通的方法
	public void setName(String name)		
	{
		this.name = name;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Person per[] = new Person[] {new Person("张三", 20),new Person("da ",22)};
		if (per[0].getName().equals(per[1].getName()) && per[0].getAge() == per[1].getAge() )
		{
			System.out.println("是同一个对象");
		}
		else
		{
			System.out.println("不是同一个对象");
		}
	}
}
结果
但是这种实现是存在问题的，并不是对象之间自己的比较，是通过第三方来实现的。我们的main函数其实就是那个第三方，是客户端的操作。
代码修改如下，使用上面的实例作为因子，在类中用方法进行比较，得出结果。 
class Person
{
//进行封装
	private String name;
	private int age;
//构造方法
	public Person(String name, int age)
	{
		this.setName(name);this.setAge(age);
	}
//普通的方法
	public void setName(String name)
	{
		this.name = name;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public boolean compare(Person person)
	{
		if (person == null)
		{
			return false;
		}
		if (this == person)//两个对象== 比较的是地址值
		{
			return true;
		}
		//类中引用同类可以直接调用封装的属性
		if (this.getName().equals(person.getName()) && this.getAge() == person.getAge() )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
	Person per[] = new Person[] {new Person("张三", 20),new Person("张三", 20)};
	if( per[0].compare(null))
	{
		System.out.println("是同一个对象");
	}
	else 
	{
		System.out.println("不是同一个对象");
	}
	}
}

结果：

4.引用的深入操作

任何实物发展都是由生活而来，面向对象描述的就是生活。
例如：一个人只有一套房。这是典型的一对一的关系，问题来了：如何建立类和类之间的对应关系。
案例： 
class Person
{
	//进行封装
	private String name;
	private int age;
	private House house;			//在类中建立其他类，一个人只有一套房子
	//构造方法
	public Person(String name, int age)
	{
		this.name = name ;
		this.age = age ;
	}
	//普通的方法	
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}	
	public void setHouse(House house)
	{
		this.house = house;
	}
	public House getHouse(House house)
	{
		return this.house;
	}
}
class House
{
	private String loc;
	private Person person;
	public House(String loc)
	{
		this.loc = loc;
	}
	public String getLoc()
	{
		return this.loc;
	}
	public void setPerson(Person person)
	{
		this.person = person;
	}
	public Person getPerson()
	{
		return this.person;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Person per = new Person("张三", 20);
		House hou = new House("乳山");		//并没有完全实例化
		per.setHouse(hou);				//一个人有一套房子
		hou.setPerson(per);				//一个房子属于一个人
		System.out.println("姓名：" +  per.getName() + ",年龄："+ per.getAge()		//人找房子
							+ "，住址：" + 	per.getHouse(hou).getLoc());
		System.out.println("住址：" + hou.getLoc() + ",属于：" +hou.getPerson().getName() 
							+ ",年龄：" + hou.getPerson().getAge());		//房子找人
	}
}
结果：
问题来了：如何表示传递关系，一个人有一个孩子，一个孩子有一套房子？
由于孩子也是人的类，所以在人的类中引入人的对象
案例： 
class Person
{
	//进行封装
	private String name;
	private int age;
	private House house;			//在类中建立其他类，一个人只有一套房子
	private Person child;
	//构造方法
	public Person(String name, int age)
	{
		this.name = name ;
		this.age = age ;
	}
	//普通的方法	
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public void setChild(Person child)
	{
		this.child =child;
	}
	public Person getChild()
	{
		return this.child;
	}
	public void setHouse(House house)
	{
		this.house = house;
	}
	public House getHouse(House house)
	{
		return this.house;
	}
}
class House
{
	private String loc;
	private Person person;	
	public House(String loc)
	{
		this.loc = loc;
	}
	public String getLoc()
	{
		return this.loc;
	}	
	public void setPerson(Person person)
	{
		this.person = person;
	}
	public Person getPerson()
	{
		return this.person;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Person per = new Person("张三", 20);
		House hou = new House("乳山");		//并没有完全实例化
		Person chi = new Person("张涨", 2);
		per.setChild(chi);				
		hou.setPerson(chi);
		chi.setHouse(hou);
		System.out.println("姓名：" +  per.getName() + ",年龄："+ per.getAge()		//人找房子
							+ ",孩子："	+chi.getName() +",年龄："+ chi.getAge()	
							+ "，住址：" + 	chi.getHouse(hou).getLoc());
	}
}
结果：
问题又来了：上面这个例子显然是一对一的关系，那么出现了一对多的关系该如何？
比如一个人有两本书，多的概念可以通过数组来表示
案例: 
class Person
{
	//进行封装
	private String name;
	private int age;
	private Books[] books;
	//构造方法
	public Person(String name, int age)
	{
		this.name = name ;
		this.age = age ;
	}
	//普通的方法	
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public void setBooks(Books[] books)
	{
		this.books = books;
	}
	public Books[] getBooks()
	{
		return this.books;
	}

}
class Books
{
	private String title;
	private Person person;
	public Books(String title)
	{
		this.title = title;
	}
	public void setPerson(Person person)
	{
		this.person = person;
	}
	public Person getPerson()
	{
		return this.person;
	}
	public String getTitle()
	{
		return this.title;
	}
}
public class TestPass 
{
	public static void main(String[] args) 
	{
		Person per = new Person("张三", 20);
		Books books[] = new Books[]{new Books("java"),new Books("c")};
		per.setBooks(books);		//人对应书
		for (int i=0;i<books.length ; ++i)
		{
			books[i].setPerson(per);		//书给人
			System.out.println("姓名:" + books[i].getPerson().getName() + ",书名：" + books[i].getTitle());
		}
	}
}
结果
本次课程 非常重要，健健康康，快快乐乐。

baobeizhanshen
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组和字符串（面向对象篇）
云飞
04-24 1335
本章为大家介绍java中预定义好的两个类：数组和字符串。 数组依照存放元素的复杂程度，可分为一维数组、二维数组和多维数组。一维数组的声明格式：数组类型 数组名[]，如声明一个整型数组score，用来保存学生成绩，int score[]; 数组元素的表示方法：java的数组索引编号从0开始，示例声明一个一维数组，长度为3，利用for循环输出数组的内容后，再输出数组的元素个数。 运行结果
Java总结——Java面向对象中引用的传递
不想起标题
05-18 339
引用传递： 也称为传地址。有点类似与指针传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。 值传递： 方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参 数的值。 例如： package java面向对象; /** ...
java面向对象：引用传递
qq_35429013的博客
07-29 301
引用传递：package bao;////////引用传递案例： class Ref{       //名称 最好大写开头 int temp=10;//声明变量，并初始化 } public class refdemo {   public static void main(String[] args) {  Ref ref;         //主方法调用temp使用  ref=ne
java面向对象 【专题】引用传递
lzl_csdn的专栏
10-14 507
引用传递时整个java的精髓所在,
Java-面向对象中引用传递和按值传递
PowerAlan的博客
12-13 480
我们先从一段代码中了解面对对象中引用传递和按值传递class Demo { int a ; } class Test { public static void update(Demo d){ d.a += 10; } public static void update(int a){ a += 10; } public
Java-Java面向对象中引用传递教程
最新发布
11-09
Java 面向对象中引用传递教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
Java面向对象-笔记.docx
12-17
Java面向对象笔记 面向对象是一种编程思想，Java是一种面向对象的编程语言。下面是Java面向对象笔记的知识点摘要： 一、类和对象 * 对象：对象是一个实体，由一组属性和方法构成。对象的属性是对象具有的各种特征...
面试知识点总结--Java面向对象.pdf
01-25
Java面向对象是Java编程的核心，理解其概念和特性对于成为一名合格的Java开发者至关重要。下面将详细阐述面试中可能涉及的一些关键知识点。 1. **super()与this()的区别**： - `this`关键字用于引用当前类的对象，...
Java面向对象值传递和引用传递
07-20
Java 面向对象值传递和引用传递 Java 面向对象编程中，参数传递是非常重要的一个概念。参数传递有两种方式：值传递和引用传递。了解这两种方式的区别是非常重要的，因为它们对程序的执行结果产生了很大的影响。 值...
大学课程讲义-Java基础-面向对象.pptx
08-14
Java是一种面向对象的编程语言，它的核心理念是通过模拟现实世界中的对象来构建软件系统。在Java中，类（Class）是对象（Object）的蓝图，它定义了对象的属性（Attributes）和行为（Methods）。面向对象编程的主要...
java面向对象值传递和引用传递
追梦空间
03-30 102
一直被这个参数到底是值传递还是引用传递的问题纠结 今晚特意好好想了想，总结如下： 值传递：传递的就是实际的内存当中存储的 实在的值 例如：int a=3; a 就指向了内存当中某一个物理地址里面存储的3 当把a传递给另外一个变量，不管是局部变量还是 全局变量，都是值传递，即把a指向的物理内存中的这个3 传递给了另外一个变量，例如int b=a; 这句话之后就把3传递给了b，可能b在内存中又开...
Java基础-面向对象-值传递与引用传递
hughjin
12-25 241
Java工程师知识树 / Java基础 一：值传递 **解释:在方法的调用过程中，实参把它的实际值传递给形参，**此传递过程就是将实参的值复制一份传递到函数中，这样如果在函数中对该值（形参的值）进行了操作将不会影响实参的值。因为是直接复制，所以这种方式在传递大量数据时，运行效率会特别低下。 代码示例 package arrayDemo; public class Demo1 { public static void main(String[] args) {
Java面向对象-方法的值传递和引用传递
weixin_30633507的博客
08-24 93
Java面向对象-方法的值传递和引用传递 0 发布时间：『 2016-08-21 14:21』博客类别：Java核心基础阅读(197) 评论(0) Java面向对象-方法的值传递和引用传递 方法的值传递： 值传递 在方法里改变变量的值 作用范围仅仅是方法里 对外面不影响： 上代码： 1 2 3 4 5 6 7 8 9 ...
Java传递基本类型：值传递，对象作为参数：引用传递
幸福ITman汪文威的专栏
02-25 7203
值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参 数的值。 引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。 下面举例说明： 传值---传递基本数据类型参数 package w
java之方法参数的引用传递（浅析）
热门推荐
瓦尔登湖
08-10 2万+
算是比较基础的东西 （如果看着累可以直奔结论） 先上代码1： public class Quote1 { // 引用不会改变变量，即形参不会改变主方法中的实参 public static void main(String[] args) { int i = 0; function1(i); System.out.println(i); String str = "...
Java基础(极客)——19、Java面向对象之泛型（补充）
翟浩浩Android专栏
05-26 453
package com.zhh.java.fanxing; /**  * 1、Java面向对象之泛型－认识泛型  * 1、泛型是在jdk1.5之后的新功能 2、泛型可以解决数据类型的安全性问题，他的主要原理， 是在类声明的时候通过一个标识表示类中某个属性的类型 或者是某个方法的返回值及参数类型；  *   */ public class FanXingDemo1
java如何实现引用传递_java类方法如何实现引用传递和值传递
weixin_29050829的博客
02-13 1070
展开全部参数是基本e69da5e6ba9062616964757a686964616f31333431353235类型就是传值，传对象就是引用传递。swap(Integer x, Integer y)可以传递引用，但是没办法实现交换。这跟Integer的实现方式有关。所以不是引用传递就一定能改变外面的值。下面是引用传递，交换的情况，又臭又长。classUntitled{intneedFix;...
Java 值传递和对象传递详解
冯海林的专栏
05-12 8316
1、需要明白的概念： 堆和栈：Java中基本数据类型的值和对象的引用保存在栈中，具体对象值保存在堆中。传递原理： 一个方法传递的参数如果是基本数据类型，则是对具体值的拷贝；如果是对象数据类型，则是对对象引用地址值的拷贝，而非具体值拷贝。下面分析三种情况：①一个方法不能改变传入基本类型的参数值。 示例代码：public class Test2 { public static void ma

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值