10.Java-面向对象-多态-object类

Java-面向对象-多态-object类


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

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

10.Java-面向对象-多态-object类_第1张图片

10.Java-面向对象-多态-object类_第2张图片

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

1. 多态性的理解

1. 多态性,理解为一个事物的多种形态。
 * 
 * 2. 此时的java中的多态性,可以理解为子类对象的多态性。
 *    
 * 		子类对象的多态性:父类的引用指向子类的对象
//子类对象的多态性:父类的引用指向子类的对象
Person p2 = new Man();

2. 多态性的应用

3. 多态性的应用:虚方法(virtual method)调用
	 编译时,引用变量只能调用声明的类型中的结构,在真正调用时,实际执行的是子类重写父类的方法
 *   总结为:编译看左边,运行看右边。
 *  
4. 多态性使用的前提:① 类的继承关系  ② 方法的重写
 *  
 * 注意:多态性,只适用于方法,不适用于属性!
		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("猫抓耗子");
	}
}


举例二:

//应用场景二:
class Order{
	
	public boolean equals(Object obj){
		
		return false;
	}
	
	
}

举例三:


//应用场景三:
class DataBaseTest{ // oracle\mysql\sqlserver\
	
	public void insertData(Connection conn){//conn = new MysqlConnection()
		
		//通用操作1
		
		//通用操作2
		
		//通用操作3
		
	}

}

举例四:

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. 向下转型

10.Java-面向对象-多态-object类_第3张图片

代码体现:

//向下转型:将父类的引用转换为子类的引用类型。使用强转符:()
		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.练习

练习1:

class Person {
	protected String name="person";
	protected int age=50;
	public String getInfo() {
	          return "Name: "+ name + "\n" +"age: "+ age;
	}
}
class Student extends Person {
	protected String school="pku";
	public String getInfo() {
  	          return  "Name: "+ name + "\nage: "+ age 
	          + "\nschool: "+ school;
	}	
}
class Graduate extends Student{
	public String major="IT";
	public String getInfo()
	{
		return  "Name: "+ name + "\nage: "+ age 
	          + "\nschool: "+ school+"\nmajor:"+major;
	}
}

建立InstanceTest 类,在类中定义方法method(Person e);
在method中:
(1)根据e的类型调用相应类的getInfo()方法。
(2)根据e的类型执行:
如果e为Person类的对象,输出:
“a person”;
如果e为Student类的对象,输出:
“a student”
“a person ” 
如果e为Graduate类的对象,输出: 
“a graduated student”
“a student”
“a person” 

答案:

public class InstanceTest {
	public static void main(String[] args) {
		InstanceTest test = new InstanceTest();
		Student s = new Student();
		test.method(s);
	}
	
	public void method(Person e){
		System.out.println(e.getInfo());
		
		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");
		}
	}
}

练习2:

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

10.Java-面向对象-多态-object类_第4张图片

答案:

public class GeometricObject {
    protected String color;
    protected double weight;

//    protected GeometricObject(){
//    	
//    }

    protected GeometricObject (String color,double weight){
        this.color = color;
        this.weight = weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public double getWeight() {
        return weight;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public double findArea(){
        return -1.0;
    }
}
public class Circle extends GeometricObject {

    private double radius;

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

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

    public double getRadius() {
        return radius;
    }

    @Override
    public double findArea() {
        return 3.14 * radius * radius;
    }
}
public class MyRectangle extends GeometricObject {
    private double width;
    private double height;

    public MyRectangle(double width, double height, String color, double weight) {
        super(color, weight);
        this.width = width;
        this.height = height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getHeight() {
        return height;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getWidth() {
        return width;
    }

    @Override
    public double findArea() {//返回矩形的面积
        return width * height;
    }
}
public class GeometricTest {
    public static void main(String[] args) {
    	GeometricTest test = new GeometricTest();
    	MyRectangle r1 = new MyRectangle(2.3, 3.4, "white", 1.0);
    	MyRectangle r2 = new MyRectangle(3.4, 2.3, "white", 1.0);
    	
    	test.displayGeometricObject(r1);
    	test.displayGeometricObject(r2);
    	
    	test.equalsArea(r1, r2);
    	
    	
    }
    
    /**
     * 
     * @Description 比较两个几何图形的面积是否相等
     * @author shkstart
     * @date 2020年2月29日下午3:44:43
     * @param g1
     * @param g2
     */
    public void equalsArea(GeometricObject g1,GeometricObject g2){
//        if (g1.findArea() == g2.findArea()){
//            System.out.println("两个几何图形的面积相等");
//        }else {
//            System.out.println("两个几何图形的面积不相等");
//        }
    	
    	String str = (g1.findArea() == g2.findArea())? "两个几何图形的面积相等":"两个几何图形的面积不相等";
    	System.out.println(str);
    }

    /**
     * 
     * @Description 返回几何图形的面积
     * @author shkstart
     * @date 2020年2月29日下午3:45:29
     * @param g
     */
    public void displayGeometricObject(GeometricObject g){
        System.out.println(g.findArea());
    }
}

7. 广义上的多态性

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

三、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;
	}
	
	
	//手动:比较两个User的属性name和age是否都相等
//	public boolean equals(Object obj) {
//		System.out.println("User ... equals()");
//		if(this == obj){
//			return true;
//		}else if(obj instanceof User){
//			User u = (User)obj;
			if(this.age == u.age && this.name.equals(u.name)){
				return true;
			}else{
				return false;
			}
//			//替换为:
//			return this.age == u.age && this.name.equals(u.name);
//		}
//			
//		return false;
//	}
	
	
}
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
	}
}

4. 练习题

练习1:

10.Java-面向对象-多态-object类_第5张图片

10.Java-面向对象-多态-object类_第6张图片

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

练习3:
请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖equals方法,使其判断当两个MyDate类型对象的年月日都相同时,结果为true,否则为false。 public boolean equals(Object o)

public class EqualsTest {
    public static void main(String[] args) {
        MyDate m1 = new MyDate(14, 3, 1976);
        MyDate m2 = new MyDate(14, 3, 1976);
        if (m1 == m2) {
            System.out.println("m1==m2");
        } else {
            System.out.println("m1!=m2"); // m1 != m2
        }

        if (m1.equals(m2)) {
            System.out.println("m1 is equal to m2");// m1 is equal to m2
        } else {
            System.out.println("m1 is not equal to m2");
        }
    }
}

		String str = new String("hello");
		System.out.println(str);//hello
		System.out.println(str.toString());//hello
	}
}

四、小结

  • 子类对象实例化的全过程 —了解
    • 创建子类对象的过程中,虽然加载过父类的构造器,但是自始至终,就只有一个对象,即为new的子类对象
  • 面向对象的特征三:多态性 —重点、难点
    • 子类对象的多态性
    • 多态性的应用:虚方法调用。编译看左边,运行看右边
    • 多态性不适用于属性。编译、运行都看左边
    • 如何实现向下转型:使用强转符
      • 避免在强转时出现ClassCastException,在强转前,使用instanceof进行判断
    • 如果没有多态性,抽象类和接口的定义就没有意义!
  • Object 类
    • 根父类
    • 重点方法:equals() 、 toString()
    • wait()、notify()、notifyAll()、hashCode()、getClass()后面讲
    • 了解:clone()、finalize()

你可能感兴趣的:(Java学习笔记)