Java（转型-多态-契约）

类转型

#变量支持互相转化,如：
基本类型转换里面有两个int，（int）3.5是将double类型转换为int类型，然后将值赋给a变量；int a是定义一个int变量a。

public class extents_class {
	public static void main(String[] args) {
		int a= (int) 3.5;
		System.out.println("输出的double类型转换整型"+a);
	}
}
结果输出：输出的double类型转换整型3

#类型也可以相互转型，但是只限制与有继承关系的类。
因为转型肯定是有相同的部分，两个不一样的类之间定义的内容没有关系，肯定不能相互转化。

• 子类可以转换为父类，子类也自然继承了父类的东西，而且还增加子类自己的东西。而父类不可以转换为子类，子类的内容多，而父类没有，自然不能去继承。

• 子类继承父类所有的财产，子类可以变成父类（从大变小，即向上转型）；但是不能从父类变成子类。

• 当然任何事情不是绝对的，父类转化为子类有一种例外：父类本身就是从子类转化过来的。
  ## 多态：

• 类型转化带来的结果就是多态

• 子类继承父类的所有方法，但是子类可以重新定义一个名字，参数和父类一样的方法，这种行为就是重写（覆写、覆盖、不是重载（函数名一样，形参不一样））；重写是子类的方法替换掉父类的方法，子类的方法优先级高于父类优先级。

• 子类的方法的优先级高于父类

public class Man extends Human {
	public void eat() {
		System.out.println("I can eat more");
	}
	public void plough() {}
	
	public static void main(String[] args) {
		Man obj1=new Man();
		obj1.eat();//Man.eat
//		类转型，尽管转型了；但是函数看转型之前的类型是什么
//		因为obj2转型之前是obj1，而obj1的Man类型，所以obj1本质上函数Man类型
		Human obj2=(Human) obj1;
		obj2.eat();//Man.eat()
//		父类转换为子类，obj2本身来自obj1。即父类本省是有子类转换而来，现在有转换为子类当然是可以的
		Man obj3=(Man)obj2;
		obj3.eat();//Man.eat()
	}
}

从内存方面解释
首先创建一个子类对象，然后将子类对象转化为父类对象（父类对象比子类对象的方法要少）；此时父类与子类都指向同一段内存空间（父类调用的方法就是调用子类的方法，自己的方法被屏蔽掉。父类不能调用自身没有的方法。）
多态的作用：

• 以统一的接口来操纵某一类中不同的对象的多态行为，每一个对象的不同行为都是由自己所决定
• 对象之间的解耦

1:
package extend_duotai;

public interface Animal {
	public void eat();
	public void move() ;
}
2:


package extend_duotai;

import org.omg.CORBA.PUBLIC_MEMBER;

public class AnimalTest {
	public static void main(String[] args) {
		Animal[] as = new Animal[4];
		as[0] = new Cat();
		as[1] = new Dog();
		as[2] = new Cat();
		as[3] = new Dog();
		
		for (int i = 0; i < as.length; i++) {
//			调用每个元素的自身的move方法
//			以统一的接口来操作某一类中不同的对象的动态行为。
			as[i].move();
		}
		for (int i = 0; i < as.length; i++) {
			havelunch(as[i]);
		}
		havelunch(new Cat()); //Animal a=new Cat(); ==  haveLunch(a)
		havelunch(new Dog());
//		解耦
		havelunch(
				new Animal() {
//					Animal本身就是一个接口，不能被对象实例化；这里对象化的条件是将方法都实现，实现着接口；
					@Override
					public void move() {
						// TODO Auto-generated method stub
						System.out.println("I can eat from an anonymous class");
					}
					
					@Override
					public void eat() {
						// TODO Auto-generated method stub
						System.out.println("I can eat from an anonymous class");
					}
				});
		
		
		
	}
	public static void havelunch(Animal a)
	{
		a.eat();
	}
}



Cat:i can move
Dog :i can move
Cat:i can move
Dog :i can move
Cat:I can eat
Dog :I can eat
Cat:I can eat
Dog :I can eat
Cat:I can eat
Dog :I can eat
I can eat from an anonymous class

契约设计

1. 契约：规定规范了对象应该包含的行为方法
2. 前面提到的Animal类就规定含有move与eat行为方法，这就是一个规定。要想对象化，new出来这个类，我们必须将接口里面的类实现。
3. 接口定义了方法的名称、参数和返回值，规范了派生类的行为
4. 基于接口，利用转型和多态，不影响真正方法的调用，成功地将调用类和被调用类解耦
5. 基于第4点的解释：上述代码调用havalanch方法，需要向该方法传递一个Animal的一个参数；但是实际上传递的并不是Animal对象，而是一个实例化后的对象例如cat、dog、实例化的Animal对象。总结下来就是方法的参数就是一个规范，必须含有eat和move两个方法（规范）.