第十二节(方法的覆盖)

方法的覆盖(Override)的条件:

? 必须要有继承关系

? 覆盖只能出现在子类中,如果没有继承关系,不存在覆盖,只存在重载

? 在子类中被覆盖的方法, 必须和父类中的方法完全一样, 也就是方法名, 返回类型、参数列表,完全一样

? 子类方法的访问权限不能小于父类方法的访问权限

? 子类方法不能抛出比父类方法更多的异常,但可以抛出父类方法异常的子异常

? 父类的静态方法不能被子类覆盖

? 父类的私有方法不能覆盖

? 覆盖是针对成员方法,而非属性

为什么需要覆盖?
就是要改变父类的行为

方法覆盖 两种形式:

对成员方法覆盖

对静态方法覆盖



/*
    关于方法的覆盖:

        1. 什么时候方法需要进行重写?
            如果父类中的方法已经无法满足 当前子类的业务需求,需要将父类中的方法重写一遍

        2. 子类如果重写父类的方法之后,子类的对象一定要调用 重写之后的方法

        3. 发生方法的覆盖的条件:

            第一:发生在具有继承关系的两个类之间
            第二:必须具有相同的方法名,相同的返回值类型,相同的参数列表
            第三:重写的方法不能比被重写得方法拥有更底的访问权限;

            第四:重写的方法不能比被重写的方法抛出的更宽泛的异常(异常机制)
            第五:私有方法是不能被覆盖(多态)
            第六:构造方法无法被覆盖,因为构造方法无法被继承的
            第七:静态的方法不存在覆盖(多态)
            第八:覆盖指的是成员方法,和成员变量无关。

        4. 继承最基本的作用: 

                代用重用
                继承最重要的作用:方法可以重写

        new谁就调谁

*/
//对成员方法覆盖
public class Test01{

    public static void main(String[] args){

        //  创建子类对象
        Cat c = new Cat();

        // 调用方法
        c.move();

        Animal a = new Animal();
        a.move();

    }

}

// 父类:动物
class Animal{

    // 成员方法
    public void move(){
        System.out.println("小动物在移动 !");
    }

}

// 子类:猫
class Cat extends Animal{

    // Cat的move方法 应该输出:小猫走起,还跳起来了!
    // Animal中的move方法 已经无法满足Cat了
    // 所以在Cat类中对Animal类中的move方法进行 重新定义(就是方法的覆盖,方法的重写 Overwrite,Override)
    public void move(){
        System.out.println("小猫走起,还跳起来了!");
    }

//输出为:小猫走起,还跳起来了!

//       小动物在移动 !

}



/*
    对静态方法的覆盖

    1. 声明的是哪一个类就调用的是哪一个类的静态方法和子类 是没有关系的

*/
public class OverrideStaticTest01{

    public static void main(String[] args){

            Person person_student = new Student();

            person_student.setName("ming");
            person_student.setSex(true);
            person_student.setAge(18);

            print(person_student);
    }

    private static void print(Person p){
        p.printInfo();
    }

}

class Person{

    // 姓名
    private String name;
    // 性别
    private boolean sex;
    // 年龄
    private int age;

    // 静态方法
    public static void printInfo(){

        System.out.println("---------Person---------");

    }

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

    public void setSex(boolean sex){
        this.sex = sex;
    }
    public boolean getSex(){
        return sex;
    }

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

}

class Student extends Person{

    // 学号
    private int id;

    // 班级编号
    private int classId;

    // 静态方法
    public static void printInfo(){

        System.out.println("---------Student---------");

    }    

    public void setId(int id){
        this.id = id;
    }
    public int getId(){
        return id;
    }
//输出为:--------Person---------
}
时间: 2024-12-14 22:33:02

第十二节(方法的覆盖)的相关文章

关于继承时子类重写父类方法和覆盖父类变量的若干问题

假设,子类重载父类的方法,并将子类的成员覆盖. 创建子类对象实例,将其上转型成父类. 例子1 public class Parent { public void init() { System.out.println("1 init parent"); this.demo(); } public void demo() { System.out.println("2 demo parent"); } } public class Son extends Parent

2016.7.11子父类中方法的覆盖要点

子类new出来的对象,可以调用父类中的方法(private修饰的除外),但当子类中出现父类方法名以及参数一样的方法时,子类中的方法就是重载,覆盖父类中的相同的方法. 注意的方面: 1.子类中的方法与父类中的方法在“有无返回”.“有无参数”都应该一样的.不一样无法覆盖,但是子类中的方法还是可以被调用的,因为它就是区别于父类中的方法了. 2子类中权限修饰符的等级一定要大于或者等于父类中的,不然也是无法覆盖的哦.(public>defualt默认的>private) 3.静态的方法只能覆盖静态的方法

Java学习----方法的覆盖

方法的覆盖:子类继承父类,子类重写父类的同名方法. 覆盖的原则: 1. 方法的参数必须跟父类保持一致 2. 子类方法的修饰符的范围必须大于等于父类方法同名的修饰符(public > private) public class Father { public void print() { System.out.println("Father:print()"); } } public class Son extends Father{ // 方法的覆盖:子类重写父类的同名方法 Ov

成员变量的隐藏,方法的覆盖,super关键字

成员变量的隐藏:当父类和子类有相同的成员变量时,即定义了与父类相同的成员变量时,就会发生子类对父类变量的隐藏.对于子类的对象来说,父类中的同名成员变量被隐藏起来,子类就会优先使用自己的成员变量,父类成员隐藏. public class yincang {public static void main(String []args){ SonA son=new SonA(); son.showson(); FatherA father=new FatherA(); father.showfather

继承中方法的覆盖

执行下边的代码: class Parent2{ public void Print() { System.out.println("今天是个好日子!!"); } } class Child2 extends Parent2{ public void Print() { //super.Print(); System.out.println("今天不是个好日子!!"); } } public class super1 { public static void main

子类的方法必须覆盖父类的抽象方法

如果让一个非抽象类继承一个含抽象方法的抽象类,则编译时会发生错误.因为当一个非抽象类继承一个抽象方法的时候,本着只有一个类中有一个抽象方法,那么这个类必须为抽象类的原则.这个类必须为抽象类,这与此类为非抽象冲突,所以报错. 所以子类的方法必须覆盖父类的抽象方法.方法才能够起作用. 只有将理论被熟练运用在实际的程序设计的过程中之后,才能说理论被完全掌握! 为了实现多态,那么父类必须有定义.而父类并不实现,留给子类去实现.此时可将父类定义成abstract类.如果没有定义抽象的父类,那么编译会出现错

Java类成员(成员变量和方法)的覆盖与隐藏归纳

以前就知道重写override和重载overload的区别,平时也是逮着用就是了,Eclipse报错再说. 最近看一本书里面出现了重写.替换.覆盖.置换.隐藏.重载,简直乱得不行,归纳整理一下. 从全局来看,java只有重写.隐藏.重载3种,具体归纳如下: 基本概念: 方法签名:方法名+参数列表(参数类型.个数.顺序).=================================[重写]================================= 某些书又叫覆盖.替换.置换.本文统一

Java继承方法隐藏(覆盖)

方法隐藏 一个类从其超类继承所有非私有静态方法.在子类中重新定义继承的静态方法称为方法隐藏.子类中的重定义静态方法隐藏其超类的静态方法.在类中重定义非静态方法称为方法覆盖.关于方法隐藏的重定义方法(名称,访问级别,返回类型和异常)的所有规则与方法覆盖相同. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class MySuper {   public static void print() {     System.

java变量和方法的覆盖和隐藏(翻译自Java Tutorials)

隐藏变量 在一个类里,如果一个变量的名字和父类的变量的名字一样,即使他们的类型不一样,那么在子类中,父类的同名变量无法直接通过变量名访问.但是,父类的同名变量可以通过super访问.一般来说,不推荐隐藏变量,这样会让代码难以阅读 覆盖和隐藏方法 对象实例方法 在一个对象实例方法中,如果子类有一个方法,它的签名(方法名字,方法的参数个数和类型)和返回值都和父类一样,那么就是覆盖父类的方法.子类覆盖的能力,允许一个类,继承父类的行为,根据需要修改某些行为.覆盖的方法,和父类对应的方法有一样的名字,一