java-多态数组的多态参数

介绍

代码

employer父类

package hansunping;

public class employer {
	private String name;
	private double salary;

	public employer(String name,double salary) {
		this.name=name;
		this.salary=salary;
		// TODO Auto-generated constructor stub
	}
	public double getsalary() {
		return 12*salary;
		
	}
	public String getname () {
		return name;
		
	}

}

两个子类

worker

package hansunping;

public class woker extends employer{

	public woker(String name, double salary) {
		super(name, salary);
		// TODO Auto-generated constructor stub
	}
	public void work() {
		System.out.println("普通员工"+getname()+"isworking");
				
	}
	@Override
	public double getsalary() {//直接调用父类方法
		return super.getsalary();
	}

}

mannerge

package hansunping;

public class manner extends employer {
	private double bonus;
	public double getBonus() {
		return bonus;
	}
	public void setBonus(double bonus) {
		this.bonus = bonus;
	}
	public manner(String name, double salary,double bonus) {
		super(name, salary);
		this.bonus=bonus;
		// TODO Auto-generated constructor stub
	}
	public void manne() {
		System.out.println("经理"+getname()+"正在工作");
		
	}
	
	@Override
	public double getsalary() {
		return super.getsalary()+bonus;
		
	}
	
	
	
}

运行主类

我们在主类中看到我们创建了woker类的实例。

new woker("tom", 2500);

是类的构造器传入参数的

package hansunping;

public class demon2 {

	public static void main(String[] args) {
		woker tom=new woker("tom", 2500);
		manner mail=new manner("milain", 5000, 2000);
		demon2 polyparamer= new demon2();//对象，类，调用方法
		polyparamer.showempanual(tom);
		polyparamer.showempanual(mail);

	}
	public void showempanual(employer e ) {
		System.out.println(e.getsalary());
		
	}
}

重要的是

public void showempanual(employer e ) {
       System.out.println(e.getsalary());

   }

这行代码。

还是看ai的解释

这段代码展示了Java中的继承和多态。
首先，你有一个名为`employer`的父类，它有两个属性：`name`和`salary`。它还有一个构造函数来初始化这些属性，以及两个方法`getsalary`和`getname`来获取这些属性的值。
然后，你有一个名为`manner`的子类，它继承了`employer`类。`manner`类添加了一个新的属性`bonus`，并且覆盖了`getsalary`方法来包括奖金。它还有一个名为`mann`的方法来打印出经理正在工作的信息。
在`demon2`类中，你创建了两个对象：一个`worker`对象`tom`和一个`manner`对象`mail`。然后，你创建了`demon2`类的一个实例，并调用了它的`showempanual`方法，分别传递了`tom`和`mail`作为参数。
`showempanual`方法接受一个类型为`employer`的参数`e`，并调用它的`getsalary`方法。由于`manner`类覆盖了`getsalary`方法，当你传递`mail`对象时，它会调用`manner`类的`getsalary`方法，这包括了奖金。
这就是多态的作用：你可以使用一个父类类型的引用来引用子类的对象，并且调用相应的方法时，会执行子类覆盖的方法。
当你运行这个程序时，你会看到输出两个工资：一个是`tom`的工资，另一个是`mail`的工资加上奖金。

关于在showempanual时传入的编译类型要求是employer，但其子类也可以看作是他的编译类型在传入时可以看作是employer的编译类型。这里相当于实现了employ e=new tom().的向上转型。所以才能根据我们传入的对象不同返回相应的salary

那我们来看看向下转型的，添加一个testwork方法，强制类型转换

package hansunping;

public class demon2 {

	public static void main(String[] args) {
		woker tom=new woker("tom", 2500);
		manner mail=new manner("milain", 5000, 2000);
		demon2 polyparamer= new demon2();//对象，类，调用方法
		polyparamer.showempanual(tom);
		polyparamer.showempanual(mail);
		polyparamer.testwork(tom);
		polyparamer.testwork(mail);

	}
	public void showempanual(employer e ) {
		System.out.println(e.getsalary());
		
	}
	public void testwork(employer e ) {
		if (e instanceof woker) {//如果是属于其子类
			((woker)e ).work();//向下转型
			
		} else if (e instanceof manner) {
			((manner)e ).manne();//向下转型

		}
		else {
			System.out.println("不做处理因为不合理");
		}
		
	}
}