57_Java_面向对象3_多态

对象的多态性(编译，看左边；运行，看右边)：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
多态的使用：我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
   
details
1 多态性的使用前提：1 类的继承关系  2 方法的重写
2 对象的多态性，只适用于方法，不适用于属性（属性 编译和运行都看左边）

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，
但变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法,子类特有的属性和方法不能调用
Person p2 = new Man();
如何才能调用子类特有的属性和方法  --> 向下转型：使用强制类型转换符
Man m1 = (Man)p2;   # 可能出现  ClassCastException的异常 引出了 instanceof
m1.earnMoney();     # 只能调用 person里定义的方法

instanceof关键字的使用 
a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false
我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

如果 a instanceof A返回true,则 a instanceof B也返回true. 其中，类B是类A的父类。

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

public class DTtesx {
    public static void main(String[] args) {
        Person1 p1 = new Man();
        System.out.println(p1.id);  //属性 编译和运行都看左边

        // 体现多态
        DTtesx dTtesx = new DTtesx();
        dTtesx.test1(new Woman());  //多态

        //向下转型：使用强制类型转换符
        //进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型
        if(p1 instanceof Person1){
        Man m1 = (Man) p1;
        m1.earnMoney();  // 调用子类方法，
        }
    }

    public void test1(Person1 p ){
        p.eat();
    }}

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

class  Man extends  Person1{
    boolean isSmoking;
    int id = 1002;
    public void earnMoney(){
        System.out.println("男人负责挣钱养家");
    }

    public void eat(){
        System.out.println("男：吃饭");
    }
}

class Woman extends Person1{
    boolean isBeauty;
    public void goShopping(){
        System.out.println("女人喜欢购物");
    }

    public void eat(){
        System.out.println("女人少吃，为了减肥");
    }}

== 和 equals()

一 == ：运算符
1. 使用在基本数据类型变量 和 引用数据类型变量
2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
   如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
补充： == 符号使用时，必须保证符号左右两边的变量类型一致

二、equals()方法的使用 仅适用于引用数据类型：

1. 是一个方法，而非运算符
2. 只能适用于引用数据类型
3. Object类中equals()的定义：
  public boolean equals(Object obj) {
            return (this == obj);
      }
   说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后,比较的不是 两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。 
5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
   就需要对Object类中的equals()进行重写. 重写的原则：比较两个对象的实体内容是否相同.
   
Object类中toString()的使用：

 1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
 2. Object类中toString()的定义：
   public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
     }
 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。 使得在调用对象的toString()时，返回"实体内容"信息
 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

//自动生成的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;
	}
	

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

包装类的使用:
 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
 2.基本数据类型、包装类、String三者之间的相互转换

String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
        String str2 = "true1";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

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

        //方式1：连接运算
        String str1 = num1 + "";
        //方式2：调用String的valueOf(Xxx xxx)
        float f1 = 12.3f;
        String str2 = String.valueOf(f1);//"12.3"
        

public class WrapperTest {
	
	//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类型：调用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"
		
	}
	
	/*
	 * 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);
	}
	
	//包装类--->基本数据类型:调用包装类Xxx的xxxValue()
	@Test
	public void test2(){
		Integer in1 = new Integer(12);
		
		int i1 = in1.intValue();
		System.out.println(i1 + 1);
		
		
		Float f1 = new Float(12.3);
		float f2 = f1.floatValue();
		System.out.println(f2 + 1);
	}
	
	//基本数据类型 --->包装类：调用包装类的构造器
	@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());
		
		//报异常
//		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
	}
}