爪哇2博客
关
爪哇2博客

爪哇中的方法重写

If subclass is having same 方法 as base 类 then it is known as 方法 overriding Or in another words, If subclass provides specific implementation to any 方法 which is present in its one of parents 类es then it is known as 方法 overriding


让我们从一个实时示例开始：

在 a small 组织anization,There are two kinds of 雇员s i.e. 经理 and 开发者. Now we want to print 薪水 of employee.

在org.arpit.java2blog中创建Employee.java类
雇员.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
25
26
27
28
29
30
31
32
33
34
35
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员 {
    整型 员工ID;
    串 员工姓名;
    双 薪水;
 
    上市 雇员(整型 员工ID, 串 员工姓名, 双 薪水) {
        超();
       这个.员工ID = 员工ID;
        这个.员工姓名 = 员工姓名;
        这个.薪水 = 薪水;
    }
 
    上市 整型 getEmployeeId() {
        返回 员工ID;
    }
    上市 虚空 setEmployeeId(整型 员工ID) {
        这个.员工ID = 员工ID;
    }
    上市 串 getEmployeeName() {
        返回 员工姓名;
    }
    上市 虚空 setEmployeeName (串 员工姓名) {
        这个.员工姓名 = 员工姓名;
    }
    上市 双 getSalary() {
        返回 薪水;
    }
    上市 虚空 setSalary(双 薪水) {
       这个.薪水 = 薪水;
    }
}
 

经理.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
包 组织.Arpit.爪哇2blog;
 
上市 类 经理 延伸 雇员{
 
    上市 静态的 最后 双 奖金百分比=0.2;
    上市 经理(整型 员工ID, 串 员工姓名, 双 薪水) {
        超(员工ID, 员工姓名, 薪水);
    }
    上市 双 getSalary() {
        返回 薪水+薪水*奖金百分比;
    }
}
 

开发者.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
包 组织.Arpit.爪哇2blog;
上市 类 开发者 延伸 雇员{ 
    上市 静态的 最后 双 奖金百分比=0.1;
 
    上市 开发者(整型 员工ID, 串 员工姓名, 双 薪水) {
        超(员工ID, 员工姓名, 薪水);       
    }
 
    上市 双 getSalary() {
 
        返回 薪水+薪水*奖金百分比;
    }
}
 

MethodOverridingMain:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
包 组织.Arpit.爪哇2blog;
 
上市 类 MethodOverridingMain {
 
    / **
     * @作者Arpit Mandliya
     */
    上市 静态的 虚空 主要(串[] args) {
        开发者 d1=新 开发者(1,“阿尔伯特” ,20000);
        开发者 d2=新 开发者(2,“约翰” ,15000);
        经理 m1=新 经理(1,“授予” ,30000);
        经理 m2=新 经理(2,“阿什温” ,50000);
 
        系统.出.打印(“员工的名字：” +d1.getEmployeeName()+“-”+“薪水：”+d1.getSalary());
        系统.出.打印(“员工的名字：” +d2.getEmployeeName()+“-”+“薪水：”+d2.getSalary());
        系统.出.打印(“员工的名字：” +m1.getEmployeeName()+“-”+“薪水：”+m1.getSalary());
        系统.出.打印(“员工的名字：” +m2.getEmployeeName()+“-”+“薪水：”+m2.getSalary());
    }
}
 

运行：
当您运行MethodOverridingMain.java时，将获得以下输出：

员工姓名：Arpit—Salary:22000.0
员工姓名：约翰—Salary:16500.0
员工姓名：阿米特—Salary:36000.0
员工姓名：Ashwin—Salary:60000.0

如您所见，我们在Developer和Manager中重写Employee类的getSalary（）方法。 为什么我们需要重写getSalary（）？
因为我们需要基于Class的getSalary（）方法的特定实现。例如开发人员类和管理者类具有不同的奖励，因此我们两者都需要不同的实现。

方法覆盖规则

争论 一定不能改变
返回类型 能够’除协变（子类型）返回值外的t变化
访问修饰符 一定不要限制更多。可以减少限制。
例外情况 可以减少或消除但不能抛出新的/广泛检查的异常
建设者 能够 not be overriden
静态方法 能够 not be overriden
最终方法 能够 not be overriden

现在，在这里，我将回答您可能遇到的一些显而易见的问题：

问题

为什么可以’您是否对访问修饰符进行了更严格的限制（例如，从公开到私有）？

It’在OOP中有一个基本原则：子类是父类的完整实例，因此必须至少具有与父类相同的接口。减少可见度将违反此想法；您可以使子类无法用作父类的实例。
让我们借助示例进行查看：

1
2
3
4
5
6
7
8
9
10
11
12
13
 
类 雇员{
 上市 双 getSalary(){
      //一些操作
    }
 }
 
类 开发者 延伸 雇员{
   私人的 双 ID getSalary(){
       //一些操作
   }
 }
 

现在，我可以使用致电：

1
2
3
4
 
雇员 e1=新 开发者();
e1.getSalary();
 

因此，即使您将开发人员的getSalary（）方法设为私有，即使您将其设为私有，您也可以使用Employee（父类）的引用访问开发人员的getSalary（）方法。所以你可以’•在覆盖方法时减少访问修饰符。

为什么可以’您覆盖静态方法吗？

由于静态方法与类相关，而与对象状态无关，因此可以在子类中声明静态方法，但与父类无关。是隐藏而不是覆盖的方法。

能够 you override 私人的 方法s?

不可以’t。私有方法不能被覆盖，因为它在任何其他类中都不可见。您可以为子类声明一个与超类方法无关的新方法。因此，这不是方法重写。

为什么可以’您覆盖最终方法吗？

因为final方法是不可重写的，所以您声明一个final方法是因为您没有’不想在子类中重写它。

如果我们更改参数数量怎么办？

如果您更改参数数量，那么方法重载将不会被覆盖。父类方法和子类方法应具有相同的方法签名。

什么是动态绑定？

在运行时发生的覆盖方法的绑定称为动态绑定。

超级关键字

Super关键字可用于从子类中调用特定的父类方法。
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
包 组织.Arpit.爪哇2blog;
 
上市 类 雇员{
上市 双 getSalary(){
  系统.出.打印(“在Employee类中，getSalary（）方法”);
  返回 0;
}
 
上市 静态的 虚空 主要(串 args[])
{
  开发者 d1=新 开发者();
  d1.getSalary();
}
}
 
类 开发者 延伸 雇员{
上市 双 getSalary(){
               //调用父类方法
  超.getSalary();
  系统.出.打印(“在开发人员类中的getSalary（）方法”);
  返回 0;
}
}
 

运行该程序时，将获得以下输出：
1
2
3
4
 
在 雇员 类 getSalary() 方法
在 开发者 类 getSalary() 方法
 

那’关于Java中的方法重写的全部内容。


相关文章

分享这个

作者

关注作者

相关文章

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


成为朋友

©2020 爪哇2博客