当前位置：首页 > 句子词语 > 反义词> 覆盖的反义词

覆盖的反义词

时间：2022-08-06 08:02:00 反义词收藏本文下载本文

覆盖的反义词（通用6篇）由网友“请你加油”投稿提供，下面是小编整理过的覆盖的反义词，欢迎您阅读分享借鉴，希望对您有所帮助。

覆盖的反义词

篇1：覆盖的反义词

词语：覆盖

【覆盖的反义词】(以下词语任选其一)

掀开；揭开；

附录词语（覆盖）的相关知识：

【覆盖的意思】

①（动词）遮盖。地面覆盖着白雪。（作谓语）；②（名）指地面上的植物。

【覆盖的'近义词】(以下词语任选其一)

包围；掩盖；笼盖；遮盖；笼罩；

篇2：覆盖的反义词

覆盖的反义词:

掀开揭开

为更好地掌握这个词语，以下是覆盖饶造句：

1、花园，早已被大雪覆盖了。树枝上挂满了一个个沉甸甸的小雪球，一阵微风吹过，树枝一颤一颤的，仿佛在向我们问好。院子里的花都枯萎了，不，不，那……那花开得正盛呢!没错，那是梅花。

2、冬天，一层薄薄的白雪，像巨大的轻软的羊毛毯子，覆盖摘在这广漠的荒原上，闪着寒冷的

银光。

被泥土覆盖了

3、香椿树很高很高，足足有两层楼高。树冠郁郁葱葱，覆盖着整个院子。夏天骄阳似火，我们的小院却树影婆娑，显得十分凉快。我们在树下做功课、打扑克，有时爷爷、奶奶在树下喝茶聊天，爸爸妈妈在树下看报谈心。

4、无数雪白的云团聚集在远处，气势磅礴地覆盖了脚下的群山。云块轻轻地碰撞着，挤压着，推拥着，缓慢而又柔和地翻腾、起伏，无声无息地向这里拥来……

5、纷纷扬扬的大雪下了一夜，整个大地都覆盖了一层厚厚的雪花，好像大地母亲披上了一件白色的外衣。

6、穿过一大片原始白桦林溯源而上，我看见了碧草覆盖下的高原湿地，一脚踏上去软绵绵的，酷似红军跋涉过的草地。云来时，草地变成墨绿色;风骤起，草地绿浪滚滚。

7、微风轻轻的吹，暖暖的阳光覆盖着大地，小草在阳光的沐浴下吐出了嫩嫩的小芽。

8、时间漫步过宿命的转轮，覆盖住纷繁的凡世，事过境迁，早已是物是人非了。转眼间，岁月匆匆。四千多日子从我手中溜去，如同一滴水滴在大海里。没有声音，没有影子，没有任何踪影。

篇3：覆盖的反义词是什么

覆盖的近义词是什么

与覆盖一词含义相近的`词语有：掩盖、遮盖、包围、笼罩、笼盖等。

1、掩盖 [ yǎn gài ] 遮盖，也可指掩饰该受责备的或违法的事。如：掩盖丑事。

2、遮盖 [ zhē gài ] 从上面遮住。如：路让大雪遮盖住了。

3、包围 [ bāo wéi ] 四面围住。如：将敌人全部包围住。

篇4：覆盖

覆盖

覆盖fù gài[释义]

①（动）遮盖。地面～着白雪。（作谓语）

②（名）指地面上的植物。

[构成] 并列式：覆＋盖

篇5：覆盖是什么意思

覆盖的意思：

1、遮盖;掩盖。

2、指空中某点发出的电波笼罩下方一定范围的地面。

3、指地面生长的成片植物。

英文解释

cover;overlap;plant cover;vegetation;bestrow ;

[cover]

遮盖;掩盖

其牙机巧制,皆隐在尊中,覆盖周密无际。--《后汉书.张衡传》

指空中某点发出的电波笼罩下方一定范围的地面

指地面生长的成片植物

枝枝相覆盖,叶叶相交通。--《玉台新咏.古诗为焦仲卿妻作》

详细解释

掩饰;遮盖。

《史记·曹相国世家》：“ 参见人之有细过，专掩匿覆盖之。”《玉台新咏·古诗为焦仲卿妻作》：“枝枝相覆盖，叶叶相交通。” 巴金《秋》六：“她的整个脸沐着月光，略微高的前额上覆盖着刘海。”

犹伞篷。

《英烈传》第七一回：“忽见黑云一片，压住营垒，宛如覆盖。”

覆盖全国

指覆蔽在地面上的植物。

马烽《我的第一个上级》：“这九十个水量是正沟的水，南沟北沟山上覆盖多，水下来要慢一些，至少要差三个钟头。”

中英例句

醋量只够覆盖笔毛就可以了。

You'll only need enough vinegar to cover the bristles.

这个大陆覆盖了240万平方公里。

The continent covers about 24 million square kilometres.

目前超过7亿人覆盖在保障体系下，与此同时社会保障金也在逐年增长。

More than 700 million people are covered under the scheme, with social security payments rising as well.

与此同时，在地理覆盖范围方面，中国港口运营商依然不及其跨国竞争对手。

Meanwhile, though, chinese operators remain leagues away from global rivals in terms of geographic coverage.

篇6：方法重载和方法覆盖

方法重载和方法覆盖

重载与覆盖的区别【一】

1、方法的覆盖是子类和父类之间的关系，是垂直关系;方法的重载是同一个类中方法之间的关系，是水平关系。

2、覆盖只能由一个方法，或只能由一对方法产生关系;方法的重载是多个方法之间的关系。

3、覆盖要求参数列表相同;重载要求参数列表不同。

4、覆盖关系中，调用那个方法体，是根据对象的类型(对象对应存储空间类型)来决定;重载关系，是根据调用时的实参表与形参表来选择方法体的。

override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果;

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致;

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类;

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序(当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int));

2、不能通过访问权限、返回类型、抛出的异常进行重载;

3、方法的异常类型和数目不会对重载造成影响;

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果

class A {

protected int method1(int a, int b) { return 0; }

}

public class B extends A{

public int method1(int a, int b) { return 0; } //正确，重写父类方法，可以扩大访问权限

//private int method1(int a, int b) { return 0; } //错误，重写父类方法，不能降低了访问权限

//private long method1(int a, int b) { return 0; } //错误，重写父类方法，不能改变返回值类型

public short method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型

private int method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型

}

方法覆盖(overwrite)与方法重载(overload)详解【二】

方法重载(Overload)

有时候，类的同一种功能有多种实现方式，到底采用哪种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。

public void train(Dog dog){

//训练小狗站立、排队、做算术

…

}

public void train(Monkey monkey){

//训练小猴敬礼、翻筋斗、骑自行车

…

}

再例如某个类的一个功能是比较两个城市是否相同，一种方式是按两个城市的名字进行比较，另一种方式是按两个城市的名字，以及城市所在国家的名字进行比较。

public boolean isSameCity (String city1,String city2){

return city1.equals(city2);

}

public boolean isSameCity(String city1,String city2,String country1,String country2){

return isSameCity(city1, city2) && country1.equals(country2);

}

再例如java.lang.Math类的max()方法能够从两个数字中取出最大值，它有多种实现方式。

public static int max(int a,int b)

public static int max(long a,long b)

public static int max(float a,float b)

public static int max(double a,double b)

以下程序多次调用Math类的max()方法，运行时，Java虚拟机先判断给定参数的类型，然后决定到底执行哪个max()方法。

//参数均为int类型，因此执行max(int a,int b)方法

Math.max(1,2);

//参数均为float类型，因此执行max(float a,float b)方法

Math.max(1.0F, 2.0F);

//参数中有一个是double类型，自动把另一个参数2转换为double类型，

//执行max(double a,double b)方法

Math.max(1.0,2);

对于类的方法(包括从父类中继承的方法)，如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。

重载方法必须满足以下条件：

l 方法名相同。

l 方法的参数类型、个数、顺序至少有一项不相同。

l 方法的返回类型可以不相同。

l 方法的修饰符可以不相同。

在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的两个方法，Java虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型、个数和顺序。

例如以下Sample类中已经定义了一个amethod()方法。

public class Sample{

public void amethod(int i, String s){}

//加入其他方法

}

下面哪些方法可以加入到Sample类中，并且保证编译正确呢?

A)public void amethod(String s, int i){} (可以)

B)public int amethod(int i, String s){return 0;} (不可以)

C)private void amethod(int i, String mystring){} (不可以)

D)public void Amethod(int i, String s) {} (可以)

E)abstract void amethod(int i); (不可以)

选项A的amethod()方法的参数顺序和已有的不一样，所以能作为重载方法加入到Sample类中。

选项B和选项C的amethod()方法的参数签名和已有的一样，所以不能加入到Sample类中。对于选项C，尽管String类型的参数的名字和已有的不一样，但比较参数签名无须考虑参数的具体名字。

选项D的方法名为Amethod，与已有的不一样，所以能加入到Sample类中。

选项E的方法的参数数目和已有的不一样，因此是一种重载方法。但由于此处的Sample类不是抽象类，所以不能包含这个抽象方法。假如把Sample类改为抽象类，就能把这个方法加入到Sample类中了。

再例如，以下Sample类中已经定义了一个作为程序入口的main()方法。

abstract public class Sample{

public static void main( String[] s){}

//加入其他方法

}

下面哪些方法可以加入到Sample类中，并且保证编译正确呢?

A)abstract public void main(String s, int i); (可以)

B)public final static int main( String[] s){} (不可以)

C)private void main(int i, String mystring){} (可以)

D)public void main( String s) throws Exception{} (可以)

作为程序入口的main()方法也可以被重载。以上选项A、C和D都可以被加入到Sample类中。选项B与已有的main()方法有相同的方法签名，因此不允许再加入到Sample类中。

方法覆盖(Override)

假如有100个类，分别为Sub1，Sub2…Sub100，它们的一个共同行为是写字，除了Sub1类用脚写字外，其余的类都用手写字。可以抽象出一个父类Base，它有一个表示写字的方法write()，那么这个方法到底如何实现呢?从尽可能提高代码可重用性的角度看，write()方法应该采用适用于大多数子类的实现方式，这样就可以避免在大多数子类中重复定义write()方法。因此Base类的 write()方法的定义如下：

public void write(){ //Base类的write()方法

//用手写字

…

}

由于Sub1类的写字的实现方式与Base类不一样，因此在Sub1类中必须重新定义write()方法。

public void write(){ //Sub1类的write()方法

//用脚写字

…

}

如果在子类中定义的一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。

覆盖方法必须满足多种约束，下面分别介绍。

(1)子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致。例如以下代码将导致编译错误。

public class Base {

public void method() {…}

}

public class Sub extends Base{

public int method() { //编译错误，返回类型不一致

return 0;

}

Java编译器首先判断Sub类的method()方法与Base类的method()方法的参数签名，由于两者一致，因此Java编译器认为Sub类的method()方法试图覆盖父类的方法，既然如此，Sub类的method()方法就必须和被覆盖的方法具有相同的返回类型。

以下代码中子类覆盖了父类的一个方法，然后又定义了一个重载方法，这是合法的。

public class Base {

public void method() {…}

}

public class Sub extends Base {

public void method(){…} //覆盖Base类的method()方法

public int method(int a) { //重载method()方法

return 0;

}

(2)子类方法不能缩小父类方法的访问权限。例如以下代码中子类的method()方法是私有的，父类的method()方法是公共的，子类缩小了父类方法的访问权限，这是无效的方法覆盖，将导致编译错误。

public class Base {

public void method() {…}

}

public class Sub extends Base {

private void method() {…} //编译错误，子类方法缩小了父类方法的访问权限

}

为什么子类方法不允许缩小父类方法的访问权限呢?这是因为假如没有这个限制，将会与Java语言的多态机制发生冲突。例如对于以下代码：

Base base=new Sub(); //base变量被定义为Base类型，但引用Sub类的实例

base.method();

Java编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用base变量所引用的 Sub实例的method()方法，如果这个方法为private类型，Java虚拟机就无法访问它。所以为了避免这样的矛盾，Java语言不允许子类方法缩小父类中被覆盖方法的访问权限。本章第6.6节(多态)对多态做了进一步的阐述。

(3)子类方法不能抛出比父类方法更多的异常，关于异常的概念参见第9章(异常处理)。子类方法抛出的异常必须和父类方法抛出的异常相同，或者子类方法抛出的异常类是父类方法抛出的异常类的子类。

例如，假设异常类ExceptionSub1和ExceptionSub2是ExceptionBase类的子类，则以下的代码是合法的：

public class Base {

void method()throws ExceptionBase{}

}

public class Sub1 extends Base {

void method()throws ExceptionSub1{}

}

public class Sub2 extends Base {

void method()throws ExceptionSub1,ExceptionSub2{}

}

public class Sub3 extends Base {

void method()throws ExceptionBase{}

}

以下代码不合法：

public class Base {

void method() throws ExceptionSub1{ }

}

public class Sub1 extends Base {

void method()throws ExceptionBase {} //编译出错

}

public class Sub2 extends Base {

void method()throws ExceptionSub1,ExceptionSub2 {} //编译出错

}

为什么子类方法不允许抛出比父类方法更多的异常呢?这是因为假如没有这个限制，将会与Java语言的多态机制发生冲突。例如对于以下代码：

Base base=new Sub2(); //base变量被定义为Base类型，但引用Sub2类的实例

try{

base.method();

}catch(ExceptionSub1 e){ … } //仅仅捕获ExceptionSub1异常

Java编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用base变量所引用的 Sub2实例的method()方法。假如Sub2实例的method()方法抛出ExceptionSub2异常，由于该异常没有被捕获，将导致程序异常终止。

(4)方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被覆盖。

(5)父类的静态方法不能被子类覆盖为非静态方法。例如以下的'代码将导致编译错误：

public class Base {

public static void method() { }

}

public class Sub extends Base {

public void method() { } //编译出错

}

(6)子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法。在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束：方法的参数签名一致，返回类型一致，不能缩小父类方法的访问权限，不能抛出更多的异常。例如以下代码是合法的：

public class Base {

static int method(int a) throws BaseException{ return 0; }

}

public class Sub extends Base{

public static int method(int a) throws SubException { return 0; }

}

子类隐藏父类的静态方法和子类覆盖父类的实例方法，这两者的区别在于：运行时，Java虚拟机把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。下面举例来解释这一区别。在例程6-1中，Base类和它的子类即Sub类中都定义了实例方法method()和静态方法staticMethod()。

例程6-1 Sub.java

package hidestatic;

class Base{

void method(){ //实例方法

System.out.println(“method of Base”);

}

static void staticMethod(){ //静态方法

System.out.println(“static method of Base”);

}

public class Sub extends Base{

void method(){ //覆盖父类的实例方法method()

System.out.println(“method of Sub”);

}

static void staticMethod(){ //隐藏父类的静态方法staticMethod()

System.out.println(“static method of Sub”);

}

public static void main(String args[]){

Base sub1=new Sub(); //sub1变量被声明为Base类型，引用Sub实例

sub1.method(); //打印 method of Sub

sub1.staticMethod(); //打印 static method of Base

Sub sub2=new Sub(); //sub2变量被声明为Sub类型，引用Sub实例

sub2.method(); //打印 method of Sub

sub2.staticMethod(); //打印 static method of Sub

}

运行Sub类的main()方法，程序将输出：

method of Sub

static method of Base

method of Sub

static method of Sub

引用变量sub1和sub2都引用Sub类的实例，Java虚拟机在执行sub1.method()和sub2.method()时，都调用Sub实例的method()方法，此时父类Base的实例方法method()被子类覆盖。

引用变量sub1被声明为Base类型，Java虚拟机在执行sub1. staticMethod()时，调用Base类的staticMethod()方法，可见父类Base的静态方法staticMehtod()不能被子类覆盖。

引用变量sub2被声明为Sub类型，Java虚拟机在执行sub2. staticMethod()时，调用Sub类的staticMethod()方法，Base类的staticMehtod()方法被Sub类的staticMehtod()方法隐藏。

(7)父类的非静态方法不能被子类覆盖为静态方法。例如以下代码是不合法的：

public class Base {

void method() { }

}

public class Sub extends Base {

static void method() { } //编译出错

}

(8)父类的私有方法不能被子类覆盖。例如在例程6-2中，子类Sub中定义了一个和父类Base中的方法同名、参数签名和返回类型一致，但访问权限不一致的方法showMe()，父类中showMe()的访问权限为private，而子类中showMe()的访问权限为public。尽管这在形式上和覆盖很相似，但Java虚拟机对此有不同的处理机制。子类方法覆盖父类方法的前提是，子类必须能继承父类的特定方法，由于Base类的private类型的showMe()方法不能被Sub类继承，因此Base类的showMe()方法和Sub类的showMe()方法之间并没有覆盖关系。

例程6-2 Sub.java

package privatetest;

class Base {

private String showMe() {

return “Base”;

}

public void print(){

System.out.println(showMe()); //到底调用Base类的showMe()还是Sub类的showMe()?

}

public class Sub extends Base {

public String showMe(){

return “Sub”;

}

public static void main(String args[]){

Sub sub=new Sub();

sub.print();

}

执行以上Sub类的main()方法，会打印出结果“Base”，这是因为print()方法在Base类中定义，因此print()方法会调用在Base类中定义的private类型的showMe()方法。

但是如果把Base类的showMe()方法改为public类型，其他代码不变：

public class Base {

public String showMe() {

return “Base”;

}

…

}

再执行以上Sub类的main()方法的代码，会打印出结果“Sub”，这是因为此时Sub类的showMe()方法覆盖了Base类的showMe()方法。因此尽管print()方法在Base类中定义，Java虚拟机还是会调用当前Sub实例的showMe() 方法。

(9)父类的抽象方法可以被子类通过两种途径覆盖：一是子类实现父类的抽象方法;二是子类重新声明父类的抽象方法。例如以下代码合法：

public abstract class Base {

abstract void method1();

abstract void method2();

}

public abstract class Sub extends Base {

public void method1(){…} //实现method1()方法，并且扩大访问权限

public abstract void method2(); //重新声明method2()方法，仅仅扩大访问权限，但不实现

Tips

狭义的理解，覆盖仅指子类覆盖父类的具体方法，即非抽象方法，在父类中提供了方法的默认实现方式，而子类采用不同的实现方式。在本书中，为了叙述方便，把子类实现父类的抽象方法也看做方法覆盖。

例如以下代码不合法：

public abstract class Base {

abstract void method1();

abstract void method2();

}

public abstract class Sub extends Base {

private void method1(){…} //编译出错，不能缩小访问权限

private abstract void method2(); //编译出错，不能缩小访问权限

}

(10)父类的非抽象方法可以被覆盖为抽象方法。例如以下代码合法：

public class Base {

void method(){ }

}

public abstract class Sub extends Base {

public abstract void method(); //合法

}

图6-2 Sub类继承Base类

在本书提供的UML类框图中，在子类中只会显示子类特有的方法及覆盖父类的方法，而不会显示直接从父类中继承的方法。例如，图6-2表明Base类是抽象类(Base名字用斜体字表示)，method1()为抽象方法(method1名字用斜体字表示)，method2()和method3()为具体方法。Sub类是Base类的子类，Sub类实现了Base类的method1()方法，覆盖了 Base类的method2()方法，直接继承Base类的method3()方法，此外Sub类还有自己的method4()方法。

方法覆盖与方法重载的异同

方法覆盖和方法重载具有以下相同点：

·都要求方法同名。

·都可以用于抽象方法和非抽象方法之间。

·方法覆盖和方法重载具有以下不同点：

·方法覆盖要求参数签名必须一致，而方法重载要求参数签名必须不一致。

· 方法覆盖要求返回类型必须一致，而方法重载对此不做限制。

·方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类的所有方法(包括从父类中继承而来的方法)。

·方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。

·父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。

以下子类Sub覆盖了父类Base的method(int v)方法，并且提供了多种重载方法。

public class Base{