9.面向对象（多态性）

1.多态性的使用

1）理解多态性： 可以理解为一个事物的多种形态。
2）何为多态性：

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）。

3）多态的使用： 虚拟方法调用。

有了对象的多态以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。

4）多态性的使用前体： ①类的继承 ②方法的重写
5）对象的多态性： 只适用于方法，不适用于属性。
6）示例：

public class Person {
	String name;
	int age;
	int id = 1;

	public void eat() {
		System.out.println("吃饭");
	}
	
	public void walk(){
		System.out.println("走路");
	}
}

public class Man extends Person{
	boolean smoking;
	int id = 2;

	public void eat() {
		System.out.println("吃可可果");
	}
	public void walk() {
		System.out.println("起飞");
	}
}

public class Woman extends Person{
	boolean beauty;
	
	public void eat() {
		System.out.println("吃落落梅");
	}
	
	public void walk() {
		System.out.println("游泳");
	}
}

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Man();
		p1.eat(); //吃可可果
		System.out.println(p1.id); //1

		Person p2 = new Woman();
		p2.walk(); //游泳
	}
}

2.虚拟方法调用

1）正常的方法调用：

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

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

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

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

3.向下转型的使用

1）代码示例：

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

public class Man extends Person{
	boolean smoking;
	
	public void eat() {
		System.out.println("吃可可果");
	}
	public void walk() {
		System.out.println("起飞");
	}
	public void earnMoney() {
		System.out.println("挣钱");
	}
}

public class Woman extends Person{
	boolean beauty;
	
	public void eat() {
		System.out.println("吃落落梅");
	}
	
	public void walk() {
		System.out.println("游泳");
	}
	public void cook() {
		System.out.println("做饭");
	}
}

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Man();
		p1.eat();
//		p1.earnMoney(); 无法调用子类中特有的方法
		//如何调用子类特有的属性和方法:使用强制类型转换符（向下转型）
		Man m1 = (Man)p1; 
		m1.earnMoney();
		
	    //使用强转时出现的异常ClassCastException
//		Woman w1 = (Woman)p1;
//		w1.cook();
		
		/*instanceof关键字的使用
		 * a instanceof A:判断对象a是否是对象A的实例。如果是，返回true，如果不是，返回false。
		 * 
		 * 为了避免使用强转时出现的异常ClassCastException，在进行向下转型之前，使用
		 * instanceof进行判断，一旦返回true，则进行向下转型，返回false，不能进行向下转型
		 * 
		 * 如果a instanceof A返回true，则a instanceof B也返回true。
		 * 其中，类B是类A的父类
		 */
		
		if(p1 instanceof Man) {
			System.out.println("*****Man*****");
		}
		if(p1 instanceof Person) {
			System.out.println("*****Person*****");
		}
		if(p1 instanceof Woman) {
			System.out.println("*****Woman*****");
		}
	}
}

4.13.继承成员变量和继承方法的区别

1）子类不会覆盖父类中声明的属性。
2）子类重写父类中的方法，则父类中的方法会被覆盖。
3）代码示例：

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

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

public class FiledMethodTest {
	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，子类重写父类中的方法，则父类中的方法会被覆盖
	}
}

5.Object类

1）java.lang.Object类：

①Object类是所有Java类的根父类。
②如果在类的声明中未使用extends关键字指明父类，则默认父类为java.lang.Object类
③Object类中的功能(属性、方法)就具有通用性。
属性：无
方法：equals() / toString() /getClass() / hashCode() / clone() / finalize() / wait() 、 notify() 、 notifyAll()
④Object类只声明了一个空参构造器

2）Object类中的主要结构：

4）代码示例：

import org.junit.Test;

public class Test1 {
	@Test
	//数组也作为Object的子类出现，可以调用Object类中声明的方法
	public void test01() {
		int[] arr = new int[] {1,2,3};
		print(arr); //[I@5906ebcb，地址值
		
		System.out.println(arr.getClass()); //class [I ，为一维整型数组的类
		System.out.println(arr.getClass().getSuperclass()); //class java.lang.Object
		
	}
	
	public void print(Object obj) {
		System.out.println(obj);
	}
}

6.==运算符的回顾

1）==和equals的区别：

2）重写equals()方法的原则：

7.equals()的使用

1）回顾 == 的使用：
①可以使用在基本数据类型变量和引用数据类型变量中。
②如果比较的是基本数据类型：比较两个变量保存的数据是否相等。（不一定数据类型要相同）
如果比较的是引用数据类型：比较两个对象的地址是否相同，即两个引用是否指向同一个对象实体。

2）equals()的使用：
①是一个方法。
②只能适用于引用数据类型。
③Object类中的equals()的定义：

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

说明：Object类中定义的equals()和 == 的作用是相同的：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体

④像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址值是否相同，而是比较两个对象的“实体内容”是否相同。

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

重写的原则：比较两个对象的实体内容（即属性）是否相同

3）代码示例：

public class equalsTest {
	public static void main(String[] args) {
		//基本数据类型
		int i = 10;
		int j = 10;
		double d = 10.0;
		char c = 10;
		System.out.println(i == j);	//true
		System.out.println(i == d);	//true
		System.out.println(i == c);	//true
		
		//引用数据类型
		Customer cust1 = new Customer("Tom",21);
		Customer cust2 = new Customer("Tom",21);
		System.out.println(cust1 == cust2); //false
		System.out.println(cust1.getName() == cust2.getName()); //true
		
		String str1 = new String("ganyu");
		String str2 = new String("ganyu");
		System.out.println(str1 == str2); //false
		
		System.out.println(cust1.equals(cust2)); //false -> true
		System.out.println(str1.equals(str2)); // true
	}
}

import java.util.Objects;

public class Customer {
	private String name;
	private int age;
	
	public Customer() {
		
	}
	
	public Customer(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	//自动生成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;
		return age == other.age && Objects.equals(name, other.name);
	}
	
	//手动实现equals()
//	//重写的原则：比较两个对象的实体内容（即属性）是否相同
//	public boolean equals(Object obj) {
//		if(this == obj) {
//			return true;
//		}
//		if(obj instanceof Customer) {
//			Customer cust = (Customer)obj;
//			return this.age == cust.age && this.name.equals(cust.name);	
//		}
//		return false;
//	}
}

8.toString()的使用

1）Object类中的tostring()的使用：
①当我们输出一个对象的引用时，实际上就是调用当前对象的tostring()。
②Object类中tostring()的定义：

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

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

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

2）代码示例：

public class ToStringTest {
	public static void main(String[] args) {
		Customer cust1 = new Customer("甘雨",21);
		System.out.println(cust1.toString());	//Test1.Customer@379619aa --> Customer[ name = 甘雨,age = 21]
		System.out.println(cust1);	//Test1.Customer@379619aa --> Customer[ name = 甘雨,age = 21]
		
		String str1 = new String("MM");
		System.out.println(str1);  //MM
		
		Date date1 = new Date(123456L);
		System.out.println(date1); //1970-01-01
	}
}

public class Customer {
		private String name;
		private int age;
		
		public Customer() {
			
		}
		
		public Customer(String name,int age) {
			this.name = name;
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public int getAge() {
			return age;
		}

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

9.单元测试方法的使用

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

说明：
①如果执行结果没有任何异常：绿条
②如果执行结果出现异常：红条

7）代码示例：

import org.junit.Test;

public class JUnitTest {
	@Test
	public void test1() {
		String s1 = "MM";
		String s2 = "MM";
		System.out.println(s1.equals(s2));
	}
}