Java SE从入门到放弃（十二)

Java SE从入门到放弃（十二)之多态和Object类的使用

一、子类对象实例化的全过程

 * 1. 从结果的角度来看：体现为类的继承性。
 *    在创建了子类对象以后，可以获取直接父类以及所有的间接父类中声明的结构：属性、方法。
 *    在权限允许的情况，可以直接进行调用或修改。
 * 在创建子类对象的过程中，一定会调用父类中的构造器吗？yes!
 * 
 * 2. 从过程的角度来看：
 *  在通过子类的构造器创建对象时，子类的构造器一定会直接或间接调用到直接父类的构造器，直接父类的构造器也一定会直接或间接的调用其父类的构造器（即：子类的间接的父类），。。。,直到调用了java.lang.Object类的构造器为止。也就是说，在创建子类对象的过程中，一定会加载器所有父类的构造器，进而理解为加载了所有父类的结构。
 * 
 * 3. 注意：创建子类的对象，一定注意：内存中自始至终就只有一个对象，那就是变量声明的类型的子类对象。

二、面向对象的特征三：多态性

1. 多态性的理解

 * 1. 多态性，理解为一个事物的多种形态。
 * 
 * 2. 此时的java中的多态性，可以理解为子类对象的多态性。
 *    
 * 3. 子类对象的多态性:父类的引用指向子类的对象

//子类对象的多态性:父类的引用指向子类的对象
Person p2 = new Man();

2. 多态性的应用

 * 4. 多态性的应用：虚方法(virtual method)调用
	 编译时，引用变量只能调用声明的类型中的结构，在真正调用时，实际执行的是子类重写父类的方法
 *   总结为：编译看左边，运行看右边。
 *  
 * 5. 多态性使用的前提：① 类的继承关系 ② 方法的重写
 *  
 * 注意：多态性，只适用于方法，不适用于属性！

		Person p2 = new Man();
		//多态性的应用：虚方法(virtual method)调用
		//编译时，引用变量只能调用声明的类型中的结构，在真正调用时，实际执行的是子类重写父类的方法
		p2.eat();
		p2.walk();
//		p2.earnMoney();
		System.out.println(p2.id);//1001

其中：

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("女人窈窕的走路");
	}
}

3. 多态的应用

举例一：

public class AnimalTest {

	public static void main(String[] args) {
		AnimalTest test = new AnimalTest();
//		test.func(new Animal());
//		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 dog = (Dog)animal;
			dog.protectHome();
		}else if(animal instanceof Cat){
			Cat cat = (Cat)animal;
			cat.catchMouse();
		}
	}
//	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 protectHome(){
		System.out.println("狗开门");
	}
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void shout(){
		System.out.println("喵~喵~喵~");
	}
	public void catchMouse(){
		System.out.println("猫抓耗子");
	}
}

举例二：

public class Account {
	
	private int id;//账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public void withdraw(double amount){
		System.out.println("Account .. withdraw");
		if (balance >= amount) {
			balance -= amount;
		}else{
			System.out.println("余额不足！");
		}
	}
}

public class CheckAccount extends Account{ //信用卡

	private double overdraft;//可透支额度
	
	@Override
	public void withdraw(double amount) {
		System.out.println("CheckAccount .. withdraw");
		if (amount <= getBalance()) {
//			setBalance(getBalance() - amount);
			super.withdraw(amount);
		}else{
			if ((amount - getBalance()) <= overdraft) {
				overdraft -= (amount - getBalance());
				super.withdraw(getBalance());
//				setBalance(0);
			}else{
				System.out.println("超过可透支限额!");
			}
		}
	}
}

public class Customer {
	
	private String firstName;
	private String lastName;
	private Account acct;
	
	public String getFirstName() {
		return firstName;
	}
	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public Account getAcct() {
		return acct;
	}
	
	public void setAcct(Account acct) {//Account acct = new CheckAccount();
		this.acct = acct;
	}
	
	public Customer() {
		super();
	}
	public Customer(String firstName, String lastName) {
		super();
		this.firstName = firstName;
		this.lastName = lastName;
	}
	
	public void info(){
		System.out.println("firstName : " + firstName +", lastName : " + lastName 
				+ ", accout : " + acct);
	}
	
}

测试：

public class CustomerTest {
	public static void main(String[] args) {
		
		
		Customer cust = new Customer("志鹏", "连");		
		CheckAccount acct1 = new CheckAccount(1002, 30000, 0.035, 10000);
		//体现了多态性
		cust.setAcct(acct1);
		
		cust.info();
		//虚拟方法调用
		cust.getAcct().withdraw(3000);
	}
}

4. 向下转型

代码体现：

//向下转型：将父类的引用转换为子类的引用类型。使用强转符：()
		Man m2 = (Man)p2;
		m2.earnMoney();
		//强转时，可能会出现ClassCastException的异常。
//		Woman w1 = (Woman)p2;
//		w1.goShopping();
		
		//避免在向下转型时，出现ClassCastException的异常，所以在强转前，必须要使用instanceof进行判断。
		//a instanceof A:判断对象a是否是类A类型的。
		//如果是，返回true;如果不是，就返回false.
		
		if(p2 instanceof Man){
			Man m3 = (Man)p2;
			m2.earnMoney();
		}
		
		if(p2 instanceof Woman){
			Woman w1 = (Woman)p2;
			w1.goShopping();
		}else{
			System.out.println("我根本不是女人");
		}
		//如果a instanceof A返回是true,则 a instanceof B也一定是true.其中，类B是类A的父类。
		if(p2 instanceof Person){
			System.out.println("Person....");
		}
		
		if(p2 instanceof Object){
			System.out.println("Object....");
		}

5. 多态与向下转型的常见问题

//问题一：编译时通过，运行时不通过
		Person p1 = new Woman();
//		Man man1 = (Man)p1;
		
		Person p2 = new Person();
//		Man man2 = (Man)p2;
		
		//问题二：编译时通过，运行时也通过
		Woman woman1 = (Woman)p1;
		
		Object obj = new Man();
		Man m = (Man)obj;//
		Person p = (Person)obj;
		
		//问题三：编译不通过
//		Man m1 = new Man();
//		Woman w = (Woman)m1;	
		
		
		String str = "hello";
//		Date date = (Date)str;
		
//		Object obj1 = str;
//		Date date1 = (Date)obj1;

6. 广义上的多态性

• 对象的多态性：父类的引用指向子类的对象
• 方法的重写

三、Object类的使用

1. Object类的理解

 * 1. Object类是所有其他类的根父类、根基类
 * 2. 任何一个类（除了Object类）如果没有显式的声明其父类的话，则默认继承于Object类
 * 3. 熟悉Object类中的常用方法
 * 		equals() 和 toString()
 * 		了解：clone() \ finalize()
 * 		wait() \ notify() \ hashCode() \ getClass() 后续讲解 
 * 
 * 4. 笔试题： 区分：finalize \ final \ finally	

2. equals()的使用

1. 回顾  == 的使用
 * 
 *   ① 使用在基本数据类型变量中，比较左右两端的数据值是否相等。
 *   ② 使用在引用数据类型变量中，比较两个引用变量的保存的地址值是否相同的。（或：比较两个引用是否指向同一个对象）
 * 
 * 2. equals()的使用
 * 	 ① 使用范围:只能适用于引用数据类型的变量。
 *   ② Object类中equals()定义如下：
 *       public boolean equals(Object obj) {
	        return (this == obj);
	    }
 *   ③ 像 String\Date\File\包装类重写了Object类中的equals(),用于比较两个对象的实体内容是否相等。
 *   ④ 我们在开发中，需要使用equals()方法时，通常都是需要比较两个对象的实体内容是否相等。则，我们需要重写
 *   Object类中的equals()  
 * 
 * 面试题：区分 == 和 equals()

public class User {
	private String name;
	private int age;
	public User() {
		super();
	}
	public User(String name, int age) {
		super();
		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 boolean equals(Object obj) {
		System.out.println("User ... equals()");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) 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;
	}

public class EqualsTest {
	public static void main(String[] args) {
		
		int i = 10;
		int j = 10;
		System.out.println(i == j);//true
		
		char c = 'A';
		int k = 65;
		System.out.println(c == k);//true
		
		float f = 54.0f;
		int m = 54;
		System.out.println(f == m);//true
		
		//*************************************
		User u1 = new User("Tom",12);
		User u2 = new User("Tom",12);
		System.out.println(u1 == u2);//false

		User u3 = u1;
		System.out.println(u1 == u3);//true
		
		//*************************************
		System.out.println(u1.equals(u2));//false --> true
		
		String str1 = new String("hello");
		String str2 = new String("hello");
		System.out.println(str1.equals(str2));//true	
	}
}

3.toString()的使用

 * 1. Object类中toString()的定义如下：
 * 	public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    2. 当我们打印对象的引用时，默认调动了其toString()
 *  3. String\包装类\File\Date类重写了toString()，用于输出其实体内容的信息
 *  4. 我们也可以考虑在自定义类中重写toString()，用于输出其实体内容的信息

public class User {
	private String name;
	private int age;
	public User() {
		super();
	}
	public User(String name, int age) {
		super();
		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;
	}
	
	//手动编写
//	public String toString() {
//		return "User[name = " + name + ", age = " + age + "]";
//	}
	//自动生成
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
	
}

public class ToStringTest {
	public static void main(String[] args) {
		
		User u1 = new User("Tom",12);
		System.out.println(u1.toString());//com.atguigu.java2.User@15db9742-->User[name = Tom, age = 12]
		System.out.println(u1);//com.atguigu.java2.User@15db9742 -->User[name = Tom, age = 12]
		
		
		String str = new String("hello");
		System.out.println(str);//hello
		System.out.println(str.toString());//hello
	}
}

如果对你有帮助的话，可不可以帮我一键三连呢？