【JavaSE】【面向对象09】面向对象三大特征---多态

java中
（1）方法的多态

重载：在一个类中一个方法功能的多种表现形态
重写：父子类对于同一个方法表现出不同的形式

（2）对象的多态

若编译时类型和运行时类型不一致，就出现多态（Polymorphism）

Java程序的编译运行分为两种状态：在多态的情况下

• 编译时，“看左边”，看的是父类的引用（父类中不具备子类特有的方法）
• 运行时，“看右边”，看的是子类的对象（实际运行的是子类重写父类的方法）
  注意：这里说的是一个对象实际运行的方法，而属性是没有多态的(JVM动态链接)

引用数据类型之间的转换：前提都先有继承

• 向上转型upcasting：子类转父类 系统自动完成
  注意：一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法
• 向下转型downcasting：父类转子类 需要使用强制类型转换符()
  注意：前提父类原先指向的就是本身对象才能向下转型成功，如果父类原先指向的是其他类型（父类的，兄弟类的）的对象，那么就会发生java.lang.ClassCastException类型转换异常

public static void main(String[] args) {
		//基本数据类型
		int i = 12;
		long myLong = i;//自动类型转化，存储范围小的自动转为大的
		int n = (int)myLong;//强制类型转换，存储范围大的强制转为小的，损失精度
		
		//多态引用
		Human m = new Man();//向上转型
		Human w = new Woman();//向上转型
		
		Man man = new Man();//本态引用
		Human h1 = man;//多态引用，向上转型
		Man m1 = (Man)h1;//向下转型
		
		//Man m2 = (Man)w;//从概念上来说,w是Human类型，强制转为Man类型，存在风险。w本身指向的是Woman，如果强制转为Man就会出现异常java.lang.ClassCastException: 
	
		Human h3 = new Human();
	//	Man m3 = (Man)h3;//java.lang.ClassCastException: 
	}

• 引用类型对象能用的运算符：

=：赋值   引用变量 = 对象;
==和!=：比较两个对象的地址    
+：必须与String拼接
其他的运算符都不能直接用于对象

• 唯一一个只用于引用类型的运算符：instanceof

 x instanceof A：检验x是否为类A的对象，返回值为boolean型。
 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
 如果x属于类A的子类B，x instanceof  A值也为true。

多态的前提：（1）要有继承或实现关系（2）要有方法的重写
成员方法：
编译时：要查看引用变量所属的类中是否有所调用的方法。
运行时：调用实际对象所属的类中的重写方法。

注意：
成员变量：不具备多态性，只看引用变量所属的类。
静态方法：不能被重写，也没有多态性

public class TestPolymorphism3 {
	public static void main(String[] args) {
		Animal a = new Cat();//多态引用
		System.out.println(a.leg);//父类的
		Cat c = (Cat)a;
		System.out.println(c.leg);//子类的
	}
}
class Animal{
	int leg = 0;
}
class Cat extends Animal{
	int leg = 4;
}

public class TestStatic{
	public static void main(String[] args) {
		Father f = new Son();
		f.test();//父类的方法
	}
}
class Father{
	public static void test(){
		System.out.println("父类的方法");
	}
}
class Son extends Father{
	public static void test(){
		System.out.println("子类的方法");
	}
}

1、多态数组
多态数组：元素的类型是父类的类型，存储的是父类或子类的对象
2、多态参数
多态参数：形参类型是父类的类型，实参是父类或子类的对象
3、多态属性+多态参数

案例1：

public class Scala04_DataType3 {

    public static void main(String[] args) {
        A a = new B();
        test(a);
    }

    public static void test(A a){
        System.out.println("aaa");
    }

    public static void test(B b){
        System.out.println("bbb");
    }
}


class A{

}
class B extends A{}

方法重载看两个，参数类型和参数个数；这里类型是a，所以打印aaa

案例2：基本数据类型自动向上转型

public class Scala04_DataType4 {

    public static void main(String[] args) {
        byte b = 10;
        test(b);  //bbbb  注掉后 ssss

    }

//     public static void test(byte b){
//        System.out.println("bbb");
//    }

    public static void test(short s){
        System.out.println("sss");
    }

    public static void test(char c){
        System.out.println("ccc");
    }

    public static void test(int i){
        System.out.println("iiii");
    }
}

案例3

public class Scala07_Test_java {

    public static void main(String[] args) {
            BBB  bbb = new BBB();
            bbb.test(); //李四， 张三
    }
}
class AAA{
    public String name = "张三";
}
class BBB extends AAA{
    public String name = "李四";
    public void test(){
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

对象之间最弱的一种关联方式，是临时性的关联。
代码中一般指由局部变量、函数参数、返回值建立的对于其他对象的调用关系。

class A{
	public B method(C c,D d){
		E e = new E();
		...
		B b = new B();
		...
		return b;
	}
}

这个代码结构中，表示A类依赖了B,C,D,E类

对象之间一种引用关系，这种关系通常使用类的属性表达

class Employee{
	private int eid;//员工编号
	private String name;//员工姓名
	private Computer coumputer;//员工所使用的电脑
	//....
}
class Computer{
	
}

has a关系有三种语义：
关联关系 ：普通引用关系，双方互相独立个体；
关联关系所涉及的两个对象是处在同一个层次上的。比如人和自行车就是一种关联关系，而不是聚合关系，因为人不是由自行车组成的。

聚合关系： 如汽车类与引挚类、轮胎类之间的关系就是整体与个体的关系。
组合关系：对象A包含对象B，对象B离开对象A没有实际意义。是一种更强的关联关系。人包含手，手离开人的躯体就失去了它应有的作用。

类与类的继承关系，类与接口的实现关系。
场景：父与子、动物与人、植物与树