Java学习第五章——面向对象编程（中）

继续开展面向对象的学习，本章内容翔实，请君静下心开始新的修炼。

目录

OOP特征二：继承性

方法的重写(override)

四种访问权限修饰符

关键字：super

子类对象实例化过程

OOP特征三：多态性

Object类的使用

补充知识：单元测试方法的使用

包装类的使用

本章结束语

---

OOP特征二：继承性

为什么要有继承
    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
    此处的多个类称为子类 (派生类 )，单独的这个类称为父类 (基类或超类)。可以理解为“子类 is a 父类”

类继承语法规则 :
class Subclass extends  SuperClass{}

引例：

为描述和处理个人信息，定义类Person:
class Person{
    public String name;
    public int age;
    public Date birthDate;

    public String getInfo(){
    }
}

为描述和处理学生信息，定义类Student:
class Student{
    public String name;
    public int age;
    public Date birthDate;
    public String school;//(较person不同的点)

    public String getInfo(){
    }
}

通过继承，可以简化Student类的定义： 

class Person{
    public String name;
    public int age;
    public Date birthDate;

    public String getInfo(){
    }
}

class Student extends Person{
    public String school;
}

Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person类的属性和方法，Student都可以使用。

继承作用
   减少了代码冗余，提高了代码的复用性。
   有利于功能扩展。
   继承的出现让类与类之间产生了关系，提供了多态的前提。
   注意：不要仅为了获取其他类中某个功能而去继承。

关于继承的规则

    在子类中，可以使用父类定义的方法和属性，也可以创建新的数据和方法。在Java中，继承的关键字用的是“extends”，即子类不是父类的子集， 而是对父类的“扩展” 。
    子类不能直接访问父类中私有的 (private)成员变量和方法。（私有的属性和方法继承到了，因为封装性的影响，使得子类不能直接调用父类的结构）。通过getter和setter方法调用。

Java只支持单继承和多层继承，不允许多重继承
     一个子类只能有一个父类   一个父类可以派生出多个子类
    子类直接继承的父类，称为：直接父类，间接继承的父类称为间接父类
    子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
   class  SubDemo extends Demo{ }//ok
   class  SubDemo extends Demo1,Demo2...//error

如果没有显式声明一个类的父类，则此类继承于java.lang.Object类，所有的java类，都直接或间接继承java.lang.Object类，意味着所有的java类具有java.lang.Object类声明的功能。

 练习：

 基本练习题，过程略

2.根据下图实现类 。在 CylinderTest类中创建 Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱体积。

Cicle类
public class Circle {
	private double radius;
	public Circle() {
		radius = 1.0;
	}
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public double findArea() {
		double s = Math.PI*radius*radius;
		return s;
	}	
}
cylinder类
public class Cylinder extends Circle{
	private double length;
	public Cylinder() {
		length = 1.0;
	}
	
	public double getLength() {
		return length;
	}

	public void setLength(double length) {
		this.length = length;
	}
	
	public double findVolume() {
		return findArea()*length;
	}
}

class CylinderTest{
	public static void main(String[] args) {
		Cylinder cy = new Cylinder();
		cy.setRadius(2.1);
		cy.setLength(3.4);
		double volume = cy.findVolume();
		System.out.println(volume);
	}
}

方法的重写(override)

定义

在子类中可以根据需要对从父类中继承来的方法（同名同参）进行改造，也称为方法的重置、覆盖 。在程序执行时，子类的方法将覆盖父类的方法。

方法的声明： 权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{
		//方法体
 		}
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

要求
    1. 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
    2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
           父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
           父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
           父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的
    3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限（向上转型及java程序设计维护的原因），子类不能重写父类中声明为private权限的方法（特殊情况）
    4. 子类方法抛出的异常不能大于父类被重写方法的异常（具体放到异常处理时讲解）

注意：

子类与父类中同名同参数的方法必须同时声明为非static的（即为重写 ）。或者同时声明为static的（不是重写）。静态的方法不能被覆盖，随着类的加载而加载

区分方法的重载和重写

练习：如果现在父类的一个方法定义成 private访问权限，在子类中将此方法声明为default 访问权限，那么这样还叫重写吗  ？(NO)

四种访问权限修饰符

Java权限修饰符public、protected、(缺省)、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于class的权限修饰只可以用public和default（缺省）。

public类可以在任意地方被访问。default类只可以被同一个包内部的类访问

关键字：super

在Java类中使用super来调用父类中的指定操作：
super可用于访问父类中定义的属性和成员方法，super可用于在子类构造器中调用父类的构造器。

注意：
    尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
    super的追溯不仅限于直接父类
    super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

调用父类的构造器
    子类中所有的构造器默认都会访问父类中空参数的构造器。super();
    当父类中没有空参数的构造器时,子类的构造器必须通过this( 参数列表)或者super(参数列表 )语句指定调用本类或者父类中相应的构造器。同时，this和super只能 ”二选一 ”，且必须放在构造器的首行
    如果子类构造器中既未显式调用父类或本类的构造器，且父类中没有无参的构造器，则编译出错

    在类的构造器中，至多有n-1个构造器使用了this,至少有一个构造器使用了super调用父类的构造器

代码示例

调用父类构造器示例：

this和super的区别

子类对象实例化过程

  1. 从结果上来看：（继承性）
       子类继承父类以后，就获取了父类中声明的属性或方法。创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

2. 从过程上来看：
     当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，...直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

（每个小框代表构造器）   
  明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

代码示例：

package com.atguigu.exercise;

public class Creature {
	public Creature() {
		System.out.println("Creature无参数的构造器");
	}
}
class Animal extends Creature{
	public Animal(String name) {
		System.out.println("Animal带一个参数的构造器，该动物的name为"+name);
	}	
	public Animal(String name,int age) {
		this(name);
		System.out.println("Animal带两个参数的构造器，其age为："+age);
	}
}
class Wolf extends Animal{
	public Wolf() {
		super("大灰狼",3);
		System.out.println("Wolf无参数的构造器");
	}
	
	public static void main(String[] args) {
		new Wolf();
	}
}

运行结果：

Creature无参数的构造器
Animal带一个参数的构造器，该动物的name为大灰狼
Animal带两个参数的构造器，其age为：3
Wolf无参数的构造器

实验练习

OOP特征三：多态性

多态性，是面向对象中最重要的概念 ，在Java 中的体现：
    对象的多态性：父类的引用指向子类的对象
        可以直接应用在抽象类和接口上（后章节介绍）

Java引用变量有两个类型： 编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定 。简称： 编译时，看左边；运行时 ，看右边 。 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
    多态情况下"看左边 ”：看的是父类的引用 （父类中不具备子类特有的方法 ）
                      “看右边 ”：看的是子类的对象 （实际运行的是子类重写父类的方法 ）

对象的多态——在Java 中,子类的对象可以替代父类的对象使用
    一个变量只能有一种确定的数据类型
    一个引用类型变量可能指向 (引用 )多种不同类型的对象

Person  p=new Student() ;
Object o=new Person();//Object类型的变量o，指向Person类型的对象
Object o=new Student();//Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可指向子类的对象：向上转型 (upcasting )。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。

Student m = new Student();
m.school = “ pku ”; // 合法 ,Student类有 school 成员变量
Person e = new Student(); 
e.school = “ pku ”; // 非法 ,Person类没有school成员变量
属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

示例代码

public class Person {
	String name;
	int age;	
	int id = 1001;	
	public void eat(){
		System.out.println("人：吃饭");
	}
	
	public void walk(){
		System.out.println("人：走路");
	}	
}

public class Man extends Person{
	boolean isSmoking;
	int id = 1002;
	public void earnMoney(){
		System.out.println("男人负责挣钱养家");
	}	
	public void eat(){
		System.out.println("男人多吃肉，长肌肉");
	}	
	public void walk(){
		System.out.println("男人霸气的走路");
	}
}


public class Woman extends Person{
	boolean isBeauty;
	public void goShopping(){
		System.out.println("女人喜欢购物");
	}	
	public void eat(){
		System.out.println("女人少吃，为了减肥");
	}	
	public void walk(){
		System.out.println("女人窈窕的走路");
	}
}

public class PersonTest {	
	public static void main(String[] args) {		
		Person p1 = new Person();
		p1.eat();
		
		Man man = new Man();
		man.eat();
		man.age = 25;
		man.earnMoney();
		
		//对象的多态性：父类的引用指向子类的对象
		Person p2 = new Man();
		Person p3 = new Woman();
		//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
		p2.eat();
		p2.walk();	
//		p2.earnMoney(); 报错，调的只能是person里声明的方法。有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
		System.out.println(p2.id);//1001 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）	
	}
}

多态性使用举例

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法（子类的对象传递给父类的参数）

多态性的使用举例一：
public class AnimalTest {
	
	public static void main(String[] args) {		
		AnimalTest test = new AnimalTest();
		test.func(new Dog());		
		test.func(new Cat());
	}
	
	public void func(Animal animal){//Animal animal = new Dog();
		animal.eat();
		animal.shout();		
		if(animal instanceof Dog){
			Dog d = (Dog)animal;
			d.watchDoor();
		}
	}
	
//如果没有多态性
	public void func(Dog dog){
		dog.eat();
		dog.shout();
    }
	public void func(Cat cat){
		cat.eat();
		cat.shout();
	}
}


class Animal{	
	public void eat(){
		System.out.println("动物：进食");
	}	
	public void shout(){
		System.out.println("动物：叫");
	}	
}

class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头");
	}	
	public void shout(){
		System.out.println("汪！汪！汪！");
	}
	
	public void watchDoor(){
		System.out.println("看门");
	}
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}	
	public void shout(){
		System.out.println("喵！喵！喵！");
	}
}

//举例二：
class Order{	
	public void method(Object obj){
		
	}
}

//举例三：
class Driver{
	
	public void doData(Connection conn){
    //conn = new MySQlConnection(); conn = new OracleConnection();
		//规范的步骤去操作数据
//		conn.method1();
//		conn.method2();
//		conn.method3();		
	}	
}

虚拟方法调用 (Virtual Method Invocation)

正常的方法调用

Person e = new Person(); 
e.getInfo;
Student e = new Student(); 
e.getInfo;

虚拟方法调用 (多态情况下）

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法。父类根据赋给它的不同子类对象，动态调用属于子类的该方法 。这样的方法调用在编译期是无法确定的。

Person e = new Student(); 
e.getInfo ; // 调用Student类的getInfo方法

编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo方法。 —— 动态绑定

举例：

 前提：Person类中定义了 welcome()方法，各个子类重写了welcome()。
执行：多态的情况下，调用对象的welcome()方法，实际执行的是子类重写的方法

注意

对象不能调用子类所特有的方法、属性：编译时，p2是Person类型。

//无法通过编译
p2.name = "Tom";
p2.earnMoney();
p2.isSmoking = true;

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特有的属性和方法？
        向下转型：使用强制类型转换符。 

	
	Man m1 = (Man)p2;
	m1.earnMoney();
	m1.isSmoking = true;
	
	使用强转时，可能出现ClassCastException的异常。
	Woman w1 = (Woman)p2;
	w1.goShopping();

不能调用子类所特有的方法、属性：编译时，p2是Person类型。 

方法的重载与重写
1. 二者的定义细节： 略
2. 从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表， 对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了 。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以： 对于重载而言， 在方法调用之前编译器就已经确定了所要调用的方法，这称为 “早绑定” 或“静态绑定”；
而对于多态，只有等到方法调用的那一刻，编译器才会确定所要调用的具体方法，这称为 “晚绑定” 或“动态绑定”。
引用一句 Bruce Eckel的话： “不要犯傻，如果它不是晚绑定 ，它就不是多态。
多态小结
多态作用：提高了代码的通用性，常称作接口重用
前提 ：
    需要存在继承或者实现关系
    有方法的重写
成员方法：
    编译时 ：要查看引用变量所声明的类中是否有所调用的方法。
    运行时 ：调用实际new的对象所属的类中的重写方法 。
成员变量：
    不具备多态性，只看引用变量所声明的类。

instanceof操作符

x instanceof  A：检验x是否为类A的对象，返回值为boolean型。
    要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
    如果x属于类A的子类B，x instanceof A值也为 true 。
使用情景：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型，反之。

public class Person extends Object {…} 
public class Student extends Person {…} 
public class Graduate extends Person {…}
public void method1(Person e) {
if (e instanceof Person) 
// 处理Person类及其子类对象 
if (e instanceof Student) 
// 处理Student类及其子类对象
if (e instanceof Graduate) 
 处理Graduate类及其子类对象

对象类型转换 (Casting )

问题一：编译时通过，运行时不通过
		举例一：
		Person p3 = new Woman();
		Man m3 = (Man)p3;
		举例二：
		Person p4 = new Person();
		Man m4 = (Man)p4; //要使向下转型可行，new的不能是父类对象
		
问题二：编译通过，运行时也通过
		Object obj = new Woman();
		Person p = (Person)obj;
		
问题三：编译不通过
		Man m5 = new Woman();		
		String str = new Date();
		Object o = new Date();
		String str1 = (String)o;

基本数据类型的Casting:
    自动类型转换：小的数据类型可以自动转换成大的数据类型
    如long g= 20 ;double d= 12.0f
    强制类型转换：可以把大的数据类型强制转换 (casting)成小的数据类型
    如 float f=(float) 12.0;int a=( int)1200L

对Java对象的强制类型转换称为造型
  从子类到父类的类型转换可以自动进行
  从父类到子类的类型转换必须通过造型(强制类型转换)实现（new的不能直接是父类对象）

Person p4 = new Person();
Man m4 = (Man)p4; //要使向下转型可行，new的不能是父类对象

  无继承关系的引用类型间转换是非法的
  在造型前可以使用 instanceof操作符测试一个对象的类型

 练习

class Base {
	int count = 10;
	public void display() {
		System.out.println(this.count);
	}
}

class Sub extends Base {
	int count = 20;
	public void display() {
		System.out.println(this.count);
	}
}

public class FieldMethodTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
		
		Base b = s;//多态性
		//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
		System.out.println(b == s);//true
		System.out.println(b.count);//10（多态性不适用于属性）
		b.display();//20 多态性执行虚拟方法调用
	}
}

上题总结：

PS:
 1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
  
 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边 

public class InstanceTest {

	public static void main(String[] args) {
		InstanceTest test = new InstanceTest();
		//Student e = new Student();
		Graduate e = new Graduate();
		test.method(e);

	}
	public void method(Person e) {
		String s = e.getInfo();
		System.out.println(s);
		if(e instanceof Graduate) {
			System.out.println("a graduated student");
		}
		if(e instanceof Student) {
			System.out.println("a student");
		}
		if (e instanceof Person) {
			System.out.println("a person");
		}
	}
}

定义三个类，父类GeometricObject代表几何形状，子类Circle代表圆形，MyRectangle代表矩形。定义一个测试类GeometricTes，编写 equalsArea方法测试两个对象的面积是否相等（注意方法的参数类型，利用动态绑定技术），编写displayGeometricObject方法显示对象的面积（注意方法的参数类型，利用动态绑定技术）。 

package com.atguigu.exercise;

public class GeometricObject {
	//#表示protected
	 protected String color;
	 protected double weight;	 
	 
	public GeometricObject(String color, double weight) {
		super();
		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;
	}
	
	public double findArea() {
	//后面子类的方法对此都会进行重写
		return 0.0;
	}
}

class Circle extends GeometricObject{
	private double radius;

	public Circle(double radius,String color, double weight) {
		super(color, weight);
		this.radius = radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	public double findArea() {
		return (Math.PI*radius*radius);
	}
}

class MyRectangle extends GeometricObject{
	private double width;
	private double height;
	public MyRectangle(String color, double weight, double width, double height) {
		super(color, weight);
		this.width = width;
		this.height = height;
	}
	public double getWidth() {
		return width;
	}
	public void setWidth(double width) {
		this.width = width;
	}
	public double getHeight() {
		return height;
	}
	public void setHeight(double height) {
		this.height = height;
	}
	public double findArea() {
		return width*height;
	}
}

class GeometricTest{
	public static void main(String[] args) {
		GeometricTest test = new GeometricTest();
		Circle c1 = new Circle(2.3, "white", 1.0);
		test.displayGeometricObject(c1);
		Circle c2 = new Circle(3.3, "white", 1.0);
		test.displayGeometricObject(c2);
		MyRectangle m = new MyRectangle(null, 0, 3, 8);
		test.displayGeometricObject(m);
		System.out.println(test.equalsArea(c1, c2));
		
	}
	
	//测试面积是否相等
	public boolean equalsArea(GeometricObject a,GeometricObject b) {
		return a.findArea() == b.findArea();
	}
	
	public void displayGeometricObject(GeometricObject g) {
		double area = g.findArea();
		System.out.println("面积为"+area);
	}
}

多态是编译时行为还是运行时行为 ？试证明 

package com.atguigu.test;
//考查多态的笔试题目：
public class InterviewTest1 {

	public static void main(String[] args) {
		Base base = new Sub();
		base.add(1, 2, 3);

//		Sub s = (Sub)base;
//		s.add(1,2,3);  //输出sub2，确定的
	}
}

class Base {
	public void add(int a, int... arr) {
		System.out.println("base");
	}
}

class Sub extends Base {

	public void add(int a, int[] arr) {
		System.out.println("sub_1");
	}

//	public void add(int a, int b, int c) {//此方法无法重写父类的方法
//		System.out.println("sub_2");
//	}
}

Object类的使用

1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类 
3.Object类中的功能(属性、方法)就具有通用性。
    属性：无
 方法：equals() 、toString()、getClass()、hashCode() 、clone()、finalize()、wait() 、 notify()、notifyAll()

4. Object类只声明了一个空参的构造器

Object 类中的主要结构

 ==操作符与equals方法

==：基本类型比较值 :只要两个变量的值相等 ，即为true 。     
如int a= 5;if(a== 6){ …}

引用类型比较引用(是否指向同一个对象 )：只有指向同一个对象时 ，== 才返回 true 。
Person p1=new Person() ;
Person p2=new Person() ;
if (p1==p2){ …}

用“==” 进行比较时，符号两边的数据类型必须兼容 (可自动转换的基本数据类型除外 )，否则编译出错

基本数据类型
	int i = 10;
	int j = 10;
	double d = 10.0;
	System.out.println(i == j);//true
	System.out.println(i == d);//true 类型自动转换
		
	boolean b = true;
	System.out.println(i == b);//编译报错
		
	char c = 10;
	System.out.println(i == c);//true 解释：10为char的直接ASCII的值，和c = '10'不同
		
	char c1 = 'A';
	char c2 = 65;
	System.out.println(c1 == c2);//true

引用类型：
	Customer cust1 = new Customer("Tom",21);
	Customer cust2 = new Customer("Tom",21);
	System.out.println(cust1 == cust2);//false 比较两个引用是否指向同一个对象实体
	
	String str1 = new String("atguigu");
	String str2 = new String("atguigu");
	System.out.println(str1 == str2);//false
		

equals() ：所有类都继承了Object，也就获得了equals()方法 。还可以重写 。
    只能比较引用数据类型 ，其作用与 “==”相同 ,比较是否指向同一个对象。
    格式 :obj1.equals(obj2)

Object类中equals()的定义：

    public boolean equals(Object obj) {
            return (this == obj);
      }

特例：当用 equals() 方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
    原因：在这些类中重写了Object类的equals()方法 。
    当自定义使用 equals()时，可以重写 。用于比较两个对象的 “内容 ”是否都相等

	Customer cust1 = new Customer("Tom",21);
	Customer cust2 = new Customer("Tom",21);
    System.out.println(cust1.equals(cust2));//false
	System.out.println(str1.equals(str2));//true
		
	Date date1 = new Date(32432525324L);
	Date date2 = new Date(32432525324L);
	System.out.println(date1.equals(date2));//true

重写equals()方法的原则

 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。

	例：比较两个对象的实体内容(即：name和age)是否相同
	1.手动实现equals()的重写
	@Override
	public boolean equals(Object obj) {
//		System.out.println("Customer equals()....");
		if (this == obj) {
            return true;
        }
		
		if(obj instanceof Customer){
			Customer cust = (Customer)obj; //强转是为了能调用customer的特有方法和属性
			比较两个对象的每个属性是否都相同
			if(this.age == cust.age && this.name.equals(cust.name)){
				return true;
			}else{
				return false;
			}
			
			//或
			return this.age == cust.age && this.name.equals(cust.name);
		}else{
			return false;	
		}		
	}


    自动生成的equals() 
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Customer other = (Customer) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

对称性：如果 x.equals(y)返回是 “ true” ， 那么 y.equals(x) 也应该返回是 “true ”。
自反性：x.equals(x)必须返回是 “true”。
传递性：如果 x.equals(y)返回是“true ”，而且 y.equals(z)返回是 “true”， 那么 z.equals(x)也应该返回是 “true”。
一致性：如果 x.equals(y)返回是 “true ”，只要 x和y内容一直不变，不管你重复 x.equals(y)，返回都是 “true”。
任何情况下，x.equals(null)，永远返回是 “false”；x.equals(和x不同类型的对象 )永远返回是 “false”。

面试题： == 和equals 的区别

1==既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址。 
2equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==; 我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之形成了equals是比较值的错误观点。
3具体要看自定义类里有没有重写Object的equals方法来判断
4通常情况下，重写 equals方法，会比较类中的相应属性是否都相等。

练习：

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

package com.atguigu.exercise;

public class Order {
	int oederId;
	String orderName;
	public int getOederId() {
		return oederId;
	}
	public void setOederId(int oederId) {
		this.oederId = oederId;
	}
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}
	public Order(int oederId, String orderName) {
		super();
		this.oederId = oederId;
		this.orderName = orderName;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if(obj instanceof Order) {
			Order ord = (Order) obj;
			return ord.getOederId()==this.getOederId() && ord.getOrderName().equals(this.getOrderName());
		}
		return false;
	}
}

class OrderTest{
	public static void main(String[] args) {
		Order a = new Order(23, "yuyu");
		Order b = new Order(23,"yuu");
		System.out.println(a.equals(b));
	}
}

toString () 方法
toString () 方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址 。
当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

Customer cust1 = new Customer("Tom",21);
System.out.println(cust1.toString());//com.atguigu.java1.Customer@15db9742-->Customer[name = Tom,age = 21]
System.out.println(cust1);//com.atguigu.java1.Customer@15db9742-->Customer[name = Tom,age = 21]

Object类中toString()的定义：

  public String toString() {
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
 } 

可以根据需要在用户自定义类型中重写toString() 方法
如String类重写了 toString() 方法 ，返回字符串的值 。

像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息。

String str = new String("MM");
System.out.println(str);//MM
		
Date date = new Date(4534534534543L);
System.out.println(date.toString());//Mon Sep 11 08:55:34 GMT+08:00 2113

基本类型数据转换为String类型时,调用了对应包装类的toString 方法
int a= 10 ;System.out .println(“a=”+a);

自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

@Override
	public String toString() {
		return "Customer [name=" + name + ", age=" + age + "]";
}

补充知识：单元测试方法的使用

 Java中的单元测试选用的API是JUnit
 步骤：
1.选中当前工程 - 右键选择：build path - add libraries - JUnit 4 - 下一步
2.创建Java类，进行单元测试。 此时的Java类要求：① 此类是public的  ②此类提供公共的无参的构造器
3.此类中声明单元测试方法。此时的单元测试方法：方法的权限是public,没有返回值，没有形参 
4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test

也可以在测试方法前直接写@Test,点击Add JUnit4 library to the build.path

说明：
 1.如果执行结果没有任何异常：绿条
 2.如果执行结果出现异常：红条

public class JUnitTest {
	
	int num = 10;
	
	@Test
	public void testEquals(){
		String s1 = "MM";
		String s2 = "MM";
		System.out.println(s1.equals(s2));
		//ClassCastException的异常
//		Object obj = new String("GG");
//		Date date = (Date)obj;
		
		System.out.println(num);
		show();
	}
	
	public void show(){
		num = 20;
		System.out.println("show()....");
	}
	
	@Test
	public void testToString(){
		String s2 = "MM";
		System.out.println(s2.toString());
	}
}

包装类的使用

此部分内容建议会用一种方法即可

java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征

基本数据类型----包装类：调用包装类的构造器 

//基本数据类型 --->包装类：调用包装类的构造器
	@Test
	public void test1(){
		
		int num1 = 10;
		System.out.println(num1.toString());//此时基本类型没有此方法
		Integer in1 = new Integer(num1);
		System.out.println(in1.toString());
		
		Integer in2 = new Integer("123");
		System.out.println(in2.toString());//123
		
		//报异常
//		Integer in3 = new Integer("123abc");
//		System.out.println(in3.toString());
		
		Float f1 = new Float(12.3f);
		Float f2 = new Float("12.3");
		System.out.println(f1);
		System.out.println(f2);
		
		Boolean b1 = new Boolean(true);
		Boolean b2 = new Boolean("TrUe");//此处可以忽略大小写
		System.out.println(b2);
		Boolean b3 = new Boolean("true123");
		System.out.println(b3);/执行结果为false
		
		
		Order order = new Order();
		System.out.println(order.isMale);//默认值false
		System.out.println(order.isFemale);//null
	}

包装类----基本数据类型:调用包装类Xxx的xxxValue() 

//包装类--->基本数据类型:调用包装类Xxx的xxxValue()
	@Test
	public void test2(){
		Integer in1 = new Integer(12);
		
		int i1 = in1.intValue();
		System.out.println(i1 + 1);//13
			
		Float f1 = new Float(12.3);
		float f2 = f1.floatValue();
		System.out.println(f2 + 1);
	}

JDK 5.0 新特性：自动装箱与自动拆箱 

JDK 5.0 新特性：自动装箱 与自动拆箱
	@Test
	public void test3(){
//		int num1 = 10;

//		//基本数据类型-->包装类的对象
//		method(num1);
		
		//自动装箱：基本数据类型 --->包装类
		int num2 = 10;
		Integer in1 = num2;//自动装箱
		
		boolean b1 = true;
		Boolean b2 = b1;//自动装箱
		
		//自动拆箱：包装类--->基本数据类型
		System.out.println(in1.toString());
		
		int num3 = in1;//自动拆箱
		
	}

public void method(Object obj){
		System.out.println(obj);
	}

基本数据类型、包装类----String类型：调用String重载的valueOf(Xxx xxx) 

//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
	@Test
	public void test4(){		
		int num1 = 10;
		//方式1：连接运算
		String str1 = num1 + "";
		//方式2：调用String的valueOf(Xxx xxx)
		float f1 = 12.3f;
		String str2 = String.valueOf(f1);//"12.3"
		
		Double d1 = new Double(12.4);
		String str3 = String.valueOf(d1);
		System.out.println(str2);
		System.out.println(str3);//"12.4"
		
	}

String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s) 

//String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
	@Test
	public void test5(){
		String str1 = "123";
		//错误的情况：
//		int num1 = (int)str1;
//		Integer in1 = (Integer)str1;
		//可能会报NumberFormatException
		int num2 = Integer.parseInt(str1);
		System.out.println(num2 + 1);
		
		String str2 = "true1";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}

 总结：记住基本数据类型和包装类有自动装箱，拆箱的方法（搞定两个的转换），String类的valueOf的方法，包装类的parseXxx(String)的静态方法。

习题：

如下两个题目输出结果相同吗？各是什么：

o1 //1.0 三元运算符要求类型统一  多态，自动调用了包装类重写的tostrng方法

o2 //1

//false new了不同的对象

//true  底层代码integer内部定义了integercache结构，intercache中定义了integer[],保存了范围是-128-127的整数。如果我们使用自动装箱的方式给Integer赋值的范围在-128-127，可以直接使用数组中的元素，不用再去new.提高装箱效率。

//false 

package com.atguigu.exercise;

import java.util.Scanner;
import java.util.Vector;

public class VectorTest {
	public static void main(String[] args) {
		//实例化scanner，用于从键盘获取学生成绩
		Scanner scan = new Scanner(System.in);
		//创建vector对象
		Vector v = new Vector();
		//通过for(;;)或while(true)方式给vector中添加数组
		double maxScore = 0;
		while(true) {
			System.out.println("请输入成绩：");	
			double score = scan.nextDouble();
			if (score < 0)
				break;
			if (score > 100) {
				System.out.println("输入的数据非法，重新输入");
				continue;
			}
			//jdk5.0之前
			//Double inScore = new Double(score);
			//v.addElement(inScore);
			//jdk5.0之后 自动装箱
			v.add(score);
			if(maxScore < score) {
				maxScore = score;
			}
			
		}
		
		char level;
		for (int i = 0;i<v.size();i++) {
			Object obj = v.elementAt(i);
			//jdk5.0之前，拆箱
//			Double inScore = (Double)obj;
//			double score = inScore.doubleValue();
			//jdk5.0之后
			double score = (double)obj;
			if (maxScore-score<=10) {
				level = 'A';
			}else if(maxScore-score<=20) {
				level = 'B';
			}else if(maxScore-score<=30) {
				level = 'C';
			}else {
				level = 'D';
			}
			System.out.println("Student"+i+"score is"+score+",level is"+level);
		}	
	}	
}

---

本章结束语

至此，本章节内容结束。回顾本章，主要介绍了面向对象的继承性和多态性。结合示例代码多思考多体会，相信会用很多的收获。