小白学java日记day9：多态与抽象类

 实例展示

//描述公司员工信息:
//
//公司中有职员4人,包括程序员2个,美工1个,项目经理1个.
//
//程序员有姓名,工号,薪水,工作内容-编程
//
//美工:姓名,工号,薪水,工作内容-画图
//
//项目经理有姓名,工号,薪水,奖金
//
//工作内容-管理员工.
/*用到的技术点：
对象实例化
继承
重写
多台
final
Object
抽象类
构造方法在继承中的使用
super
this
 */
public class test1 {
    public static void main(String[] args) {
        //1.创建程序员类，美工类，项目经理类，并实现功能
        //one();
        // 2.优化代码
        // 2.1使用继
        // 2.2使用抽象类
        // 2.3使用构造方法在继承中的使用
        //super
        //this
        two();
    }
    public  static void one(){
        //使用父类的引用指向子类的对象
        //Object o=new ArtDesiger();//多态
        Object[] objects =new Object[4];
        objects[0] =new Programmer("张三",1,10000);
        objects[1] =new Programmer("李四",2,15000);
        objects[2] =new ArtDesiger("丽丽",3,8000);
        objects[3] =new Manager("王五",4,30000,1000);
        for (Object object : objects) {
            //因为父类布恩那个是使用子类成员所以这里错误
            //object.getName（）;
            //向下转型-强制理性转换--从高类型到低类型
//            Programmer p=(Programmer) object;
//            System.out.println(p.getName());

            //容错处理--增加用户体验
            //使用instanceof ，避免了当进行向下转型时可能发生的类型转换错误。
            if (object instanceof  Programmer){
                Programmer p=(Programmer) object;
                System.out.println(p.getName());
            }else if (object instanceof  ArtDesiger){
                ArtDesiger artDesiger=(ArtDesiger) object;
                System.out.println(artDesiger.getName());
            }else if (object instanceof  Manager){
                Manager manager=(Manager) object;
                System.out.println(manager.getName());
            }
        }
    }
    public static void two(){
        //使用父类的引用指向子类的对象
        //Object o = new ArtDesiger();//多态
        Emp[] emps = new Emp[4];
        emps[0] = new Programmer("张三",1,10000);
        emps[1] = new Programmer("李四",2,15000);
        emps[2] = new ArtDesiger("丽丽",3,8000);
        emps[3] = new Manager("王五",4,30000,1000);

        for (Emp emp : emps) {
            //因为父类不能使用子类的成员,所以这里错误
            //object.getName();
            //向下转型-强制类型转换--从高类型到低类型

            //容错处理--增加用户体验
            //使用instanceof,避免了当进行向下转型时可能发生的类型转换错误.
            if (emp instanceof Programmer){
                Programmer p = (Programmer) emp;
                System.out.println(p.getName());
                p.work();
            }else if (emp instanceof ArtDesiger){
                ArtDesiger artDesiger = (ArtDesiger) emp;
                System.out.println(artDesiger.getName());
                emp.work();
            }else if (emp instanceof Manager){
                Manager manager = (Manager) emp;

                manager.work();

                //获取属性信息
                System.out.println(manager.getName());
                //可以快速打印当前对象的属性值
                //System.out.println(manager.toString());
                //默认就是在调用toString
                System.out.println(manager);

                manager.managerEmp(emps[0]);
                manager.managerEmp(emps[2]);
            }

        }
    }

}
//创建共同的父类
// 一个类中如果有了抽象方法，这个类就必须是抽象类
//抽象类中一定有抽象方法吗？不一定
//抽象类中除了抽象方法，普通类的属性和正常方法也都可以有
//抽象类不能直接创建对象，但是可以通过子类创建对象。
abstract class Emp{
    private String name;
    private int id;
    private int salary;
    public Emp(){}
    public Emp(String name,int id ,int salary){
        this.name=name;
        this.id=id;
        this.salary=salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }
    //在继承中，提取父类方法的时候，每个人都有自己具体的方法实现，父类不能决定他们各自的实现方法,
    //所以父类干脆就不管了，在父类中只写方法的声明（负责制定一个规则），将方法的实现交给子类。
    //在类中只有方法声明的办法叫抽象方法，拥有抽象方法的类叫抽象类

    //work只是相当于一个规则，这里只有方法的声明部分，我们要写成抽象方法
    public abstract void work();
    @Override
    public String toString(){
        return "Emp{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", salary=" + salary +
                '}';
    }
}
//创建程序员类
class Programmer extends Emp{

    public Programmer(String name, int id, int salary) {
        super(name,id,salary);
    }
    //重写
    @Override
    public void work(){
        System.out.println("编程--happy");
    }
    @Override
    public String toString(){
        return "Programmer{"+"姓名:\"+getName()+\"  工号：\"+getID()+\" 薪水+getSalaty()"+"}";
    }
}
//美工类
class ArtDesiger extends Emp{
    public ArtDesiger(){}
    public ArtDesiger(String name, int id, int salary) {
        super(name, id, salary);
    }
    //重写
    @Override
    public void work(){
        System.out.println("画图--happy");
    }
    @Override
    public String toString() {
        return "ArtDesiger{"+"姓名:\"+getName()+\"  工号:\"+getId()+\"   薪水:\"+getSalary()"+"}";
    }
}
//项目经理类
class Manager extends Emp{
    //如果是自定义的类可以在定义时先不给值，但是必须在构造方法中给值，即必须保证属性是被初始化了的。这种情况较空白final。如果无参构造方法，会优先识别无惨构造。
    private double bonus;
    public Manager(String name, int id, int salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public void managerEmp(Emp emp){//多态
        System.out.println("管理-happy  "+emp.getName());
        emp.work();
    }
    //    public void managerEmp(ArtDesiger artDesiger){
//        System.out.println("管理-happy");
//        artDesiger.work();
//    }

    public void work(){
        System.out.println("管理整个项目-happy");
    }

    //重写Object的toString()方法
//    public String toString(){
//        String str = "姓名:"+getName()+"  工号:"+getId()+"   薪水:"+getSalary()+"   奖金:"+bonus;
//        return str;
//    }

    @Override
    public String toString() {
        return "Manager{" +"姓名:"+getName()+"  工号:"+getId()+"   薪水:"+getSalary()+"   奖金:"+bonus+
                '}';
    }
}