Java继承问题

在现实生活中个体和个体之间是存在各种各样关联的.比如学生和学生用的电脑.那学生和电脑之间就是一种使用关系.比如人和手机.是拥有关系.

继承和上面一样也是这些关系中的一种.我们通过一个判断语句来判断是否符合继承:is – a.比如 猫 is – a 老鼠.从现实生活中的逻辑上来看,猫不是一个老鼠,就代表代码中猫这个类不可以继承老鼠这个类.再比如手机 is – a 移动设备.这个判断是成立的,所以在代码中我们可以让描述手机的类继承描述移动设备的类.

在代码中使用extends关键字来表达继承关系.其本质目的是为了实现对已有的扩展.

派生类(子类) extends 基类(父类).对移动设备进行功能扩展得到手机,所以派生类是手机,基类是移动设备.

从功能上来说,派生类的功能比较多.因为基类是被派生的,所以基类有的,派生类都有,但是派生类有的,基类不一定有.

例如:

Person类:(父类)

public class Person {
    private String name;
    private int    age;
    private String gender;

    public Person()
    {

    }
    public Person(String name,int age,String gender)
    {
        this.name = name;
        this.age  = age;
        this.gender = gender;
    }

    public String getPerson()
    {
        return name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

Employee子类: (继承Person类)

public class Employee extends Person{
    private String job;

    public Employee()
    {

    }
    public Employee(String job)     //要调用父类的构造方法,需要把父类的有参构造方法的参数传到子类参数表中
    {
        //super(参数)   对构造方法的调用,这个地方super()方法来调用父类有参构造,并将父类的参数填入super中
        this.job = job;
    }
    public String getJob()
    {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

//    public boolean equal(Employee emp)
//    {
//        if(this.getName().equals(emp.getName())
//                && this.getAge() == emp.getAge()
//                && this.getGender().equals(emp.getGender())
//                && this.getJob().equals(emp.getJob()))
//        {
//            return true;
//        }
//        else
//        {
//            return  false;
//        }
//    }
    @Override       //重写父类的方法
    //Employee类继承于Person类,Person类继承于object类,所以Employee类也继承于object类
    public boolean equals(Object obj)
    {
        Employee emp = (Employee)obj; //类型强转,Object 小转大 Employee,必须强转

        if(this.getName().equals(emp.getName())
                && this.getAge() == emp.getAge()
                && this.getGender().equals(emp.getGender())
                && this.getJob().equals(emp.getJob()))
        {
            return true;
        }
        else
        {
            return  false;
        }
    }
}

特别注意:

       在子类Employee中,用到了一个"@Override",这一条语句的主要作用是重写父类方法,就是如果在子类中有一个和父类里一毛一样的方法,在子类中又想要重新定义,那么在该方法的上方就加上"@Override"这条语句;

        在这个子类中,equals()这个方法并不是父类Person类的方法,而是API已经写好的方法,这个方法位于Object类中,然而Person这个类是继承Object这个类的,然后Employee这个类又继承Person类,所以,对于Object类来说,Employee类也是Object类的子类,所以,在子类里重写了父类的方法.

        还需要提一点: 在子类中如果需要调用父类的有参构造方法,可以使用如下方法:

                在子类构造函数中的第一行加上super(),在这个方法里面填写父类有参构造方法的参数;例如:

public Person(String name,String num)
{
     this.name = name;
     this.num  = num;
}

         super()必须在第一行(注释除外); 在无参构造方法中,super()是隐藏的.
                

public Employee(int index,String name,String num)
{
    super(name,num);
    this.index = index;
}

测试类TestPerson:

public class TestPerson {
    public static void main(String[] args)
    {
        Employee em1 = new Employee();
        Employee em2 = new Employee();

        em1.setName("Jams");
        em1.setAge(33);
        em1.setGender("男");
        em1.setJob("篮球运动员");

        em2.setName("Kobe");
        em2.setAge(45);
        em2.setGender("男");
        em2.setJob("篮球运动员");

        System.out.println("两个人的信息如下:");
        System.out.println("name:"+em1.getName()+"age:"+em1.getAge()+"gender:"+em1.getGender()+"job:"+em1.getJob());
        System.out.println("name:"+em2.getName()+"age:"+em2.getAge()+"gender:"+em2.getGender()+"job:"+em2.getJob());
        System.out.println("判断两个人是否相等:");
        System.out.println(em1.equals(em2));
    }
}