你可以理解为父类是一个模板，子类拿过来之后在上面修改。
创新互联建站-专业网站定制、快速模板网站建设、高性价比安徽网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式安徽网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖安徽地区。费用合理售后完善，十多年实体公司更值得信赖。
举个通俗的例子，盗墓笔记里张起灵家族手指都长，都长生不老。然后呢：
父亲姓张，那么他的前五个孩子都姓张，但是呢，第六个孩子跟妈妈姓王了，但是他们都继承了父类手指长，长生不老的特性。老六就是覆盖了父类中的张姓。
为啥写父类还要覆盖？
写父类是因为很多子类都有一些通用的属性，覆盖是因为每一个子类还有些不同之处。
比如鸟类：通用的属性是羽毛，会飞，两只腿，下蛋。
但是鸵鸟这个类比较特殊，它继承了鸟类但是不会飞，所以就覆盖父类的方法，把飞行这项重新写一下。
不知道你明白了没。我是这么理解的。如果有不对的地方还请见谅。
Java中覆盖和重载的区别如下：
override 可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对来说可能比较熟悉，可以翻译为重载，它是指可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
下面是对override和overload的测试程序，其中注释中的内容都是会产生编译错误的代码，将注释去掉，看看在编译时会产生什么效果。
// 对overload测试的文件：OverloadTest.java
public class OverloadTest {
// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。
public void fun(){
System.out.println("method fun in OverloadTest, no parameter");
}
public void fun(float f) {
System.out.println("method fun in OverloadTest, parameter type: float");
}
public void fun(int i){
System.out.println("method fun in OverloadTest, parameter type: int");
}
public void fun(int i1, int i2) {
System.out.println("method fun in OverloadTest, parameter type: int, int");
}
// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。
// 需要注意：这里的参数肯定不是相同的类型，否则的顺序的先后就毫无意义。
public void fun1(int i, float f) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float");
}
public void fun1(float f, int i) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int");
}
// 下面的两个方法用来验证方法抛出的异常对于重载的影响.
// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。
public void fun2() throws TestException {
System.out.println("fun2 in OverloadTest, exception: TestException");
}
public void fun2(int i) throws TestException, TestException1 {
System.out.println("fun2 in OverloadTest, exception: TestException, TestException1");
}
public void fun2(float f) throws Exception {
System.out.println("fun2 in OverloadTest, exception: Exception");
}
// 不能通过抛出的异常类型来重载fun方法。
//public void fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception");
//}
// 不能通过返回值重载fun方法。
//public boolean fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean");
// return true;
//}
private void fun3() { }
// 不能通过不同的访问权限进行重载
public void fun3() { }
public static void main(String[] args) {
// 这里只是定义了OverloadTest的实例，所以test不会调用
// OverloadTest1中的方法。
OverloadTest test = new OverloadTest1();
// 这里定义了OverloadTest1的实例，因为OverloadTest1是OverloadTest
// 的子类，所以test1会调用OverloadTest中的方法。
OverloadTest1 test1 = new OverloadTest1();
try {
int i = 1, j = 2, m = 3;
// 这里不会调用OverloadTest1的fun方法
// test.fun(i, m, j);
test1.fun(i, j, m);
test1.fun();
// 这个调用不会执行，因为fun3()在OverloadTest中访问权限是priavte
//test1.fun3();
test1.fun3(i);
} catch(Exception e) { }
}
}
class OverloadTest1 extends OverloadTest{
// 在子类中重载fun
public void fun(int i, int m, int n) {
System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int");
}
// 这个不是对父类中方法的重载，只是一个新的方法。
public void fun3(int i) {
System.out.println("fun2 in OverloadTest1");
}
}
// 对override测试的文件：OverrideTest.java
public class OverrideTest {
public void fun() throws TestException {
System.out.println("method fun in OverrideTest");
}
private void fun1() {
System.out.println("method fun1 in OverrideTest");
}
public static void main(String[] args) {
OverrideTest test = new OverrideTest1();
try {
test.fun();
test.fun1();
} catch(Exception e) { }
}
}
class OverrideTest1 extends OverrideTest{
// 以下正常Override
public void fun() throws TestException2 {
System.out.println("fun in OverrideTest1");
}
// 不能Override父类中的方法，因为它定义了不同的异常类型和
// 返回值。
//public int fun() throws TestException1 {
// System.out.println("method fun in Test");
// return 1;
//}
// 不能Override父类中的方法，因为它抛出了比父类中非法范围
// 更大的异常。
//public void fun() throws Exception {
// System.out.println("fun in OverrideTest1");
//}
// 这个方法并没有Override父类中的fun1方法，因为这个方法在
// 父类是private类型，所以这里只是相当于定义了一个新方法。
public void fun1() {
System.out.println("method fun1 in Test");
}
}
class TestException extends Exception{
public TestException(String msg) {
super(msg);
}
}
class TestException1 extends TestException {
public TestException1(String msg) {
super(msg);
}
}
class TestException2 extends TestException {
public TestException2(String msg) {
super(msg);
}
}
举个简单的例子，展示了多态性（Polymorphism）：重载（Overloaded）和覆盖（Overridden）。
多态性意味着方法可以在不同的时刻表现出不同的形式。在编译期间，这被称为方法重载。重载允许相关的方法可以使用相同的方法名访问。有时候这被称为ad hoc polymorphism,与parametric polymorphism 不同。
输出：
intstringoverriden int
从编译器的角度讲，如何生成能够正确调用的函数的代码？
静态重载（Static overloading）不难实现。当处理一个重载方法的声明时，一个新的绑定会被映射到一个不同的实现。在处理类型检查的过程中，编译器会分析参数的实际类型，然后决定使用哪个方法。
动态重载（Dynamic overloading ）允许运行时根据实际参数的类型来选择函数的不同实现。这是动态调度（dynamic dispatch）的一种形式。
动态调度也被用来实现方法覆盖。被覆盖的方法的调用由运行期间实际对象的类型决定的。
程序员在进行代码完整度检测的时候，通常会通过代码覆盖等方面来实现。
今天我们就一起来了解一下，代码覆盖对于JavaScript编程开发的作用。
代码覆盖提供有关是否以及可选地应用程序的某些部分被执行的频率的信息。
它通常用于判定一个测试套件执行特定代码库的全面程度。
它为什么是有用的?作为一名JavaScript开发者，你可能经常发现自己处于代码覆盖可能有用的情景。
例如：对测试套件的质量感兴趣?重构一个大型的遗留项目?代码覆盖可以准确显示代码库中已覆盖了哪些部分。
想快速了解是否覆盖了代码库的特定部分?代码覆盖可以显示有关应用程序的哪些部分已被执行的实时信息，而不是使用console.log进行printf-风格的调试或手动执行代码。
或者你可能正在优化速度，并想知道要关注哪些点?执行次数可以指出关键函数和循环。
给嵌入式嵌入式及框架作者可以通过直接hook到InspectorAPI上获得更大的灵活性。
V8提供两种不同的覆盖模式：尽力覆盖模式下收集覆盖信息，确保在运行时对性能的影响小，但可能会丢失已被垃圾回收(GC)函数的数据。
精确覆盖确保不会因为GC而丢失任何数据，甘肃电脑培训认为用户可以选择接收执行计数而不是二进制覆盖信息;但性能可能会受此额外开销的影响(有关详细信息，请参阅下一节)。
精准覆盖可以按函数或块粒度收集信息。
重庆分公司
重庆分公司
