下次自动登录
现在的位置:
& 综合 & 正文
java重载与重写（覆盖）
转载自：http://blog.163.com/sunflower123_happy/blog/static/0/
有时候，类的同一种功能有多种实现方式，到底采用那种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。
public void train (Dog dog){
//训练小狗站立，排队，做算数
public void train(Monkey monkey){
//训练猴子骑自行车等
再如某个类的一个功能是比较两个城市是否相同，一种方式是比较两个城市的名字，一种是除了比较两个城市的名字外，还要比较所在国家的名字。
publi boolean isSameCity (String city1,String city2){
return city1.equals(city2);
public boolean isSameCity(String city1,String city2,Stirng 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)
以下程序多次调用Math 类的max() 方法，运行时，Java 虚拟机先判断给定参数的类型，然后决定到底执行哪个 max()方法。
// 参数为 int 类型，因此执行max（int a, int b）方法
Math.max(1,2);
//参数为 flloat 类型，因此执行 max(float a, float b) 方法
Math.max(1.0F,2.9F);
对于类的方法（包括从父类中继承的方法）如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。
重载方法满足以下条件
方法名相同
方法的参数类型，个数，顺序至少有一项不相同
方法的返回类型可以不相同
方法的修饰符可以不相同
在一个类中不允许定义另个方法名相同，并且参数签名也完全相同的方法。假如存在这样的两个方法，Java 虚拟机 在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型，个数和顺序。
例如 ：public class Sample {
public void amethod(int i,String s){} }
下面哪个方法可以加入到 Sample 类中去？
public void amethod(String s,int i)
public int amethod(int i,String s){return 0}
//不行，参数签名和类中方法一样
public void amethod(int i,String myString){} //NO
//不行，参数签名和类中方法一样
public void Amethod (int i,Sting s){} //
//可以，因为 Amethod 和amethod 是两个不同的方法名称。
abstract void amethod( int i);
尽管它的参数列和类中方法参数不一样，但是，此处的Sample 类不是抽象类，所以不能包括这个抽象方法。假如把Sample 类改为抽象类，就能把这个方法加入到 Sample 类中了。
public boolean compareCity(String city1,String city2){
return city1.equals(city2);
public int compareCity(String city1,String city2){
if(city1.equals(city2)){
编译错误：compareCity(java.lang.String,java.lang.String) is already defined
// compareCity(String ,String ) 方法已经被定义过
作为程序的入口 main（）方法也可以被重载。
public static void main(String args[]){
public void main(String s,int i){}
private void main(int i,String myString []){}
public void main(String s)throws Exception{}
public final static int main(String args[]){}
它已经和已有的 main （）方法有相同的签名，因此不允许再加到这个类中来。
main(java.lang.String []) is already defined in Sample
假如有100个类，分别是 Sub1,Sub2,Sub3…….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};// 编译错误
method() in Simon.Sub cannot overrid method() in Simon.B
attempting to use incompatible return type
在Simon 包 Sub 中的方法不不能重写（覆盖） 在 Simon 包 Base类中的方法
试图用不匹配的返回类型
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 mehod(int a){………return 0.}
//重载method 方法
2) 子类方法不能缩小父类方法的访问权限。例如以下代码中子类的 method() 方法是私用的，父类的 method（）方法是公共的，子类缩小了 父类方法的访问权限，这是无效的方法覆盖，将导致编译错误。
public class Base{
public void method(){…………..}
public class Sub extends Base{
private void method(){……….}//覆盖 Base 类的method 方法,但是缩小了 父类方法访问权限
method() in Simon.Sub cannot override method() in Simon.B
attempting to assign weake
was public
Simon 包中 的 Sub 类 method()不能重写、覆盖 Simon 包中Base类的 method()方法。
试图分配一个更弱的访问权限
原来是 public (现在却是 private)
为什么子类方法不允许缩小父类方法的访问权限呢？这时因为假如没有这个限制，将于Java 语言的多态机制发生冲突。
Base base = new Sub() ;//base 变量被定义为Base 类型，但引用 Sub 的实例。
base.method();
Java 编译器认为以上是合法的代码，但是在运行时，根据动态绑定规则，Java 虚拟机会调用base 变量所引用的Sub 实例的 method（）方法，如果这个方法为 private 类型，Java 虚拟机就没有办法访问它.所以为了避免这样的矛盾，Java 语言不允许子类方法缩小父类中被覆盖方法的权限。
3）子类方法不能抛出比父类方法更多的异常。
子类方法抛出的异常必须和父类方法抛出的异常相同，或者子类方法抛出的异常类是父类抛出的异常类的子类。
假设异常类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 methos () 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 的实例。
base.method();
}catch(ExceptionSub1 e){……..}
//仅仅描述ExceptionSub1 异常
Java 编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用 base 变量所引用的Sub2 实例的 method() 方法。
假如 Sub2 实例的 method（） 方法抛出 ExceptionSub2 异常，由于该异常没有被捕获，将导致程序异常终止。
4）方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中方法只能被重载，不能被覆盖。
【上篇】【下篇】在类继承中，子类可以修改从父类继承来的方法，也就是说子类能创建一个与父类方法有不同功能的方法，但具有相同的名称、返回值类型、参数列表。
如果在新类中定义一个方法，其名称、返回值类型和参数列表正好与父类中的相同，那么，新方法被称做覆盖旧方法。
参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。
被覆盖的方法在子类中只能通过super调用。
注意：覆盖不会删除父类中的方法，而是对子类的实例隐藏，暂时不使用。请看下面的例子：
public class Demo{
public static void main(String[] args) {
Dog myDog = new Dog("花花");
myDog.say();
Animal myAnmial = new Animal("贝贝");
myAnmial.say();
}}class Animal{
String name;
public Animal(String name){
this.name = name;
public void say(){
System.out.println("我是一只小动物，我的名字叫" + name + "，我会发出叫声");
}}class Dog extends Animal{
public Dog(String name){
super(name);
public void say(){
System.out.println("我是一只小狗，我的名字叫" + name + "，我会发出汪汪的叫声");
运行结果：
我是一只小狗，我的名字叫花花，我会发出汪汪的叫声
我是一只小动物，我的名字叫贝贝，我会发出叫声方法覆盖的原则：
覆盖方法的返回类型、方法名称、参数列表必须与原方法的相同。覆盖方法不能比原方法访问性差（即访问权限不允许缩小）。覆盖方法不能比原方法抛出更多的异常。被覆盖的方法不能是final类型，因为final修饰的方法是无法覆盖的。被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。被覆盖的方法不能为static。如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误；反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。方法的重载：
前面已经对进行了说明，这里再强调一下，Java父类和子类中的方法都会参与重载，例如，父类中有一个方法是 func(){ ... }，子类中有一个方法是 func(int i){ ... }，就构成了方法的重载。覆盖和重载的不同：
方法覆盖要求参数列表必须一致，而方法重载要求参数列表必须不一致。方法覆盖要求返回类型必须一致，方法重载对此没有要求。方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类中的所有方法（包括从父类中继承而来的方法）。方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。父类的一个方法只能被子类覆盖一次，而一个方法可以在所有的类中可以被重载多次。
原文地址：http://www.weixueyuan.net/view/5999.html
Java方法继承、方法重载、方法覆盖小总结
1、方法继承：利用extends关键字一个方法继承另一个方法，而且只能直接继承一个类。
在同一个包时继承类中的public/protected/默认级别的变量和方法在不同包时继承public...
JAVA思想：继承的方法覆盖的作用
在继承后，如果子类和父类中有同名的方法，子类调用同名的方法后，调用的是子类自己的方法，这就叫做覆盖。
当我们开发时，原有的父类---A类功能已经不够强了，我们需要对他进行功能修改，但又不能改动他的代...
Java之调用被子类重载的方法
有一种特殊的重写方法，就是当子类重写父类方法，父类表面上只是调用属于自己的、被子类重写的方法，但随着contex的执行改变，将会变成父类直接调用子类的方法。
public class Animal...
java类的继承中方法的覆盖与重载
java类的继承中方法的覆盖与重载
我们都知道，java中类是可以继承的，而在继承中方法是可以覆盖或者重载的。以前一直在纠结什么时候是覆盖，而什么时候又是重写，知道前几天，终于把一些搞通。
一 方法重载介绍如果一个类中包含了两个或两个以个以上的方法名相同，但形参列表不同，则称为方法重载。
二 方法重载应用1 代码示例
public class Overload
方法的覆盖
什么是方法的覆盖（Overridden Methods）
在类继承中，子类可以修改从父类继承来的行为，也就是说子类能创建一个与父类方法有不同功能的方法，但具有相同的：名称、返回类型、参...
*详细原因:
交 &em&Java方法继承&/em&、&em&方法重载&/em&、&em&方法&/em&覆盖总结 3积分 立即下载 ...
继承(inheritance)
简单的说，继承就是在一个现有类型的基础上，通过增加新的方法或者重定义已有方法（下面会讲到，这种方式叫重写）的方式，产生一个新的类型。继承是面向对象的三个基本特征--封...
JAVA基础再回首（六）——父与子的继承、super关键字、方法重写、方法重载
不墨迹，才是时间管理的最大利器,学无止境。
首先我们来学习继承的概述多个类中存在相同属性和行为时，将这些内...
没有更多推荐了，java 属性方法重写覆盖
[问题点数：25分，结帖人u]
本版专家分：0
结帖率 100%
CSDN今日推荐
本版专家分：0
本版专家分：40
本版专家分：8391
2015年5月 Java大版内专家分月排行榜第一
2015年7月 Java大版内专家分月排行榜第二2015年4月 Java大版内专家分月排行榜第二
2015年3月 Java大版内专家分月排行榜第三
本版专家分：682
本版专家分：0
本版专家分：0
本版专家分：149
本版专家分：25
本版专家分：1
本版专家分：357
本版专家分：3268
本版专家分：1285
本版专家分：357
本版专家分：33
本版专家分：2717
匿名用户不能发表回复！
其他相关推荐
使用重写优化电子宠物系统需求说明：按照方法的重写或方法的覆盖的注意事项：
（1）子类根据需求对从父类继承的方法进行重新编写；
（2）重写时，可以用super.方法的方式来保留父类的方法；
（3）构造方法不能被重写；回顾之前使用继承实现的电子宠物系统，请使用方法的重写或覆盖优化现有代码，重写宠物类的宠物自白方法，在不同类型的宠物进行自白时，介绍其不同的特性，如：狗狗的自白需要介绍其品种、企
首先，重写等于覆盖，常发生于父类与子类之间的变量和方法之间。
1.子类中方法与父类方法具有相同的返回值类型；
子类声明返回的类型也可以是父类声明返回类型的子类
2.子类中方法与父类中方法有相同的方法签名；
3.子类中方法的访问权限不能小于父类方法的访问权限；
4.子类方法不能抛出新的异常类型；
5.子类方法可以同时声明抛出多个父类方法声明抛出异常类的子类（RuntimeEexception除外）
方法签名：方
在C#中改变类中相同名称的方法的实现过程中有三种方式：重载，重写和覆盖。
首先重载是指具有相同的方法名，通过改变参数的个数或者参数类型实现同名方法的不同实现。
重写则是只在继承中，子类通过override关键字修饰方法，实现父类和子类相同方法的不同实现，注意，父类方法必须是用virtual或者abstract关键字修饰的虚方法或者抽象方法，例如：
重写/覆盖：
父类与子类之间的多态性，对父类的函数进行重定义。
在子类中定义某种方法与其父类中的某一方法具有相同的名称和参数，我们就说该方法被重写或者覆盖了。
判断重写：
参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
返回的类型必须一直与被重写的方法的返回类型相同。
访问修饰符的限制一定要大于被重写方法的访问修饰符。
重写方法只能存在于具有继承关系
一、方法的重写：
1.子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法重写(复写);
2.重写的格式：
1).返回值类型
方法名 ,形参列表：必须完全一致；
A.&返回值类型&和&方法名&相同，&参数列表&不同：编译通过。类似于&重载&，子类定义了一个自己的方法
B.&方法名&和&参数列表&相同，&返回值类型&不同：编译错误。如果&方法名&和&形参列表&相同，要求&返回
Java中方法的重写(override)public class Parent{
public void ou tput()throws NullPointerException{
System.out.println(&parent&);
}}public class Child extends Parent{
public void outpu...
今天在牛客碰到这样一道题：
public A foo() {
class B extends A {
public A foo() {
class C extends B
//这样填写什么代码不会报错
选项分别是：
A.public void foo(){}
(一)重写和覆盖：重写:
在声明时，父类的方法前面加上virtual关键字，子类的方法前面加上override关键字，且与父类方法同名，表示父类的方法可以被子类进行修改和重新定义。
在声明子类方法的时候，添加new关键字，定义与父类同名的方法，称为覆盖。
当用子类创建父类的时候，重写调用的是子类中的功能，而覆盖调用的仍然是父类的功能。用子类创建子类和用父类创建父类的时候，则
方法覆盖原则方法的覆盖（override）两同两小一大原则：（重写、覆盖）方法名相同，参数列表（参数类型，参数个数，参数顺序）相同
子类返回类型小于等于父类方法返回类型
子类抛出异常小于等于父类方法抛出异常
子类访问权限大于等于父类方法访问权限
为什么不能降低可见性，因为每个子类的实例都应该是一个基类的有效实例，如果降低了方法的可见性，那么就相当于子类失去了一个父类的方法，这博客分类：
先看一段代码
public class MethoDemo01{
public static void main(String args[]){
int one = addOne(10,20) ;
// 调用整型的加法操作
float two = addTwo(10.3f,13.3f) ; // 调用浮点数的加法操作
System.out.println("addOne的计算结果：" + one) ;
System.out.println("addTwo的计算结果：" + two) ;
// 定义方法，完成两个数字的相加操作，方法返回一个int型数据
public static int addOne(int x,int y){
int temp = 0 ;
// 方法中的参数，是局部变量
temp = x +
// 执行加法计算
// 返回计算结果
// 定义方法，完成两个数字的相加操作，方法的返回值是一个float型数据
public static float addTwo(float x,float y){
float temp = 0 ;
// 方法中的参数，是局部变量
temp = x +
// 执行加法操作
// 返回计算结果
从上面的代码可以看出同样是完成加法的操作，但是方法名称并不是很明确，例如 addOne()和addTwo()实际上就是两个同类型的方法，应该都统一成add()方法才对，为了解决这种问题Java导入了方法重载的概念。所谓的方法重载就是方法名相同，但参数的类型和参数的个数不同。通过传递参数的类型不同和参数个数的不同完成不同功能的方法调用。如下代码：
public class MethoDemo02{
public static void main(String args[]){
int one = add(10,20) ;
// 调用整型的加法操作
float two = add(10.3f,13.3f) ; // 调用浮点数的加法操作
int three = add(10,20,30) ; // 调用有三个参数的加法操作
System.out.println("add(int x,int y)的计算结果：" + one) ;
System.out.println("add(float x,float y)的计算结果：" + two) ;
System.out.println("(int x,int y,int z)的计算结果：" + three) ;
// 定义方法，完成两个数字的相加操作，方法返回一个int型数据
public static int add(int x,int y){
int temp = 0 ;
// 方法中的参数，是局部变量
temp = x +
// 执行加法计算
// 返回计算结果
public static int add(int x,int y,int z){
int temp = 0 ;
// 方法中的参数，是局部变量
temp = x + y +
// 执行加法计算
// 返回计算结果
// 定义方法，完成两个数字的相加操作，方法的返回值是一个float型数据
public static float add(float x,float y){
float temp = 0 ;
// 方法中的参数，是局部变量
temp = x +
// 执行加法操作
// 返回计算结果
从程序中发现add()方法被重载了3次，而且每次重载是的参数类型或个数都有不同。
System.out.println();方法也属于方法重载。
System.out.println(3);//输出整数
System.out.println(33.3);//输出浮点数
System.out.println("33");//输出字符串
System.out.println(true);//输出布尔型
从发现程序可以打印数字，小数，字符，布尔等数据，也就是说println()方法被重载了。
重载的注意事项：
方法重载一定是在参数类型或者参数个数上的不同，下面的代码就不是方法重载：
范例：错误的方法重载
public static float add(int x, int y){//返回float类型，但是参数的类型及个数一致
float temp = 0;
temp = x +
return x+y;
public static int add(int x, int y){//返回int类型，但是参数的类型及个数一致
int temp = 0;
temp = x +
return x+y;
从上面的程序可以看出，方法的接受参数类型和个数完全一致，但是方法的返回类型值不一样，所以不是方法重载。
再次强调：方法重载只和方法接收参数的类型以及接收参数的个数有关 和方法的返回值类型无关。
stephenwang1011
浏览: 25676 次
一言以蔽之：&& 与& 安慰与
温故基础 不错
楼主开头写的第二句话应该是这样的吧：区别是&& ...
对的，就是这样的！
有意思哦，以前都没注意~
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
我们的作业要写一个web宠物医院管理系统，因为医生、客户等都包含浏览、添加、删除操作，所以对于service层，我希望有个统一的接口以供servlet中的类使用。
开始我是这样定义的：
public interface ServiceManager&T extends PetHospital& {
boolean addOne(T arg);
boolean deleteOne(int id);
List&T& list(int page);
这样删除和浏览都没有问题，但是addOne(T arg)方法会造成在servlet层的类需要创建Hippiater等bean层里面声明的类，感觉这样做好像不太符合分层的设计，但是对于医生、客户、宠物等不同对象需要的参数是不一样的，我该怎么设计addOne方法来保证servlet层调用时只需要传这些对象需要的参数，而不是这些对象。
可能描述的不清楚，再解释一下：
我希望在接口里还是要声明addOne方法，但是能够接收不同参数（个数、类型都不一定），这样在service层还是可以优雅的实现这个接口。
对象及其属性包含的内容如下：
class Hippiater {
//primary key
private S//姓名
private int workA//医龄
private S//技能专长
class Customer {
//primary key
private S//姓名
class Pet {
//primary key
private int masterId; //所属客户id
private S //品种
private S //名字
class Record {
//primary key
private int petId; //宠物ID
private long recordT //病历创建日期
private String diseaseD //病情描述
目录结构如下：
+- service
上面的几个类在bean目录下，ServiceManager接口位于service目录下，为web目录下的类提供服务。但我觉得应该不能让web下的类去操作bean目录下的类的实例，而应该提供其所需参数，交给service去处理所有我的问题就是怎么设计我的ServiceManager接口来满足这个需求
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
先说一下你的几个问题
你使用一个类型参数T继承PetHospital，T的类型可能是Hippiater，Customer，Pet等。这种继承方法违反了继承的“is－A”语义，试想一下一个customer或者一个pet是一个PetHospital吗？
web曾当然可以了解bean层的对象，因为你web层的参数一般是来自于表单，那自然必须知道这个表单是为了添加什么对象的。在struts或者spring中的controller都是直接使用并且把form参数封装成bean层的对象的。
delete方法只接受一个id，那怎么知道需要删除的是什么对象？是一个customer？还是一个pet？如果这两者有相同的id？
如果一定要用范型，参考下面代码
public class Entity {
//omit getter and setter
public class Pet extends Entity{
public interface EntitiyService&T extends Entity& {
boolean addOne(T arg);
boolean deleteOne(int id);
List&T& list(int page);
public class EntityServiceImpl&T extends Entity& implements EntitiyService&T& {
public boolean addOne(T arg) {
System.out.println("save entity " + arg.toString());
public boolean deleteOne(int id) {
System.out.println("delete entity which type is T");
public List&T& list(int page) {
System.out.println("query first " + page + " pages result");
public class Client {
public static void main(String[] args) {
Pet petFromForm = new Pet();
EntityServiceImpl&Pet& entityService = new EntityServiceImpl&&();
entityService.addOne(petFromForm);
entityService.deleteOne(1);
entityService.list(3);
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。