Java面向对象编程（五）

 一、Object类的使用

• Object类是所有Java类的根父类
• 如果在类的声明中未使用extends关键字指明父类，则默认父类为java.lang.Object类
• Object类中的功能（属性、方法）具有通用性
• Object类只声明了一个空参构造器

public class Person{

                ......

}

等价于：

public class Person extends Onject{

                ......

}

Object类的主要结构

equals()方法的使用

1、equals()是一个方法，而非运算符

2、equals()只能适用于引用数据类型

3、Object类中equals()的定义：

public boolean equals(Object obj){

        return（this==obj）;

}

说明：Object类中的equals()方法和“==”的作用是相同的，都是比较量两对象的 地址值。

4、想String、Date、File，包装类等都重写了Object类中的euqals()方法，重写之后比较的不知两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同

5、通常情况下，使用equals()也通常比较的是两对象的“实体内容”。因此需要对Object()类中的equals()方法进行重写

equals()方法重写原则

比较两对象的实体内容是否相等

 练习

1.编写Order类，有int型的orderId，String型的orderName，相应的 getter()和setter()方法，两个参数的构造器，重写父类的equals()方法： public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。

public class OrderTest {
	public static void main(String[] args) {
		Order order1=new Order(1001,"AA");
		Order order2=new Order(1001,"AB");
		System.out.println(order1.equals(order2));
		
	}
}
 
class Order{
	private int orderId;
	private String orderName;
	
	public Order(int orderId ,String orderName) {
		this.orderId=orderId;
		this.orderName=orderName;
	}
	
	public int getOrderId() {
		return orderId;
	}
	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}
	@Override
	public boolean equals(Object obj) {
		if(this==obj) {
			return true;
		}
		if(obj instanceof Order) {
			Order order=(Order)obj;//强转
			
			return this.orderId==order.orderId&&this.orderName.equals(order.orderName);	
		}
		return false;
	}
}

运行结果如下：

 toString()方法

1、toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址

public String toString{

        return getClass.getname()+"@"+Intteger.toHexString(hashCode());

}

2、在进行String与其他类型数据的连接时，自定调用toString()方法

Date now =new Date;

System.out.println("now="+now);

相当于：

System.out.println("now="+now.toString());

3、当我们输出一个对象的引用时，实际上是调用了当前对象的yoString()方法 

4、基本数据类型转换为String类型是，调用了包装类中的toString()方法

5、像String、Date、File、包装类都重写了Object类的toString()方法，使得对象再调用toString()方法时，返回的是“实体内容”信息

6、自定义类可以根据需要重写toString()方法，是的方法返回的是对象的“实体内容”

练习

定义两个类，父类GeometricObject代表几何形状，子类Circle代表圆形。

 

 写一个测试类，创建两个Circle对象，判断其颜色是否相等；利用equals方法判断其半径是否相等；利用 toString()方法输出其半径。

public class ObjectTest {
	public static void main(String[] args) {
		Circle o1=new Circle(1.0);
		Circle o2=new Circle(2.0);
		System.out.println("两圆的颜色是否相等："+o1.getColor().equals(o2.getColor()));
		System.out.println("两圆的半径是否相等："+o1.equals(o2));
		System.out.println("圆1的半径为："+o1.toString());
		System.out.println("圆2的半径为："+o2.toString());
	}
}
 
 class GeometricObject {
	private String color;
	private double weight;
	
	public GeometricObject() {
		color="white";
		weight=1.0;
	}
 
	/**
	 * @param color:颜色
	 * @param weight：重量
	 */
	public GeometricObject(String color, double weight) {
		this.color = color;
		this.weight = weight;
	}
 
	public String getColor() {
		return color;
	}
 
	public void setColor(String color) {
		this.color = color;
	}
 
	public double getWeight() {
		return weight;
	}
 
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	
}
 class Circle extends GeometricObject {
	private double radius;
	public Circle() {
		super();
		
	}
	public Circle(double radius) {
		super();
		this.radius=radius;
	}
	public Circle(double radius,String color,double weight) {
		super();
		this.radius=radius;
	}
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public double findArea() {
		return getRadius()*getRadius()*Math.PI;
	}
	
	/**
	 * @Override
	 *比较两圆半径是否相等
	 */
	public boolean equals(Object obj) {
		if(this==obj) {
			return true;
		}
		if(obj instanceof Circle) {
			Circle cir=(Circle)obj;
			return cir.radius==this.radius;
		}
		return false;
		
	}
	/**
	 * 	@Override
	 * 输出圆的半径
	 */
	public String toString() {
		return "圆的半径是："+this.radius;
		  
	}
}

运行结果如下：

二、Java中Junit单元测试

1、Junit进行单元测试要求：

• 此类是public类的
• 此类要提供一个无参的构造器

2、此类声明单元测试的方法： 方法的权限public ，没有返回值，没有形参

3、此单元测试方法上需要声明注释：@Test；并在单元测试中导入：import org.junit.Test;

4、声明单元测试方法后，就可以在方法体内测试相关代码

三、包装类(Wrapper)的使用

针对八种基本数据类型定义响应相应的引用类型——包装类（封装类）

有了类的特点，就可以调用类中的方法，java才是真正的面向对象

基本数据类型包装成包装类（装箱）

• 通过包装类的构造器实现

int i=500；

Integer t =new Intrger(i)；                         

• 还可通过字符串参数构造包装类的对象

Float f=new Float("4.56");

获得包装类对象中包装类的基本类型变量（拆箱）

• 调用包装类的.xxxValue();

boolean b=bObj.booleanValue();

 JDK1.5后，支持自动装箱、自动拆箱。但类型必须匹配。

字符串转换成基本数据类型

• 听过包装类的构造器实现

int i=new Integer("12");

• 通过包装类的parseXxx(String s)静态方法

Float f =Float.parseFloat("12.1");

基本数据类型转换成字符串

• 调用字符串重载valueOf()方法

String fstr=String.valueOf(2.34f);

• 更直接的方式

String str=5+“”;

 

 练习题

public void method1() {
    Integer i = new Integer(1);
    Integer j = new Integer(1);
    System.out.println(i == j);//会输出false（==比较的是地址值）
    Integer m = 1;
    Integer n = 1;//自动装箱
    System.out.println(m == n);//true
    Integer x = 128;
    Integer y = 128;//相当于new了一个Integer对象
    System.out.println(x == y);//false
}
/*
**Integer内部定义了IntegerCache结构，IntegerCache中定义了一个
**Integer[]，保存了从-128~127，如果使用自动装箱的方式，给Integer赋值，
**变量范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了
*/

Integer内部定义了IntegerCache结构，IntegerCache中定义了一个Integer[]，保存了从-128~127，如果使用自动装箱的方式，给Integer赋值，变量范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了