java面向对象04-向上造型/重写与重载

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

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

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

     > 多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用
     >
     > 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(){
         }
     }

2. 方法的重写(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; } //正确
         }

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

     - 一大：

       - 派生类方法的访问权限大于或等于超类方法的

   //测试类
     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;
         }
     }

3. 重写与重载的区别：

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

## 补充：

1. 超类的意义：

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

最后

以上就是欣喜飞鸟为你收集整理的java面向对象04-向上造型/重写与重载的全部内容，希望文章能够帮你解决java面向对象04-向上造型/重写与重载所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。