继承和多态对应的几类问题

继承和多态对应的几类问题

• 员工薪资问题：

        例：

某公司的雇员分为以下若干类： Employee：这是所有员工总的父类，属性：员工的姓名,员工的生日月份。方法：void getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励1000元。 SalariedEmployee：Employee的子类，拿固定工资的员工。属性：月薪 HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放。属性：每小时的工资、每月工作的小时数 SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定。属性：月销售额、提成率 BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，工资由底薪加上销售提成部分。属性：底薪。

//定义一个父类，包含name和birthday属性
public class Employee {办法
    public String name;
    public int birthday;
    public void getSalary(int month){
    }
}
//定义一个子类，第一类员工的结算工资办法
class SalariedEmployee extends Employee{
    public double yx;
    @Override
    public void getSalary(int month){
        if(month==birthday){
            System.out.println(name+month+"月份工资为"+(yx+1000)+"元");
        }else{
            System.out.println(name+month+"月份工资为"+yx+"元");
        }
    }
}
//定义一个子类，第二类员工的结算工资办法
class HourlyEmployee extends Employee {
    public double hgz;
    public double hour;
    @Override
    public void getSalary(int month) {
        double gz = (hour < 160) ? (hour * hgz) : (hour - 160) * 1.5 + (160 * hgz);
        if (month == birthday) {
            System.out.println(name + month + "月份工资为" + (gz + 1000) + "元");
        } else {
            System.out.println(name + month + "月份工资为" + gz + "元");
        }
    }
}
//定义一个子类，第三类员工的结算工资办法
class SalesEmployee extends Employee{
    public double xse;
    public double tcl;
    @Override
    public void getSalary(int month){
        double gz=(month==birthday)?(xse*tcl+1000):(xse*tcl);
        System.out.println(name+month+"月份工资为"+gz+"元");
    }
}
//定义一个子类，第四类员工的结算工资办法
class BasePlusSalesEmployee extends SalesEmployee{
    public double dx;
    @Override
    public void getSalary(int month){
        double gz=(month==birthday)?(xse+tcl+dx+1000):(xse+tcl+dx);
        System.out.println(name+month+"月份工资为"+gz+"元");
    }
}
//定义一个测试类，并创建四个对象进行实例化操作
class Test2 {
    public static void main(String[] args) {
        SalariedEmployee e1 = new SalariedEmployee();
        e1.name = "张三";
        e1.birthday = 1;
        e1.yx = 3000;

        HourlyEmployee e2 = new HourlyEmployee();
        e2.name = "李四";
        e2.birthday = 2;
        e2.hgz = 10;
        e2.hour = 160;
        SalesEmployee e3 = new SalesEmployee();
        e3.name = "王五";
        e3.birthday = 3;
        e3.xse = 100000;
        e3.tcl = 0.1;
        BasePlusSalesEmployee e4 = new BasePlusSalesEmployee();
        e4.name = "赵六";
        e4.birthday = 4;
        e4.xse = 100000;
        e4.tcl = 0.1;
        e4.dx = 2000;
        //打印四个人的名字
        Employee[] e = {e1, e2, e3, e4};
        for (Employee em : e) {
            System.out.println(em.name);
        }
        //打印这四人12个月来每个月的薪资情况
        for (int i = 1; i < 13; i++) {
            System.out.println("------------第" + i + "月工资表------------");
            e1.getSalary(i);
            e2.getSalary(i);
            e3.getSalary(i);
            e4.getSalary(i);
        }
    }
}

         在多态中，涉及到将子类对象当做父类类型使用的情况，例如Animal animal=new dog();将子类对象当做父类使用时不需要任何显式声明，需要注意的是，此时不能通过父   类变量去调用子类中的某些方法，这时要用到对象类型转换。

         instanceof关键字可以判断一个对象是否为某个类（或接口）的实例或者子类实例。

         例：

public interface Animal {
    void shout();
}
class Dog implements Animal{
    public void shout(){
        System.out.println("汪汪汪");
    }
}
class Cat implements Animal {
    public void shout() {
        System.out.println("喵喵喵");
    }

    public static void main(String[] args) {

        Cat cat = new Cat();
        Dog dog = new Dog();

        animalShout(cat);
        animalShout(dog);
        // animal1.shout();
        // animal2.shout();
     /*   animalShout(animal1);
        animalShout(animal2);
    }
    public static void animalShout(Animal animal){
        animal.shout();
    }*/
    }

    public static void animalShout(Animal animal) {
        if (animal instanceof Dog) {        /*instanceof关键字判断animalShout方法中传入的对象是否为Dog类型*/
            //Cat cat = (Cat) animal;
            //animal.shout();
            Dog dog = (Dog) animal;
            animal.shout();
        } else if(animal instanceof Cat){         /*instanceof关键字判断animalShout方法中传入的对象是否为Cat类型*/
           Cat cat=(Cat) animal;
           animal.shout();
        }
    }
}

 

• 匿名内部类

        匿名内部类是实现接口的一种简便写法，在程序中不一定非要使用匿名内部类。

          格式:new 父类（参数列表）或父接口（）{/*匿名内部类实现部分*/}

//匿名内部类
public interface Jiaju {
    public void name();

    public class Test {
        public static void main(String[] args) {
            zhidaoName(new Jiaju() {
                @Override
                public void name() {
                    System.out.println("我是凳子");
                }
            });
        }
        public static void zhidaoName(Jiaju a){
            a.name();
        }
    }
}