貌似又是多态的问题 不会了啊

Question

/*2
.某公司的雇员分为以下若干类：
Employee：这是所有员工总的父类，
属性：员工的姓名,员工的生日月份。
方法：getSalary(int month) 
根据参数月份来确定工资，
如果该月员工过生日，则公司会额外奖励100元。
SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪
HourlyEmployee：Employee的子类，按小时拿工资的员工
，每月工作超出160小时的部分按照1.5倍工资发放。
属性：每小时的工资、每月工作的小时数
SalesEmployee：Employee的子类，销售人员，
工资由月销售额和提成率决定。属性：月销售额、提成率
BasedPlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，
工资由底薪加上销售提成部分。属性：底薪。
写一个程序，把若干各种类型的员工放在一个Employee数组里，
写一个函数，打印出某月每个员工的工资数额。
注意：要求把每个类都做成完全封装，不允许非私有化属性
*/
class Employee //所有员工总的父类
{
private String name ;//员工的姓名
private int yue ; //员工的生日

public Employee()
{
}
public Employee( String name , int yue ) //构造方法
{
this.name = name ;
this.yue = yue ;
}
 void setName( String name )
{
this.name = name ;
}
  void setYue (int yue)
{
this.yue = yue ;
}
  String getName()
{
return name ;
}
  int getYue()
{
return yue ;
}
  void getSalary(int month)  //方法：getSalary(int month) 
{
if ( yue == month )
{
System.out.println("生日快乐，公司将额外奖励你100");
}
}
void gongzi ()
{
System.out.println("父类的成员方法");
}
}
//拿固定工资的员工
class SalariedEmployee extends Employee
{
private double yuexin ; //月薪

public SalariedEmployee ( double yuexin ) //构造方法
{
this.yuexin = yuexin ;
}
  void setYuexin( double yuexin )
{
this.yuexin = yuexin ;
}
  double getYuexin()
{
return (double)yuexin;
}
  void gongzi ()
{
System.out.println("拿固定工资得是" + yuexin );
}

}//按小时拿工资的员工
class HourlyEmployee extends Employee
{
private double gongzi ; //每小时的工资、
private int xiaoshi ; //每月工作的小时数

public HourlyEmployee()
{

}
public HourlyEmployee ( double gongzi , int xiaoshi )//构造方法
{
this.gongzi = gongzi ;
this.xiaoshi = xiaoshi ;
}

  void setGongzi ( double gongzi )
{
this.gongzi = gongzi ;
}
  void setXiaoshi ( int xiaoshi )
{
this.xiaoshi = xiaoshi ;
}

double getGongzi()
{
return (double)gongzi ;
}
int getXiaoshi()
{
return xiaoshi ;
}
//每月工作超出160小时的部分按照1.5倍工资发放
void gongzi () //工作时间
{
if ( xiaoshi > 160 )
{
gongzi =(double) (gongzi * xiaoshi * 1.5) ;  
System.out.println("超出时间得工资是 " + gongzi );
}
else 
{
 gongzi = (double)gongzi * xiaoshi ;
 System.out.println("没有超出时间得工资是" + gongzi );
}
}
}//销售人员，
class SalesEmployee extends Employee
{
private double xiaoshou ; //月销售额
private double ticheng ;  // 提成率

public SalesEmployee()
{

}
public  SalesEmployee ( double xiaoshou , double ticheng ) //构造方法
{
this.xiaoshou = xiaoshou ;
this.ticheng = ticheng ;
}

  void setXiaoshou( double xiaoshou )
{
this.xiaoshou = xiaoshou ;
}
void setTicheng( double ticheng )
{
this.ticheng = ticheng ;
}

  double getXiaoshou()
{
return (double)xiaoshou ;
}
  double getTicheng()
{
return (double)ticheng ;
}
//工资由月销售额和提成率决定
  void  gongzi()
{
System.out.println("销售得工资是" +( xiaoshou * ticheng )) ;
}

}
//有固定底薪的销售人员
class BasedPlusSalesEmployee extends SalesEmployee
{
private double dixin ;
private double ticheng;

public  BasedPlusSalesEmployee ( double dixin )
{
this.dixin = dixin ;
}
  public void setDixin( double dixin )
{
this.dixin = dixin ;
}
  public double getDixin()
{
return (float)dixin ;
}

  void gongzi ()
{
System.out.println("拿底薪得销售工资是 " + (dixin * ticheng)) ;
}
}class EmployeeTest
{
public static void main ( String [] args )
{
Employee [] a = new Employee [4];
a[0] = new Employee ("张三" , 1);
a[1] = new HourlyEmployee(0.0 , 0 );
a[2] = new SalesEmployee(0.0 , 0.0 );
a[3] = new BasedPlusSalesEmployee(0.0);
}
}各位 这个我前面写出来了 可是写到 写一个程序，把若干各种类型的员工放在一个Employee数组里，
写一个函数，打印出某月每个员工的工资数额。 这里就不知道怎么做了 
还有我写的这些是封装嘛？？？？？？ 那里不好的 麻烦个人牛人说出来 详细点啊 

Answer 1

这个题很像我曾经做过的一个实验
LZ参考这里：http://blog.csdn.net/XiaoHuanJie/archive/2009/09/21/4575587.aspx

Answer 2

JAVA的动态多态性本就可以很好的完成你需要的工作。直接用数组中的元素调用gongzi 这个函数就好了。

Answer 3

....又是你.  老来问作业0.0
  上次就你说一个JAVA文件只写一个类。你看你...  一个public类都有,能编译通过？？？
  还这样写，不听话。懒得回答你

Answer 4

当你定义了一个类时  类里面一定有它的若干个成员变量而且还有它的方法 而这些类的成员变量和方法就被封装在这个类里面 这也是封装的一个书面上的定义
另外你写的这个函数还是觉得有点模糊 我帮你改了一下  大体上的还是原样的 
代码如下:
class Employee //所有员工总的父类 
{  
private String name ;//员工的姓名 
private int yue ; //员工的生日     
public Employee()  
{} 
public Employee(String name ,int yue) //构造方法  
{  
this.name = name ; 
this.yue = yue ;  
}    
void setName(String name)  
{  
this.name = name; 
}   
void setYue (int yue)  
{  
this.yue = yue ;  
}   
public String getName() 
{ 
return name ;  
}   
public int getYue()  
{  
return yue ;  
}   
        void getSalary(int month)  //方法：
               {  
if (yue==month ) 
   {  
System.out.println("生日快乐，公司将额外奖励你100");  
           }  
}  
void gongzi()  
{  
System.out.println("父类的成员方法");  
} 
} 
//拿固定工资的员工  
class SalariedEmployee extends Employee  
{  
private double yuexin ; //月薪     
public SalariedEmployee(double yuexin) //构造方法  
{ 
this.yuexin = yuexin ;  
}   
void setYuexin(double yuexin)  
{ 
this.yuexin = yuexin ;  
}   
double getYuexin()  
{  
return (double)yuexin;  
} 
void gongzi ()  
{ 
System.out.println("拿固定工资得是" +yuexin );  
}     
} 
//按小时拿工资的员工  
class HourlyEmployee extends Employee  {  
private double gongzi ; //每小时的工资、  
private int xiaoshi ; 
double ewai=0; 
                public HourlyEmployee()  
{}  
public HourlyEmployee(double gongzi ,int xiaoshi)//构造方法  
{  

this.gongzi = gongzi ;  
this.xiaoshi = xiaoshi ; 
}      
void setGongzi(double gongzi)  
{  
this.gongzi =gongzi ;  
} 
void setXiaoshi(int xiaoshi)  
{  
this.xiaoshi = xiaoshi ;  
} 
double getGongzi()  
{  
return (double)gongzi ;  
}  
int getXiaoshi()  
{  
 return xiaoshi ;  
 } //每月工作超出160小时的部分按照1.5倍工资发放  
 
 void  gongzi () //工作时间 
 {  
if ( xiaoshi < 160 ) {
    ewai=0;
                       } 
  else{  
 ewai =(double) ((xiaoshi-160 )* 1.5) ; 
 System.out.println("额外时间得工资是 " +ewai );
       }  
  gongzi=gongzi+ewai; 
  System.out.println("所得到的工资是" +gongzi );  
       }  
} 
//销售人员，  
class SalesEmployee extends Employee  { 
private double xiaoshou ; 
  private double ticheng ;
double i=50.0; //销售一件可以得到的钱 
double sum=0;
  
  public SalesEmployee() 
  {}  
  public SalesEmployee(double xiaoshou ,double ticheng) //构造方法  
  { 
this.xiaoshou = xiaoshou ;  
this.ticheng  = ticheng ; 
        }      
        void setXiaoshou(double xiaoshou)  
{  
this.xiaoshou =  xiaoshou ; 
}  
void setTicheng(double ticheng)  
{  
this.ticheng = ticheng;  
} 
double getXiaoshou()  
{  
return (double)xiaoshou ;  
}   
double  getTicheng() 
        {  
return (double)ticheng;  
        }  
        void  gongzi() 
       { 
sum=(xiaoshou)*i+ticheng;
System.out.println("销售得工资是:" +sum) ;
}     
} 
//有固定底薪的销售人员  
class BasedPlusSalesEmployee extends  SalesEmployee  { 
private double dixin ;  
private double ticheng;
BasedPlusSalesEmployee(double dixin,double ticheng){
                this.dixin=dixin;
this.ticheng=ticheng;
}    
/*public BasedPlusSalesEmployee(double dixin)  
{  
this.dixin = dixin ;  
}*/
public void setDixin(double dixin)  
{  
this.dixin = dixin ;  
}
public double getDixin()  
{  
return (float)dixin ;  
        }      
void gongzi() 
{ 
System.out.println("拿底薪得销售工资是 " + (dixin + ticheng)) ;  
}  
} 
public class EmployeeTest  {  
public static void main ( String [] args ){ 
        SalariedEmployee s=new SalariedEmployee(2000);
HourlyEmployee h=new HourlyEmployee(2500,240);
SalesEmployee d=new SalesEmployee(100,1000);
BasedPlusSalesEmployee b=new BasedPlusSalesEmployee(2500,1000);
System.out.println("第一个员工的工资情况为:");
s.gongzi();
System.out.println("");
System.out.println("第二个员工的工资情况为:");
h.gongzi();
System.out.println(""); 
System.out.println("第三个员工的工资情况为:");
d.gongzi();
System.out.println(""); 
System.out.println("第四个员工的工资情况为:");
b.gongzi();     
}  
} 

Answer 5

因为都是员工，都有员工父类的特点，所以函数定义中的参数也应该是员工的父类，在JAVA中用父类或者接口来NEW子类是很常见的事。因为数组中的元素类型必须是一致的，如果把对象都变成员工的父类那么就符合要求了。至于把他们添加到数组中 加个for循环赋值就可以了。
打印工资，你可以覆盖每个子类中的toString方法，从数组中取出来，然后转换类型，这样直接打印数组中的对象就可以了。