Java继承与方法重写

  一、继承

1、基本概念
（1）继承是面向对象的三大特征之一，继承可以解决编程中代码冗余的问题，是实现代码重用的重要手段之一。

（2）继承是软件可重用的一种表现，新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法，来充实自身内容，这种现象或行为就称为继承。此时，新类称为子类，现有的类称为父类。

（3）继承最基本的作用就是使得代码可重用，增加软件的可扩充性。

（4）Java中只支持单根继承，即每个类只能有一个直接父类。

（5）继承表达的是“XX is a XX”的关系，或者说是一种特殊和一般的关系。如Dog is a Pet.

（6）继承的语法格式如下：

        [访问修饰符] class <SubClass> extends <SuperClass>{

                //代码

        }

        -->在Java中，继承通过extends关键字实现，其中SubClass称为子类，SuperClass称为父类或基类。

        -->访问修饰符如果是public，那么该类在整个项目中可见。

        -->若不写访问修饰符，则该类只在当前包中可见。

        -->在Java中，子类可以从父类中继承以下内容：

                》 可以继承public和protected修饰的属性和方法，不论子类和父类是否在同一个包里。

                》 可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一个包里。

                》 无法继承父类的构造方法

     案例代码       

 建一个父类：Animal类

package cn.bdqn.demo02;
 
public class Animal {
    // 将demo01包中Dog类和Penguin类中相同的代码提取到这个Animal类中
    private String name;
    private int health;
    private int love;
 
    public Animal() {
    }
 
    public Animal(String name, int health, int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getHealth() {
        return health;
    }
 
    public void setHealth(int health) {
        this.health = health;
    }
 
    public int getLove() {
        return love;
    }
 
    public void setLove(int love) {
        this.love = love;
    }
 
    public void print() {
        System.out.println("宠物信息-->昵称：" + this.getName() + "，健康值："
                + this.getHealth() + "，亲密度：" + this.getLove());
    }
 
}

        建一个子类：Dog类 ，继承自Animal类

p

ackage cn.bdqn.demo02;
 
public class Dog extends Animal {
    //在这个Dog类中只定义Dog类中特有的属性和方法，原来和Penguin类中相同的代码在Animal类中,通过继承获取，使用extends关键字来获取
    
    private String strain;
 
    public Dog() {
        super();//表示使用Animal类中的无参构造方法
    }
 
    public Dog(String name, int health, int love, String strain) {
        super(name, health, love);//表示使用Animal类中的有参构造方法
        this.strain = strain;
    }
 
    public String getStrain() {
        return strain;
    }
 
    public void setStrain(String strain) {
        this.strain = strain;
    }
    
    //定义Dog类中特有的方法
    public void eat(){
        System.out.println("狗吃骨头......");
    }
    
    public void printInfo(){
        super.print();
        System.out.println("品种："+this.getStrain());
    }
 
}

        建一个测试类：Test类

package cn.bdqn.demo02;
 
public class Test {
 
    public static void main(String[] args) {
        //创建Dog类对象
        Dog dog1 = new Dog();
        dog1.setName("旺财");
        dog1.setHealth(90);
        dog1.setLove(99);
        dog1.setStrain("金毛");
        //print()方法是Animal类中的
        dog1.print();
        //eat()方法是Dog类中的
        dog1.eat();
        dog1.printInfo();
        
        Penguin p1 = new Penguin("QQ", 90, 98, "公");
        //print()方法是Animal类中的
        p1.print();
        //swimming()是Penguin类中的
        p1.swimming();
        
 
    }
 
}

2、super关键字和子类对象
（1）使用super关键字调用父类成员

        1）super关键字代表父类引用，和this关键字的作用类似，都是将屏蔽了的成员变量、成员方法变得可见、可用，也就是说，用来引用被屏蔽的成员变量或成员方法。

        2）super是用在子类中，目的只有一个，就是访问直接父类中被屏蔽的内容，进一步提高代码的重用性和灵活性。

        3）super关键字可以访问父类的构造方法、属性、一般方法。

        4）通过super访问父类成员的语法格式如下：

                访问父类构造方法：super(参数)

                访问父类属性/方法：super.<父类属性/方法>

                -->super只能出现在子类（子类的方法和构造方法）中，而不是其他位置。

                -->super用于访问父类的成员，如父类的属性、方法、构造方法。

                -->具有访问权限的限制，如无法通过super访问父类的private成员。

（2）实例化子类对象

        1）在Java中，一个类的构造方法在如下两种情况下总是会被执行。

                -->创建该类的对象（实例化）

                -->创建该类的子类的对象（子类的实例化）

        2）当在Java语言中创建一个对象时，Java虚拟机会按照父类—子类的顺序执行一系列的构造方法。

        3）子类继承父类时构造方法的调用规则如下：

                a.如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，是否写“super();”语句，效果是一样的。

                b.如果子类的构造方法中通过super显示地调用了父类的有参构造方法，那么将执行父类相应的构造方法，而不执行父类无参构造方法。

                c.如果子类的构造方法中通过this显示地调用了自身的其他构造方法，在相应构造方法中遵循以上两条规则。

                d.如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级传递，一直执行到顶级父类Object类的无参构造方法为止。

  二、方法重写

1、概念
        方法的重写或方法的覆盖（overriding）

                子类根据需求对从父类继承的方法进行重新编写

                重写时，可以用super.方法的方式来保留父类的方法

                构造方法不能被重写

2、方法重写规则
        重写方法和被重写方法必须具有相同的方法名

        重写方法和被重写方法必须具有相同的参数列表

        重写方法的返回值类型必须和被重写方法的返回值类型相同或者是其子类

        重写方法不能缩小被重写方法的访问权限。

3、方法重载和方法重写的区别
​

 三、Object类

1、定义
   （1）Object类是所有类的父类

​

public class  Pet  extends Object {
          ……
}
   （2）在Java中，所有的类都直接或者间接地继承了java.lang.Object类。

   （3）Object类是所有Java类的祖先。

   （4）在定义一个类时，没有使用extend是关键字，也就是没有显示地继承某个类，那么这个类直接继承Object类。

2、Object类中的方法
​

​

3、Object类中的equals()方法
        用来比较两个对象是否是同一对象，若是，返回true，字符串对象的equals()方法用来比较两个字符串的值是否相等，java.lang.String类重写了Object类中的equals()方法。

         （1）方法一：手动重写方法

                代码如下：

     public boolean equals(Student stu) {
         //调用这个方法的对象（this）和传递过来的对象stu的姓名、年龄相同，就认为两个对象是同一个对         
           象，返回true，否则返回false
         if(this.getName().equals(stu.getName())&&this.getAge()==stu.getAge()){
             return true;
         }
          
        return false;
            
     }
        （2）方法二：利用组合键Alt+Shift+S组合键

                点击Override/Implement Methods....

​

                 然后选中equals，点击OK

​

                生成代码如下：在方法体里面进行重写操作

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return super.equals(obj);
    }