继承那块，重写和重载的具体区别是什么呢？？详细点，就当复习了

重载：
        同一个类中，方法名相同，参数列表不同。
重写：
        不同的类中，方法的声明相同。

重载可以改变返回值的类型。

重载overload是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同（类型或者数量），方法体也不相同
最常见的就是构造方法了
1在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样）
2不能通过访问权限、返回类型、抛出的异常进行重载；

1. public class MainClass {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Person p1 = new Person();
   
5.                 p1.setName("张三");
   
6.                 Person p2 = new Person("李四");
   
7.                 Person p3 = new Person("王五"，23);
   
8.                 fetchWater(p1);
   
9.                 fetchWater(p2, p3);
   
10.                 fetchWater(p1, p2, p3);
    
11.         }
    
12.         //一般方法重载
    
13.         public static void fetchWater(Person p) {
    
14.                 System.out.println(p.getName() + "，一个人挑水喝");
    
15.         }
    
16.         public static void fetchWater(Person p1, Person p2) {
    
17.                 System.out.println(p1.getName() + "和" + p2.getName() + "，两个人担水喝");
    
18.         }
    
19.         public static void fetchWater(Person p1, Person p2, Person p3) {
    
20.                 System.out.println(p1.getName() + "、" + p2.getName() + "和"
    
21.                                 + p3.getName() + "，三个人没水喝");
    
22.         }
    
23. }
    
24. 
    
25. class Person {
    
26.         private String name;
    
27.         private int age;
    
28. 
    
29.         public String getName() {
    
30.                 return name;
    
31.         }
    
32. 
    
33.         public void setName(String name) {
    
34.                 this.name = name;
    
35.         }
    
36.         //构造方法重载
    
37.         public Person() {
    
38.         }
    
39.         public Person(String name) {
    
40.                 this.name = name;
    
41.         }
    
42.         public Person(String name, int age) {
    
43.                 this.name = name;
    
44.                 this.age = age;
    
45.         }
    
46. }

复制代码

运行结果：
张三，一个人挑水喝
李四和王五，两个人担水喝
张三、李四和王五，三个人没水喝

重写override是子类重写的是父类的方法，只有在发生继承关系的前提下，在能出现重写方法
1重写方法的参数列表必须完全与被重写的方法的相同
2重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。

1. public class MainClass {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Person p = new Person("张三", 18);
   
5.                 System.out.println("重写后的toString："+p.toString());
   
6.                 System.out.println("没重写的toString："+p.superToString());
   
7.         }
   
8. 
   
9. }
   
10. 
    
11. class Person {
    
12.         private String name;
    
13.         private int age;
    
14. 
    
15.         public Person(String name, int age) {
    
16.                 this.name = name;
    
17.                 this.age = age;
    
18.         }
    
19. 
    
20.         // 重载Object的toString
    
21.         public String toString() {
    
22.                 return "姓名：" + name + "年龄：" + age;
    
23.         }
    
24.         // 调用Object的toString
    
25.         public String superToString() {
    
26.                 return super.toString();
    
27.         }
    
28. }

复制代码

运行结果
重写后的toString：姓名：张三年龄：18
没重写的toString：com.heima.Lland.Person@41a80e5a

方法的重载:
                1、必须在同一类
                2、方法名必须一致
                3、参数列表必须不同
                4、和访问修饰符无关
                5、和返回类型无关


方法的重写:子类可以根据需要重新实现父亲中的方法
                1、必须父子类之间
                2、方法名相同
                3、参数列表相同
                4、除了private的方法外，子类的访问修饰符不小于父类
                5、返回类型必须一致
                6、静态也可以被重写，但是必须要求重写的方法都为静态

金鑫 发表于 2012-11-23 01:24
方法的重载:
                1、必须在同一类
                2、方法名必须一致

楼上说错了
重写的返回值不必一致 但是一定要保证子类的重写方法返回值是父类被重写方法的返回值的子类
最常见的就是clone方法了
如下列代码

1. public class MainClass {
   
2. 
   
3.         public static void main(String[] args) throws Exception {
   
4.                 Father f = new Father(0);
   
5.                 Child c = new Child(1);
   
6.                 Father fClone = f.clone();
   
7.                 Child cClone = c.clone();
   
8.                 System.out.println("被创建父类的标记" + f.getTag() + "被克隆父类的标记"
   
9.                                 + fClone.getTag());
   
10.                 System.out.println("被创建子类的标记" + c.getTag() + "被克隆子类的标记"
    
11.                                 + cClone.getTag());
    
12.         }
    
13. }
    
14. 
    
15. class Father {
    
16.         private int tag;
    
17. 
    
18.         public int getTag() {
    
19.                 return tag;
    
20.         }
    
21. 
    
22.         public Father(int tag) {
    
23.                 this.tag = tag;
    
24.         }
    
25. 
    
26.         protected Father clone() throws CloneNotSupportedException {
    
27.                 System.out.println("父类被重写的clone被调用了");
    
28.                 return new Father(10);
    
29.         }
    
30. }
    
31. 
    
32. class Child extends Father {
    
33.         public Child(int tag) {
    
34.                 super(tag);
    
35.         }
    
36. 
    
37.         protected Child clone() throws CloneNotSupportedException {
    
38.                 System.out.println("子类重写的clone被调用了");
    
39.                 return new Child(11);
    
40.         }
    
41. }

复制代码

运行结果：
父类被重写的clone被调用了
子类重写的clone被调用了
被创建父类的标记0被克隆父类的标记10
被创建子类的标记1被克隆子类的标记11

重载是可以用一个方法名执行多个方法,
重写是用一个新方法将原来的旧方法覆盖,
本质区别

重载：是针对一个方法的情况，方法的重写是相同的方法名，形参的个数、或者参数类型不同来表现的。对于重载方法的选择运行是由JAVA编译器决定的。
重写：是在继承这块对于子类继承父类后对父类方法进行重写，使子类这个方法与父类有不同的方法体，实现自己的功能，这就表现了类的多态的特性，在运行时调用哪个方法是由JVM决定运行的。

重写是就重新编写父类函数块，重载就是相同的函数名，不同的参数~~其实很容易分辨的~

重写的规则：
        1.参数列表必须与被重写方法的参数列表相同
        2.返回类型必须与被重写方法的返回类型相同
        3.访问修饰符，这个比较重要：
              （1）首先是运用在继承当中
              （2）其次是重写与被重写的方法的访问修饰符权限不能使用private，否则不能实现重写
              （3）再一个就是重写的方法的访问权限不能低于被重写方法的访问权限，或者权限相同也可以

重载的规则：
       1.作用于同一个类中
       2.必须具有不同的参数列表
       3.返回类型可以不相同
       4.访问修饰符也可以不相同

     

• 重写和重载的具体区别！
  
  继承那块，重写和重载的具体区别是什么呢？？详细点，就当复习了
  
  首先，重写是属于继承关系里面的关键词，指的是子类继承父类的方法，然后把这个方法给重写了。
  
  
  class Demo
  {
  public static void main(String[] args)
  {
  
  }
  }
  

• class Fu
  {
    void method()
  {
    System.out.println("Fu method");
  }
  void method2()
  {
    System.out.println("Fu method2");
  }
  }
• class Zi extends Fu
  {
  void method()
  {
    System.out.println("子类覆盖父类的方法");
  }
  void method3()
  {
    System.out.println("子类自己的方法");
  }
  void method3(int a,int b)
  {
•   return System.out.println("子类之间重载的方法"+"a+b="+a+b);
  }
  }
  

/*
对于重写来说，是发生在继承关系体系当中的，
子类去覆盖父类的方法，要求方法名和方法参数的类型，
方法的返回类型要完全一致。所以有的时候在写程序为了避免写错方法名，
一般都是直接去复制父类的方法来覆盖，当然方法体可以不一样。

对于重载，是发生在同一个类中的，重写要求重写方法之间方法名一样，
方法的返回类型可以一样，也可以不一样，注意：方法的返回类型不能用来
判断方法之间是否重载。还有，方法的参数列表不一样，方法的参数列表不一样
包括：参数个数不一样，参数类型不一样，参数类型的顺序不一样。
例如：方法 void temp(int a,boolean b){} 和方法 void temp(boolean b,int a){}
就属于参数的类型顺序不一样。
重载扩展：
  到了后面JDK的新特性，为了简化书写，出现了可变参数的情况，
void method(int a...){} 这个情况就减少了重载带来的代码
重复的情况。

*/

承载是父类方法的重载，方法名称一致，但参数序列或类型不一致
继承是父类方法的覆盖，方法名称一致，参数序列和类型完全一致，使用时只调用本类方法，即是覆盖了父类的方法

重载：
作用在同一类中，存在一个以上（两个或多个）的同名函数，
且具有不同的参数列表（参数个数不同，或者参数类型不同）
与返回值类型无关

例如：void suanfa{

            int add(int a,int b){
                       return (a+b);
                }
            int add(int a,int b,int c){
                       return (a+b+c);
                }
             double add(double a,doubleb){
                      return (a+b);
                }

}
重写：
也叫覆盖，指在子类中定义一个与父类中方法“同返回值，同名，同参数列表的方法”，因为子类会继承父类的方法。
或者叫
重写就是将从父类继承过来的方法重新定义一次，重新填写方法中的代码。