Java——多态与接口

1.设计一个排序类IntSort，该类中包含3个同名的方法sort，分别完成2个整型数、3个整型数以及整型数组（10个数）的排序。编写测试类完成方法的验证。
实验程序：

package Test;

public class IntSort {
	public void sort(int a,int b){
		System.out.println("两个整数排序的结果：");
		if(a>b){
			System.out.println(b+"<"+a);
		}else{
			System.out.println(a+"<"+b);
		}	
	}
	public void sort(int a,int b,int c){
		System.out.println("三个整数排序的结果：");
		if (a>b){
			if(c>a){
				System.out.println(b+"<"+a+"<"+c);
			}else if(c<b){
				System.out.println(c+"<"+b+"<"+a);
			}else{
				System.out.println(b+"<"+c+"<"+a);
			}
		}else {
			if(c<a){
				System.out.println(c+"<"+a+"<"+b);
			}else if(c>b){
				System.out.println(a+"<"+b+"<"+c);
			}else{
				System.out.println(a+"<"+c+"<"+b);
			}
		}
	}
	public void sort(int[] array){
		for(int i=1;i<array.length;i++){
			for(int j=0;j<array.length-i;j++){
				if(array[j]>array[j+1]){
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}
		showArray( array);
	}
	public void showArray(int[] array){
		System.out.println("整形数组排序结果：");
		System.out.println("升序：");
		for(int i=0;i<array.length;i++)
		{
			System.out.println(array[i]+" ");
		}
	}
	public static void main(String args[]){
		IntSort i=new IntSort();
		i.sort(10, 20);
		i.sort(2, 8, 4);
		int[] array={21,36,58,256,12,9};
		i.sort(array);
	}
}

实验结果：

2. 高考入学考试课程为三门，每门满分为100分。在高考招生时，大学录取规则为取最低分数线是180分，而重点大学重写录取规则为录取最低分数线是220分。试利用多态中方法的覆盖实现该功能。测试类和上面的两个类（父类、子类）分开。（类继承）
   实验程序：
   (1) University类

package Test;

public class University {
	void enterRule(double math,double english,double chinese)
	{
       double total=math+english+chinese;
       if(total>=180)
    	   System.out.println(total+"分数达到大学录取分数线");
       else
    	   System.out.println(total+"分数未达到大学录取分数线");
	}
}

(2) ImportantUniversity类

package Test;
public class ImportantUniversity extends University{
	void enterRule(double math,double english,double chinese)
	{
		double total=math+english+chinese;
		if(total>=220)
			System.out.println(total+"分数达到大学录取分数线");
		else
			System.out.println(total+"分数未达到大学录取分数线");
	}
}

(3)测试类

package Test;

public class Test {
	public static void main(String[] args){
		double math=92,english=86,chinese=75;
		ImportantUniversity iun=new ImportantUniversity();
		iun.enterRule(math, english, chinese);
		math=68;
		english=60;
		chinese=76;
		iun.enterRule(math,english,chinese);
	}
}

实验结果：

3. 定义一个接口Shape2D，使用该接口实现二维几何图形类Circle（圆形）和Rectangle（矩形）面积的计算，编写实现接口的类文件以及测试类文件。（接口和两个实现，注意用向上转型）
实验程序：
(1)Shap2D接口

package Test;

interface Shap2D {
	public void draw();
}

(2) Circle类

package Test;

public class Circle {
	float r;
	final double pi=3.1415927;
	public Circle(float r){
		this.r=r;
	}
	public void draw(){
		double s=pi*r*r;
		System.out.println("圆的面积:"+s);
	}
}

(3) Rectangle类

package Test;

public class Rectangle {
	float a,b;
	public Rectangle(float a,float b){
		this.a=a;
		this.b=b;
	}
	public void draw(){
		float s=a*b;
		System.out.println("矩形面积:"+s);
	}
}

(4)测试类

Package Test;

public class Figure {
	public static void main(String[] args){
		Circle c=new Circle(5);
		Rectangle r=new Rectangle(2, 5);
		c.draw();
		r.draw();
	}
}

实验结果：

4.使用多态编程解决如下问题：一个主人养了猫和狗，猫和狗都有自己爱吃的东西，主人在喂它们的时候，如果先判断是猫还是狗，再判断他们分别爱吃什么，就显得很麻烦。如果主人养了很多种动物，这样的重复判断，就会浪费很多时间。有什么办法，能让主人拿到一种食物就知道这是哪种动物的，就好了。（接口，向上转型）
实验程序：
(1)动物类

package Test;

public class Animal {
	int age;
    String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    // 动物类里面有叫和吃两个方法
    public void cry() {
        System.out.println("我不知道叫什么");
    }
    public void eat() {
        System.out.println("我不知道吃什么");
    }
}

(2)狗类

package Test;

class Dog extends Animal {
    // 覆盖（重写）方法
    public void cry() {
        System.out.println("旺旺");
    }
    public void eat() {
        System.out.println("我是狗，我爱吃骨头");
    }
}

(3)猫类

package Test;

class Cat extends Animal {
    // 覆盖（重写）方法
    public void cry() {
        System.out.println("喵喵");
    }
    public void eat() {
        System.out.println("我是猫，我爱吃鱼");
    }
}

(4)食物类

Package Test;

class Food {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    // 食物类里面让它有一个方法
    public void showName() {
    }
}

（5）鱼类

package Test;

class Fish extends Food {
    public void showName() {
        System.out.println("食物：鱼");
    }
}

(6)骨头类

package Test;

class Bone extends Food {
    public void showName() {
        System.out.println("食物：骨头");
    }
}

(7)主人类

Package Test;

class Master {
    // 给动物喂食物，如果没有多态，他要写给猫喂食和给狗喂食两个方法
    // 有了多态，以后即使再来好多动物，用这一个函数就可以了
    public void feed(Animal an, Food f) {
        an.eat();
        f.showName();
    }
}

(8)测试类

package Test;

public class DuoTaiDemo {
    public static void main(String args[]) {
        Master master = new Master();
        master.feed(new Dog(), new Bone());
        // hin方便，可以再试试
        master.feed(new Cat(), new Fish());
    }
}

实验结果：

5.定义一组交通工具类，包括汽车类（AutoMobile）、飞机类（Plane）、船类（Ship），其中汽车类有坦克（Tank）、卡车（Truck）、小汽车（Car），飞机类有客机（AirLiner）、战斗机（FighterPlane），船类有子类游艇（Yacht）、军舰（WarShip），坦克、战斗机和军舰都具有攻击的功能，抽象并定义这些类，通过抽象类和接口以及对应的实现类实现多态和这些类的测试。
实验程序：
（1）火车类

package Test;

public interface Fire {
    void fire();
}

（2）汽车类

package Test;

public abstract class AutoMobile {
      public AutoMobile() {
        System.out.println("AutoMobile无参构造函数已构建");
    }
}

（3）坦克类

package Test;

public class Tank extends AutoMobile{
    public Tank() {
    }
}

（4）卡车类

package Test;
public class Truck extends AutoMobile implements Fire{
    String name=null;
    public Truck(String str) {
        System.out.println("Truck有参构造函数已构建");
        name=str;
    }

    @Override
    public void fire() {
        System.out.println(name+"攻击方式："+"piupiu~~");
    }
}

（5）小汽车类

package Test;

public class Car extends  AutoMobile{
    public Car() {
    }
}

（6）飞机类

package Test;

public abstract class Plane {
    public Plane() {
        System.out.println("Plane无参构造函数已构建");
    }
}

（7）客机类

package Test;

public class AirLine extends Plane {
    public AirLine() {
    }
}

（8）战斗机

package Test;

public class FighterPlane extends Plane implements Fire{
    String name;
    public FighterPlane(String str) {
      System.out.println("FighterPlane有参构造函数已构建");
        name=str;
    }
    @Override
    public void fire() {
        System.out.println(name+"攻击："+"xiuxiu~~");
    }
}

（9）轮船类

package Test;
public class Ship {
    public Ship() {
        System.out.println("Ship无参构造函数已构建");
    }
}

（10）游艇类

package Test;

public class Yacht extends Ship{
    public Yacht() {
    }
}

（11）军舰类

package Test;

public class WarShip extends Ship implements Fire{
    String name=null;
    public WarShip(String str) {
        System.out.println("WarShip有参构造函数已构建");
        name=str;
    }

    @Override
    public void fire() {
        System.out.println(name+"攻击方式："+"嗵嗵~~");
    }
}

（12）测试类

package Test;

public class Test {
    public static void main(String[] args) {
        Fire truck= new Truck("中国99坦克");
        Fire fighterPlane=new FighterPlane("歼-10");
        Fire warship=new WarShip("俄罗斯的“1144”型巡洋舰");
        truck.fire();
        fighterPlane.fire();
        warship.fire();
    }

实验结果：