Java从入门到精通 第17章 对象的引用与传递

17.1初步了解引用传递

对象的实例化分配内存操作
Book book=null;
book =new Book();
book.title="java program design";
book.price=39.8;
book.info();

17.2 引用数据类型的传递

//基本数据类型的传递
//一下操作之后，a和b的数值并没有改变，和c语言一样
class Test{
	public static void main(String[] args){
		int a=2,b=4;
		swap(a,b);
		System.out.print(a+","+b);
	}
	public static void swap(int a,int b){
		int tmp;
		tmp=a;
		a=b;
		b=tmp;
	}
}

//引用数据类型的传递
public static void change(int[] count)//数组是引用数据类型可以传递

//对象的引用传递
Person p1;
Person p2;
p1=p2;

//引用传递的使用
public void setHouse(House house)
{
　　this.house=house;//引用传递
}

17.3 引用传递与现实生活

/**
 * @(#)Test.java
 *
 *
 * @author 
 * @version 1.00 2019/4/9
 */
public class Test {

    public Test() {
    }
    public static void main(String[] args){
    	System.out.println("Hello,World!");
    	Person per=new Person("42932","zhangsan");
    	House h=new House(666,"zhongguancun");
    	h.setPerson(per);//房子属于人
    	per.setHouse(h);//人有房子
    	System.out.println(per.getPersonInfo());
    	System.out.println(per.getHouse().getHouseInfo());
    	System.out.println(h.getPerson().getPersonInfo());
    }
    
}

class Person{
	private String no;
	private String name;
	private House house;//表示一个房子
	public Person(String no,String name){
		this.no=no;
		this.name=name;
	}
	public String getPersonInfo(){
		return "人的编号:"+this.no+",name:"+this.name;
	}
	public void setHouse(House house){
		this.house=house;//引用传递
	}
	public House getHouse(){
		return this.house;
	}
}
class House{
	private double area;
	private String address;
	private Person person;
	public House(double area,String address){
		this.area=area;
		this.address=address;
	}
	public String getHouseInfo(){
		return "House's area:"+this.area+", address:"+this.address;
	}
	public void setPerson(Person person){
		this.person=person;//引用传递
	}
	public Person getPerson(){
		return this.person;
	}
}

17.4 集成设计模式

通过分析，我们发现不同的事物类之间都是依靠引用进行连接的

class MainBoard{
	private Cpu cpu;
	private Memory memory;
	private Disk disk;
}

class Cpu{
}
class Disk{
}
class Memory{
}
class Box{
	private Power power;
	private MainBoard mainBoard;
}

class Power{
}
class Screen{
}
class KeyBoard{
}
class Mouse{
}

class Computer{
	private Box box;
	private Screen screen;
	private KeyBoard keyboard;
	private Mouse mouse;
}

17.5 对象克隆

Book A=new Book();
BooK B=new (Book)bookA.clone();//对象克隆

/**
 * @(#)Test.java
 *
 *
 * @author 
 * @version 1.00 2019/4/9
 */
public class Test {

    public Test() {
    }
    public static void main(String args[])throws Exception{
    	Book bookA=new Book("Java from primamry to higher",79.8);
    	Book bookB=(Book)bookA.clone();//对象克隆，我想知道克隆有什么好，好像与bookB=bookA有区别
    	bookB.setPrice(100.64);
    	System.out.println(bookA);
    	System.out.println(bookB);
    }
    
}
class Book implements Cloneable{
	private String title;
	private double price;
	public Book(String title,double price){
		this.title=title;
		this.price=price;
	}
	public String getTitle(){
		return title;
	}
	public void setTtile(String title){
		this.title=title;
	}
	public double getPrice(){
		return price;
	}
	public void setPrice(double price){
		this.price=price;
	}
	
	@Override
	protected Object clone()throws CloneNotSupportedException{
		return super.clone();
	}
	@Override
	public String toString(){
		return "Book[title="+title+",price="+price+"]";
	}
}

//result
Book[title=Java from primamry to higher,price=79.8]
Book[title=Java from primamry to higher,price=100.64]

17.6 反射机制

~　　反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个类，都能够调用它的任意一个方法，这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制
　　Java反射机制主要提供了一下功能：
　　在运行时判断任意一个对象所属的类；
　　在运行时构造任意一个类的对象；
　　在运行时判断任意一个类所具有的成员变量和方法；
　　在运行时调用任意一个对象方法

//根据对象找到类
Date date=new Date()
Class<?>cls=date.getClass();//通过Java反射机制得到类的包名
//reuslt
class java.util.Date

//根据对象找到类
Class<?>cls=Class.forName("Book");
Book book=new (Book)cls.newInstance();

//传统的工厂设计模式
interface Book{
}
class MathBook implements Book{
}
class Factory{
　　public static Book getInstance(String className)
}
Book book=Factory.getInstance("mathbook");//实例化一个对象

//使用反射机制的工厂模式
book=(Book)Class.forName(className).newInstance();

17.6.2 反射的其他操作

//调用构造方法取得实例化对象
Class<?>cls=Class.forName("Book");
Constructor<?> cons=cls.getConstructor(String.class,double.class);
Book book=(Book)cons.newInstance("java development",85.45);
System.out.println(book);

//setter、getter的使用
import java.lang.reflect.Method;
public class Test {

    public Test() {
    }
    public static void main(String args[])throws Exception{
    	String fieldName="title";//设置要操作的属性
    	String titleValue="Java development classic";
    	Class<?>cls=Class.forName("Book");
		Object obj=cls.newInstance();
		Method setMethod=cls.getMethod("set"+initcap(fieldName),String.class);
		Method getMethod=cls.getMethod("get"+initcap(fieldName));
		setMethod.invoke(obj,titleValue);
		System.out.println(getMethod.invoke(obj));
    }
    public static String initcap(String str){
    	return str.substring(0,1).toUpperCase()+str.substring(1);
    }
}

class Book{
	private String title;
	public void setTitle(String title){
		this.title=title;
	}
	public String getTitle(){
		return title;
	}
}

//result
Java development classic

17.7总结

1.对象引用相等
引用相等：即指引用到堆上同一个对象的两个引用时相等的

Book A=new Book();
Book B=A;
A.setTitle="Java Program Design";
B.setTitle="Java Web Development";
A==B;//true
A.equals(B);//true
//需要说明的是，A和B指向同一堆内存，内存地址及内容一致,都是判断引用相等
//如果每个对象单独new，即便内容是一致的但是引用绝对不相等

2.Java垃圾回收机制
每一个栈内存只能保存一块堆内存的地址，但是反过来，一块堆内存可以同时被多个占内存所指向，在这种情况下，如果改变某个占内存的保存地址内容，则必须先断开已有的堆内存地址链接，才可以指向新的内存空间，而如果一块堆内存空间没有任何的栈内存所指向的话，那么这块空间就会成为垃圾，所有的垃圾将等待JVM中的GC进行定期收集，同时进行内存空间的释放。

虽然Java提供了垃圾的自动回收机制，但是考虑到性能的问题，建议操作过程中还是尽量少产生垃圾。