Java的多态

继承紧接下来就是多态，还真没有注意过多态，当初学习的时候肯定是知道了，当然是没有像今天这么认真的对面下。

多态，主要用到的就是抽象类的定义，所构造的抽象类你要想办法用在你的功能中，最终所设计出来的结果就是要是程序维护性高，拓展性强。

work_1是求长方形和圆的面积，定义一个图形抽象类获取面积方法和周长方法。明白要求之后当然首先是分析，然后设计出UML类图。

父类是一个抽象类，告诉我们有几个功能，而子类自行实现功能，最后也有一个计算类来完成功能的表示。这是我的看法。

这样子的方便之处在于，图形一直变，但总需要的功能是不会变的。多态就是实现在这块了。

然后就是以下的几个类和测试用例

package Java的多态;
/*此例是分别求图形的周长和面积
 *所以有抽象类的定义
 *抽象方法定义求面积和周长*/
public abstract class work_1_Shape {
		
	public abstract double getArea();			//抽象定义求面积
	
	public abstract double getPerimeter();		//抽象定义周长
	
}

抽象类定义时加上了abstract。

package Java的多态;
/*子类圆在这里定义
 * 圆有的特点是半径和PI
 * 然后在这里具体实现周长和面积的方法*/
public class work_1_Cirlce extends work_1_Shape{
	private double r;
	private final static double PI=3.14;
	
	public work_1_Cirlce(double r){
		this.r=r;
	}
	
	//这里具体实现
	public double getArea() {
		return r*r*PI;
	}

	public double getPerimeter() {
		return r*2*PI;
	}
	
	
	
}

依然还是会用到继承

package Java的多态;
/*
 * 然后是长方形子类
 * 此具有的特点就是长和宽*/
public class work_1_Rectangle extends work_1_Shape{
		private double l;
		private double w;
		
		public work_1_Rectangle(double l,double w){
			this.l=l;
			this.w=w;
		}

		public double getArea() {
			return l*w;
		}

		public double getPerimeter() {
			return (l+w)*2;
		}
		
		
}

package Java的多态;
/*多了一个图形面积和周长计算器
 * 没太搞明白啊
 * 貌似好像是具有输出功能
 * 但是这样超级规范的意思吗*/
public class work_1_ShapeCaculate {
		//说是可以计算任何shape子类的面积
		public void calArea(work_1_Shape shape) {
			System.out.println(shape.getArea());
		}
		//同理这个
		public void getPerimeter(work_1_Shape shape) {
			System.out.println(shape.getPerimeter());
		}
}

这个就是一个类，但里面用到了抽象类和抽象方法，大大简化了每个子类自己看到结果，孩子们都使用这个就好了，大致就是这个意思。

package Java的多态;
/*实例测试类*/
public class work_1_test {

	public static void main(String[] args) {
			work_1_ShapeCaculate make=new work_1_ShapeCaculate();
			//用了两种创建实例
			work_1_Shape rectangle=new work_1_Rectangle(3, 4);
			work_1_Cirlce circle=new work_1_Cirlce(3);
			
			System.out.println("长方形的面积：");
			make.calArea(rectangle);
			System.out.println("长方形的周长：");
			make.getPerimeter(rectangle);
			
			System.out.println("圆的面积：");
			make.calArea(circle);
			System.out.println("圆的周长：");
			make.getPerimeter(rectangle);
	}

}

最后就是实例测试，make这个功能很方便，对任何实例都可以用到。

然后work_2是一个模拟饲养员喂养小动物程序，这个还是先展示运行实例吧

————————————————

吃饭时间到了
Dog喜欢吃Bone
饲养员纯纯拿着10克Bone喂养Dog
吃饭时间到了
Cat喜欢吃Fish
饲养员纯纯拿着40克Fish喂养Cat
Dog算术表演
Cat玩冒险表演

————————————————
这个题其实是昨天继承那里的，但是今天多态这里又让改，结果还真明白了改是正确的决定，不愧是书本。

这里设计的类就比较多了

动物类，食物类，饲养员类。

啊哈有点尴尬虚线那里没有搞好-，-

虽然这个类比较多，但是都比较简单

package Java的继承;

public class work_3_Bone extends work_3_Food{
		public work_3_Bone(int w){
			super(w);
		}
		
		public String toString() {
			return "Bone";
		}
}

package Java的继承;

public class work_3_Food {
		private int weight;
		
		public work_3_Food(int w){
			this.weight=w;
		}
		
		public int getWeigth() {
			return weight;
		}
}
package Java的继承;

public class wrok_3_Fish extends work_3_Food{
		public wrok_3_Fish(int w){
			super(w);
		}
		
		public String toString() {
			return "Fish";
		}
}

package Java的继承;
/*动物的总类
 * 是个动物就要吃饭*/
public class work_3_Animal {
		public void eat(work_3_Food food) {
			System.out.println("吃饭时间到了");
			System.out.println(this+"喜欢吃"+food);
		}
}

package Java的继承;

public class work_3_Cat extends work_3_Animal{
	
		public String toString() {
			return "Cat";
		}
		
		public void artCat() {
			System.out.println(this+"玩冒险表演");
		}
}

package Java的继承;

public class work_3_Dog extends work_3_Animal{
		public String toString() {
			return "Dog";
		}
		
		public void artDog() {
			System.out.println(this+"算术表演");
		}
}

package Java的继承;

public class work_3_Feeder{
		private String name;
		public work_3_Feeder(String n){
			this.name=n;
		}
		
		public void feed(work_3_Animal animal,work_3_Food food) {
			animal.eat(food);
			System.out.println("饲养员"+name+"拿着"+food.getWeigth()+"克"+food+"喂养"+animal);
		}
//		//有两个相同名的构造函数，参数不同
//		public void feed(work_3_Dog dog,work_3_Bone bone) {
//			dog.eat(bone);
//			System.out.println("饲养员"+name+"拿着"+bone.getWeigth()+"克"+bone+"喂养"+dog);
//		}
		public void perform(work_3_Animal ani) {
			if (ani instanceof work_3_Dog)
				((work_3_Dog)ani).artDog();
			if (ani instanceof work_3_Cat){
				work_3_Cat cat=(work_3_Cat)ani;
				cat.artCat();
			}
		}
}

看这上面的注释掉的，这就是昨天继承那里，我当时还在想，哇哦定义相同的函数名是可以的啊，当时居然没有想想这样不是很麻烦了

今天在多态这里恍然大悟啊

还有就上每那个Instanceof运算符啊，就是说前者是不是后者的一个实例，是的话返回true。

package Java的继承;

public class work_3_test {

	public static void main(String[] args) {
			work_3_Feeder name=new work_3_Feeder("纯纯");
			work_3_Dog dog=new work_3_Dog();
			work_3_Bone bone=new  work_3_Bone(10);
			name.feed(dog, bone);
			
			name.feed(new work_3_Cat(), new wrok_3_Fish(40));
			
			name.perform(dog);
			name.perform(new work_3_Cat());
	}

}

最后是测试实例，用了两种定义方法，很不错。

这里用多态思想之后，一下子拓展了好多，可以很随意的喂动物了，新手可以随意喂动物了哈哈。