覆盖和重写的区别？

Java code

class Father{    static void print(){         System.out.println ("in father   method");     }}class Child extends Father{    static void print(){         System.out.println ("in child method");     }}class Test{    public static void main (String[] args) {         Father f =new Child();         f.print();     }}

这个叫覆盖，我知道静态方法不能被重写，但是这种写法和重写一摸一样，覆盖和重写区别是什么？

[解决办法]
重写有多态
覆盖没多态
方法调用时
重写方法决定于对象类型
覆盖的方法决定于引用类型
[解决办法]
不同的 参数 类型 相同的是 方法名字都一样的
[解决办法]
覆盖==重写 叫法不同罢了
父类中有个print()方法，子类里面再一个print()方法，这样子类对父类方法的重写。
重载是指在“一个类”中，你写了多个方法，他们的方法名相同，但是参数不同，这样算是重载。比如你在一个类中写了print()和print(String a)两个同名函数。

我也是才学没多久 不知道理解对不的啊
[解决办法]

探讨

覆盖==重写 叫法不同罢了
父类中有个print()方法，子类里面再一个print()方法，这样子类对父类方法的重写。
重载是指在“一个类”中，你写了多个方法，他们的方法名相同，但是参数不同，这样算是重载。比如你在一个类中写了print()和print(String a)两个同名函数。

我也是才学没多久 不知道理解对不的啊

[解决办法]
覆盖 就是重写啊
还有一个重载 这个和 重写不是一个概念
[解决办法]

探讨

引用:
覆盖==重写 叫法不同罢了
父类中有个print()方法，子类里面再一个print()方法，这样子类对父类方法的重写。
重载是指在“一个类”中，你写了多个方法，他们的方法名相同，但是参数不同，这样算是重载。比如你在一个类中写了print()和print(String a)两个同名函数。

我也是才学没多久 不知道理解对不的啊

就是这样
重……

[解决办法]
overLoad 是本类方法之间的
override 是子类和父类之间的


overLoad是在一个类里面有两个方法名相同参数不同的两个方法
override是子类重写了父类的某个方法
[解决办法]

探讨

覆盖==重写 叫法不同罢了
父类中有个print()方法，子类里面再一个print()方法，这样子类对父类方法的重写。
重载是指在“一个类”中，你写了多个方法，他们的方法名相同，但是参数不同，这样算是重载。比如你在一个类中写了print()和print(String a)两个同名函数。

我也是才学没多久 不知道理解对不的啊

[解决办法]
LZ出了一个伪命题，也代表一些初学者的迷茫，概念清楚了好编码。
[解决办法]
重写就是覆盖... ，你的代码肯定是输出父类的信息，静态的方法也叫类方法，只和类有关，和具体对象没联系！
[解决办法]
重写即覆盖，重构，重置，是类继承体系子类对父类方法的改写，是竖向的，属于扩展代码的需要。
重载是一个类作用域内方法的多个不同版本，是横向的，属于方法的多态。

静态方法分属于不用的作用域，即不是覆盖也不是重载，是完全不同的名字空间中的两个方法。
[解决办法]
区别点 重载方法 重写方法
参数列表 必须修改 一定不能修改
返回类型 可以修改 一定不能修改
异常 可以修改 可以减少或删除，一定不能抛出新的或者更广的异常
访问 可以修改 一定不能比被重写方法的访问权限强（可以降低限制）
[解决办法]
晕哦
覆盖和重写是同一个概念啊
我都记不太清楚了 楼主这么一问我又理解成了 C# 中的 new 关键字
楼主要例子 我就写个吧

Java code

public class Test {    public static void main(String[] args) {        A a = new B(); //父类引用，子类对象； 同名成员变量父类无法引用，static方法也是如此。        System.out.println(a.i); //父类的变量        System.out.println(((B) a).i); //恢复到子类的变量        a.testMethod(); //调用子类方法，多态        a.testStaticMethod(); //调用父类方法。        ((B)a).testStaticMethod();//恢复到子类引用调用子类方法，如同上边调用变量一样。    }}class A {    public int i = 1;    public void testMethod() {        System.out.println("this is in A");    }    public static void testStaticMethod() {        System.out.println("this is the static method in A");    }}class B extends A {    public int i = 2;    public int j = 0;    public void testMethod() {        System.out.println("this is in B");    }    public static void testStaticMethod() {        System.out.println("this is the static method in B");    }} 
 
[解决办法]
再加点东西
Java code
public class Test {    public static void main(String[] args) {        A a = new B(); //父类引用，子类对象； 同名成员变量父类无法引用，static方法也是如此。        System.out.println(a.i); //父类的变量        System.out.println(((B) a).i); //恢复到子类的变量        //System.out.println(a.j); 无法调用，这个叫擦除 ，上边同名的 i 其实也是这个意思        //当引用类型恢复成子类后 父类的 i 因为被子类的 i 给屏蔽掉了，类似于类中方法中变量与类成员同名时，类成员被屏蔽掉一样        System.out.println(((B) a).j); //恢复        a.testMethod(); //调用子类方法，多态        a.testStaticMethod(); //调用父类方法。        ((B)a).testStaticMethod();//恢复到子类引用调用子类方法，如同上边调用变量一样。    }}class A {    public int i = 1;    public void testMethod() {        System.out.println("this is in A");    }    public static void testStaticMethod() {        System.out.println("this is the static method in A");    }}class B extends A {    public int i = 2;    public int j = 0;    public void testMethod() {        System.out.println("this is in B");    }    public static void testStaticMethod() {        System.out.println("this is the static method in B");    }}
[解决办法]
看见标题把我郁闷着了.覆盖....
[解决办法]
Java code
class Father {    static void print() {        System.out.println("in father method");    }}class Child extends Father {    static void print() {        System.out.println("in child method");    }}class Test {    public static void main(String[] args) {        Father f = new Child();        f.print();    }}
[解决办法]
我明白你的意思了 
SCJP学习指南说  所说的 覆盖 应该就是指  静态绑定

SCJP学习指南说  所说的 重写 就是指动态绑定
[解决办法]
本来就没联系的两个概念，
[解决办法]
[Quote=引用:] 
 Java code 
  
 class Father{ 
     static void print(){ 
          System.out.println ( "in father   method "); 
      } 
 } 
 class Child extends Father{ 
     static void print(){ 
          System.out.println…… 
 [/Quote] 
  
  
 这个是重写 重写是在类的继承中体现出来的 子类重写父类的方法  
 而覆盖是在同一个类中拥有相同的方法名字 但是参数的个数和类型可能不同 
 例如 
 public class Test 
 { 
     public static void main(String args[]) 
     { 
          int age=22; 
          String name= "123456 "; 
          public void fun() 
          { 
              System.out.prntln( "第一个fun()方法 "); 
          } 
          public void fun(String name) 
          { 
  
               System.out.println( "第二个fun()方法 "+name);//多了一个name参数 
          } 
          public void fun(String name,int age) 
          { 
                System.out.println( "第三个fun()方法 "+name+ "  "+age);//多了两个参数 
  
          } 
     } 
 } 
 但是重写的方法名字跟参数都是一样的  
 千万要记住两点区别 
 1，覆盖是在同一个类中的 。重写是在子类中重写父类方法，是两个类 
 2，覆盖中的方法名字相同 但参数的类型和个数不同 调用方法时是根据参数来查找的 跟参数的顺序有关 在调用处输入实参数的时候 也得照着形式参数的顺序来。在重写中 子类重写父类的方法时 其方法名和参数个数和类型都相同  
 如果有说的不对的地方多多指教
[解决办法]
顶
探讨

重写有多态
覆盖没多态
方法调用时
重写方法决定于对象类型
覆盖的方法决定于引用类型