「java重写要求」java的重写方法
今天给各位分享java重写要求的知识，其中也会对java的重写方法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java中什么是重写的语法规则？
- 2、java方法的重写
- 3、java什么是方法重写的语法规则？
- 4、JAVA中子类重写父类的方法，怎么写，什么要求
- 5、Java 重写与重载方法与区别详解
- 6、北大青鸟java培训：Java重载和重写？
java中什么是重写的语法规则？
重写的方法与父类方法签名(方法名称和参数列表)相同；
子类重写的方法访问修饰符范围不能低于父类；
父类的私有方法不能被重写；
static修饰的方法不能被重写
返回值类型：
如果父类中方法返回值类型是八大基本类型、String和void，则必须相同；
如果是其他引用类型，则重写方法中返回值类型相同或其父类返回类型的子类。
关于异常，子类重写方法异常范围要小于父类方法异常或没有异常。
java方法的重写
下面将分别讲解重载与重写：
1、重载overloading
1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载是一个类中多态性的一种表现。
2) Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
3) 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
示例代码：
public class Dog {
Dog()
{
this.bark();
}
void bark()//bark()方法是重载方法
{
System.out.println("no barking!");
this.bark("female", 3.4);
}
void bark(String m,double l)//注意：重载的方法的返回值都是一样的，
{
System.out.println("a barking dog!");
this.bark(5, "China");
}
void bark(int a,String n)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
{
System.out.println("a howling dog");
}
public static void main(String[] args)
{
Dog dog = new Dog();
//dog.bark();
//dog.bark("male", "yellow");
//dog.bark(5, "China");
}
}
2、重写overriding
1) 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
2) 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
3) 子类函数的访问修饰权限不能少于父类的；
示例代码：
public class Base
{
void test(int i)
{
System.out.print(i);
}
void test(byte b)
{
System.out.print(b);
}
}
public class TestOverriding extends Base
{
void test(int i)
{
i++;
System.out.println(i);
}
public static void main(String[]agrs)
{
Base b=new TestOverriding();
b.test(0)
b.test((byte)0)
}
}
这时的输出结果是1 0，这是运行时动态绑定的结果。
java什么是方法重写的语法规则？
一、方法的重写。
1、重写只能出现在继承关系之中。当一个类继承它的父类方法时，都有机会重写该父类的方法。一个特例是父类的方法被标识为final。重写的主要优点是能够定义某个子类型特有的行为。
class Animal {
public void
eat(){
System.out.println ("Animal is eating.");
}
}
class Horse extends Animal{
public void eat(){
System.out.println ("Horse is
eating.");
}
}
2、对于从父类继承来的抽象方法，要么在子类用重写的方式设计该方法，要么把子类也标识为抽象的。所以抽象方法可以说是必须要被重写的方法。
3、重写的意义。
重写方法可以实现多态，用父类的引用来操纵子类对象，但是在实际运行中对象将运行其自己特有的方法。
public class Test {
public static
void main (String[] args) {
Animal h = new Horse();
h.eat();
}
}
class Animal {
public void eat(){
System.out.println ("Animal is
eating.");
}
}
class Horse extends
Animal{
public void
eat(){
System.out.println ("Horse is eating.");
}
public void
buck(){
}
}
一个原则是：使用了什么引用，编译器就会只调用引用类所拥有的方法。如果调用子类特有的方法，如上例的h.buck();
编译器会抱怨的。也就是说，编译器只看引用类型，而不是对象类型。
4、重写方法的规则。
若想实现一个合格重写方法，而不是重载，那么必须同时满足下面的要求！
重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。
（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。）
比如：Object类有个toString()方法，开始重写这个方法的时候我们总容易忘记public修饰符，编译器当然不会放过任何教训我们的机会。出错的原因就是：没有加任何访问修饰符的方法具有包访问权限，包访问权限比public当然要严格了，所以编译器会报错的。
重写规则之二：参数列表必须与被重写方法的相同。
重写有个孪生的弟弟叫重载，也就是后面要出场的。如果子类方法的参数与父类对应的方法不同，那么就是你认错人了，那是重载，不是重写。
重写规则之三：返回类型必须与被重写方法的返回类型相同。
父类方法A：void
eat(){} 子类方法B：int eat(){} 两者虽然参数相同，可是返回类型不同，所以不是重写。
父类方法A：int
eat(){} 子类方法B：long eat(){}
返回类型虽然兼容父类，但是不同就是不同，所以不是重写。
重写规则之四：重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。
例：
import java.io.*;
public class Test
{
public static void main (String[]
args) {
Animal h =
new Horse();
try
{
h.eat();
}
catch (Exception e) {
}
}
}
class Animal
{
public void eat() throws
Exception{
System.out.println ("Animal is eating.");
throw new
Exception();
}
}
class Horse extends
Animal{
public void eat() throws
IOException{
System.out.println ("Horse is eating.");
throw new
IOException();
}
}
这个例子中，父类抛出了检查异常Exception，子类抛出的IOException是Exception的子类，也即是比被重写的方法抛出了更有限的异常，这是可以的。如果反过来，父类抛出IOException，子类抛出更为宽泛的Exception，那么不会通过编译的。
注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类不再这个限制之中。
重写规则之五：不能重写被标识为final的方法。
重写规则之六：如果一个方法不能被继承，则不能重写它。
比较典型的就是父类的private方法。下例会产生一个有趣的现象。
public class Test {
public static
void main (String[] args) {
//Animal h = new Horse();
Horse h = new
Horse();
h.eat();
}
}
class Animal {
private void eat(){
System.out.println ("Animal is
eating.");
}
}
class Horse extends
Animal{
public void
eat(){
System.out.println ("Horse is eating.");
}
}
这段代码是能通过编译的。表面上看来违反了第六条规则，但实际上那是一点巧合。Animal类的eat()方法不能被继承，因此Horse类中的eat()方法是一个全新的方法，不是重写也不是重载，只是一个只属于Horse类的全新的方法！这点让很多人迷惑了，但是也不是那么难以理解。
main()方法如果是这样：
Animal h = new Horse();
//Horse h = new
Horse();
h.eat();
编译器会报错，为什么呢？Horse类的eat()方法是public的啊！应该可以调用啊！请牢记，多态只看父类引用的方法，而不看子类对象的方法！
JAVA中子类重写父类的方法，怎么写，什么要求
1.父类的方法不能降级，同级的话就要覆盖，例如public方法不能在子类中被声明为protected或者private（子类重载除外），否则会有
Cannot reduce the visibility of the inherited method from Father的编译错误。
2.父类的方法可以任意升级，但升级只有两种方式，要么覆盖，要么重载，覆盖就是方法体完全一样，重载则是参数必须改变，方法名称不变。
import java.lang.reflect.Method;
class Father{
int a;
protected int b = 5;
protected void funcpro(){
//父类的保护方法，子类能够访问，但子类自身没有
System.out.println("father funcpro");
}
public void funcpub(){
//父类公有方法，子类直接继承
}
private void funcpri(){
//父类私有方法，子类不可见
}
}
public class TestOveride extends Father {
/**
* @param args
*/
//父类保护方法的重写
// public void funcpro(){
// //子类自己可以这样定义，将会覆盖父类protected方法
// System.out.println("子类的func方法");
// }
// protected void funcpro(){
// //ok
//}
// public short funcpro(){
// //illegal 父类的protected和public方法在子类中是可见的，试想一下，如果编译器认为这个方法体正确，
//那么子类调用funcpro的时候究竟调用哪个呢？这样没有能构成重载
// }
// private void funcpro(){
// //illegal
// }
private void funcpro(int a){
//这是方法重载，不会报错
System.out.println("sun funcpro");
}
//父类公有方法的重写
// private void funcpub(){
// //illegal：Cannot reduce the visibility of the inherited method from Father
// }
// protected void funcpub(){
// //illegal Cannot reduce the visibility of the inherited method from Father
// }
// public void funcpub(){
// //ok
// }
// public int funcpub(){
// //illegal 和父类的返回值不匹配
// }
// public int funcpub(int i){
// //ok 子类构成重载
// return 1;
// }
//父类私有方法的重写
// public void funcpri(){
// //ok
// }
// protected void funcpri(){
// //ok
// }
// private void funcpri(){
// //ok
// }
public static void main(String[] args) {
// TODO Auto-generated method stub
TestOveride testOveride = new TestOveride();
Class class1 = testOveride.getClass();
try {
Method[] methods = class1.getMethods();
System.out.println("子类中的所有方法："); //可以看到，并没有父类的funcpro方法
for(Method m:methods){
System.out.println(m);
}
System.out.println("子类调用父类的protected 方法：");
testOveride.funcpro();
System.out.println("子类调用自己的func方法：");
testOveride.funcpro(1);
System.out.println("子类调用父类的字段");
System.out.println(testOveride.b);
}catch(Exception e){
e.printStackTrace();
}
}
}
Java 重写与重载方法与区别详解
重写：父类的方法不能满足子类的要求时，子类可以选择重写父类的方法。
重写要求：方法名必须相同，参数列表相同，返回值类型相同或者是其的子集，访问权限不能缩小，不能抛出父类没有抛出的一般异常，final修饰的父类方法不能重写。
重载：一个类可以有同名不同形参的方法，不同参数可以是不同的数据类型，不同顺序，不同的数量。（无参和有参构造器就是重载）。
北大青鸟java培训：Java重载和重写？
（1）方法重载是让类以统一的方式处理不同类型数据的一种手段。
多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。
（2）java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法,这就是多态性。
（3）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。
无法以返回型别作为重载函数的区分标准。
下面是重载的例子： packagec04.answer;//这是包名 //这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。
不同的重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
packagec04.answer; publicclassDog{ Dog() { this.bark(); } voidbark()//bark()方法是重载方法 { System.out.println(\"nobarking!\"); this.bark(\"female\",3.4); } voidbark(Stringm,doublel)//注意：重载的方法的返回值都是一样的， { System.out.println(\"abarkingdog!\"); this.bark(5,\"China\"); } voidbark(inta,Stringn)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分 { System.out.println(\"ahowlingdog\"); } publicstaticvoidmain(String[]args) { Dogdog=newDog(); //dog.bark();[Page] //dog.bark(\"male\",\"yellow\"); //dog.bark(5,\"China\");然后我们再来谈谈重写（Overriding）（1）父类与子类之间的多态性，对父类的函数进行重新定义。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。
在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
（3）子类函数的访问修饰权限不能少于父类的； 下面是重写的例子：概念：即调用对象方法的机制。
动态绑定的内幕：1、编译器检查对象声明的类型和方法名，从而获取所有候选方法。
试着把上例Base类的test注释掉，这时再编译就无法通过。
2、重载决策：编译器检查方法调用的参数类型，从上述候选方法选出唯一的那一个（其间会有隐含类型转化）。
如果编译器找到多于一个或者没找到，此时编译器就会报错。
试着把上例Base类的test(byteb)注释掉，这时运行结果是11。
3、若方法类型为priavtestaticfinal，java采用静态编译，编译器会准确知道该调用哪个方法。
4、当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用对象的实际类型相匹配的方法版本。
在例子中，重庆java课程发现b所指向的实际类型是TestOverriding，所以b.test(0)调用子类的test。
但是，子类并没有重写test(byteb)，所以b.test((byte)0)调用的是父类的test(byteb)。
如果把父类的(byteb)注释掉，则通过第二步隐含类型转化为int,最终调用的是子类的test(inti)。
java重写要求的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java的重写方法、java重写要求的信息别忘了在本站进行查找喔。
发布于：2022-12-17，除非注明，否则均为原创文章，转载请注明出处。