Java面向对象：向上造型和重写

小小编码

于 2022-10-02 10:04:09 发布

阅读量221

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_48206782/article/details/127140392

版权

精华：

向上造型：------------------------------------好处：代码复用
- 超类型的引用指向派生类的对象
- 能点出来什么，看引用的类型-------------这是规定，记住就可以了
  
  多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用
  
  eg: 学生/老师/医生都是输出名字+问好------干的事都一样，
  
  就可以将学生/老师/医生统一造型到Person数组中，这样一个for即可----代码复用
方法的重写(override/overriding)：重新写
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了
- 重写需遵循"两同两小一大"原则：
  - 两同：
    - 方法名相同
    - 参数列表相同
  - 两小：
    - 派生类方法的返回值类型小于或等于超类方法的
      - void和基本类型时，必须相等
      - 引用类型时，小于或等于
    - 派生类方法抛出的异常小于或等于超类方法的
  - 一大：
    - 派生类方法的访问权限大于或等于超类方法的
重写与重载的区别：
- 重写(override)：发生在父子类中，方法名相同，参数列表相同
- 重载(overload)：发生在同一类中，方法名相同，参数列表不同

笔记：

向上造型：------------------------------------好处：代码复用

超类型的引用指向派生类的对象

能点出来什么，看引用的类型-------------这是规定，记住就可以了

多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用

eg: 学生/老师/医生都是输出名字+问好------干的事都一样，

就可以将学生/老师/医生统一造型到Person数组中，这样一个for即可----代码复用

public class UploadDemo {
    public static void main(String[] args) {
        Aoo o1 = new Aoo();
        o1.a = 1;
        o1.show();
        //o1.b = 2;  //编译错误，超类不能访问派生类的
        //o1.test(); //编译错误

        Boo o2 = new Boo();
        o2.b = 1;
        o2.test();
        o2.a = 2;  //正确，派生类可以访问超类的
        o2.show(); //正确

        Aoo o3 = new Boo(); //向上造型
        o3.a = 1;
        o3.show();
        //o3.b = 2;  //编译错误，能点出来什么，看引用的类型
        //o3.test(); //编译错误
    }
}

class Aoo{
    int a;
    void show(){
    }
}
class Boo extends Aoo{
    int b;
    void test(){
    }
}

方法的重写(override/overriding)：重新写

发生在父子类中，方法名相同，参数列表相同

重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了

class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我还是想做中餐--------------不需要重写
class Aoo extends 餐馆{
}
//2)我想改做西餐----------------需要重写
class Aoo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我想在中餐基础之上加入西餐----需要重写(先super中餐，再加入西餐)
classs Aoo extends 餐馆{
    void 做餐(){  
       super.做餐();
       做西餐
    }
}

重写需遵循"两同两小一大"原则：------------------------ 了解，一般都是一模一样的

两同：
- 方法名相同
- 参数列表相同

两小：

派生类方法的返回值类型小于或等于超类方法的

void和基本类型时，必须相等
引用类型时，小于或等于

//超类大，派生类小
class Coo{
    void show(){}
    double test(){ return 0.0; }
    Student say(){ return null; }
    Person sayHi(){ return null; }
}
class Doo extends Coo{
    //int show(){ return 1; } //编译错误，void时必须相等
    //int test(){ return 0; } //编译错误，基本类型时必须相等
    //Person say(){ return null; } //编译错误，引用类型时必须小于或等于
    Student sayHi(){ return null; } //正确
}

派生类方法抛出的异常小于或等于超类方法的-----------------API时讲

一大：
- 派生类方法的访问权限大于或等于超类方法的-----------------明天讲

//测试类
public class Test {
    public static void main(String[] args) {
        Person[] ps = new Person[5];
        ps[0] = new Student("zhangsan",25,"LF","111"); //向上造型
        ps[1] = new Student("lisi",24,"JMS","222");
        ps[2] = new Teacher("wangwu",34,"SD",8000.0);
        ps[3] = new Teacher("zhaoliu",28,"SX",9000.0);
        ps[4] = new Doctor("sunqi",56,"HEB","主任医师");
        for(int i=0;i<ps.length;i++){ //遍历所有人
            ps[i].sayHi(); //每个人跟大家问好
        }


        //重写方法被调用时，看对象的类型
        Student zs = new Student("zhangsan",25,"LF","111");
        zs.sayHi(); //调用Student类的sayHi()方法
        //1)p是Person类型的，所以能点出Person中的所有东西，包括了sayHi()
        //2)p的对象是Student类型的，重写方法被调用要看对象，所以调用的是Student类的sayHi()
        Person p = new Student("zhangsan",25,"LF","111");
        p.sayHi();  //调用Student类的sayHi()方法


    }
}

class Person{
    String name;
    int age;
    String address;
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}
class Student extends Person{
    String stuId; //学号
    Student(String name,int age,String address,String stuId){
        super(name,age,address); //传递的是name/age/address的值
        this.stuId = stuId;
    }
    void sayHi(){ //重写了Person的sayHi()
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，学号为:"+stuId);
    }
}
class Teacher extends Person{
    double salary; //工资
    Teacher(String name,int age,String address,double salary){
        super(name,age,address);
        this.salary = salary;
    }
    void sayHi(){ //重写了Person的sayHi()
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，工资为:"+salary);
    }
}
class Doctor extends Person{
    String level; //职称
    Doctor(String name,int age,String address,String level){
        super(name,age,address);
        this.level = level;
    }
}

重写与重载的区别：
- 重写(override)：发生在父子类中，方法名相同，参数列表相同
- 重载(overload)：发生在同一类中，方法名相同，参数列表不同

补充：

超类的意义：
- 封装共有的属性和行为---------------------------------实现代码复用
- 为所有派生类提供统一的类型，即向上造型-----实现代码复用

小小编码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象：向上造型和重写

重写需遵循"两同两小一大"原则：------------------------ 了解，一般都是一模一样的。向上造型：------------------------------------好处：代码复用。向上造型：------------------------------------好处：代码复用。重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了。派生类方法抛出的异常小于或等于超类方法的-----------------API时讲。
复制链接

扫一扫