正文
java方法重写代码 java compareto方法重写
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java怎么在run方法中重写repaint方法（代码如下）
在类外面写这个方法就能调用java方法重写代码了java方法重写代码：public void repaint() { frame.repaint(); }
相关问答
Q1: java中的方法重写举例？
方法重写就是子类的方法覆盖了父类的方法，即子类的方法名和父类的方法名相同
class People
{
protected double weight,height;
public void speakHello()
{
System.out.println("yayawawa");
}
public void averageHeight()
{
height=173;
System.out.println("average height:"+height);
}
public void averageWeight()
{
weight=70;
System.out.println("average weight:"+weight);
}
}
class ChinaPeople extends People
{
//代码1//重写public void speakHello()方法
// 要求输出类似“你好，吃饭了吗”这样的汉语信息
public void speakHello()
{
System.out.println("你好，吃饭了吗");
}
//代码2//重写public void averageHeight()方法
//要求输出类似“中国人的平均身高：173.0厘米”这样的汉语信息
public void averageHeight()
{
System.out.println("中国人的平均身高：173.0厘米");
}
//代码3//重写public void averageWeight()方法
//要求输出类似“中国人的平均体重：67.34公斤”这样的汉语信息
public void averageWeight()
{
System.out.println("中国人的平均体重：67.34公斤");
}
//System.out.println(this.speakHello()+this.averageHeight()+this.averageWeight());
public void chinaGongfu()
{
System.out.println("坐如钟，站如松，睡如弓");
}
}
class AmericanPeople extends People
{
//代码5//重写public void speakHello()方法
//要求输出类似“How do you do”这样的英语信息
public void speakHello()
{
System.out.println("How do you do");
}
//代码6//重写public void averageHeight()方法
public void averageHeight()
{
System.out.println("How do you do");
}
//代码7//重写public void averageWeight()方法
public void averageWeight()
{
System.out.println("How do you do");
}
public void americanBoxing()
{
System.out.println("直拳，勾拳");
}
}
class BeijingPeople extends ChinaPeople
{
//代码9//重写public void speakHello()方法
//要求输出类似“您好”这样的汉语信息
public void speakHello()
{
System.out.println("您好!");
}
//代码10//重写public void averageHeight()方法
public void averageHeight()
{
System.out.println("您好!");
}
//代码11//重写public void averageWeight()方法
public void averageWeight()
{
System.out.println("您好!");
}
public void beijingOpera()
{
System.out.println("京剧术语");
}
}
public class Example
{
public static void main(String args[])
{
ChinaPeople chinaPeople=new ChinaPeople();
AmericanPeople americanPeople=new AmericanPeople();
BeijingPeople beijingPeople=new BeijingPeople();
chinaPeople.speakHello();
americanPeople.speakHello();
beijingPeople.speakHello();
chinaPeople.averageHeight();
americanPeople.averageHeight();
beijingPeople.averageHeight();
chinaPeople.averageWeight();
americanPeople.averageWeight();
beijingPeople.averageWeight();
beijingPeople.beijingOpera();
americanPeople.americanBoxing();
beijingPeople.beijingOpera();
beijingPeople.chinaGongfu();
}
}
Q2: java方法的重写
Java中的方法重写ujiuye
方法的重载: 在同一个类中,出现多个同名的方法,参数列表不同,与返回值类型,修饰符无关
方法的重写: 子类中出现和父类中一模一样的方法(包括返回值类型,方法名,参数列表)
方法重写的注意事项:ujiuye
1.重写的方法必须要和父类一模一样(包括返回值类型,方法名,参数列表)
2.重写的方法可以使用@Override注解来标识
3.子类中重写的方法的访问权限不能低于父类中方法的访问权限
权限修饰符 : private 默认(什么都不写) protected public
为什么要重写方法:
1.当父类中的方法无法满足子类需求的时候,需要方法重写
2.当子类具有特有的功能的时候,就需要方法重写
重写的应用
子类可以根据需要java方法重写代码，定义特定于自己的行为。既沿袭java方法重写代码了父类的功能名称java方法重写代码，又根据子类的需要重新实现父类方法java方法重写代码，从而进行扩展增强。
Q3: java 重写方法
final 和static 的方法不能被重写 但是静态的方法可以被重新定义
java方法重写代码你那个不是重写 是重新定义 重新定义不属于多态范畴
所以java方法重写代码他只看引用类型 但是java也强烈建议你千万不要用引用去访问静态变量或静态方法java方法重写代码，因为那样你会逻辑混乱
你用的f其实就是子类型java方法重写代码，根本没有多态的，就算是调用重写的非静态方法还是体现不出多态性
那么其调用的grow一定是重新定义的子类方法
然而
Amphibian.grow(f);
来说 你在grow参数里声明的是父类的引用 但是你却把一个子类实例传递进来
多态性在这体现java方法重写代码了 首先调用的是父类的静态没疑问了 然而a.eat();出现了多态行为
父类引用指向子类对象 调用的是子类重写的方法
Q4: 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方法重写代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java compareto方法重写、java方法重写代码的信息别忘了在本站进行查找喔。
