1. class Fu
   
2. {
   
3.     void speak(){}
   
4.     void show(int x){}
   
5.     void eat(){}
   
6.     private void sleep(){}
   
7. }
   
8. class Zi extends Fu
   
9. {
   
10.     void speak(){}
    
11.     void show(int x,int y){}
    
12.     int eat(){}
    
13.     private void sleep(){}
    
14. }

复制代码

speak()此函数在 Zi 类中重写（覆盖）了

show()此函数在 Zi 类中重载了

eat()此函数在 Zi 类和 Fu 类中的形式不允许出现在同一个类中，所以我这样的继承写法是不允许出现的

sleep()此函数在 Zi 类中未发生任何改变，Fu 类sleep()函数是私有的，Zi 类无法访问此函数，也就无法继承

--------------------------------------------------

重载：

函数名一定相同（重载前提），与返回值类型无关

参数列表一定不同：

参数个数不同，或者参数类型不同就重载

参数个数相同，类型顺序不同就重载

一下这个类中的两个函数就重载

1. class
   
2. {
   
3.     void show(int x,double y,char z)
   
4.     void show(int x,char y,double z)
   
5. }

复制代码

---------------------------------------------------

重写：

子父类中的两个函数

返回值类型，函数名 ，参数个数，参数类型，类型顺序都要保持一致

这是我的理解，希望大家指出我的理解的错误指出

还有什么漏掉和注意的地方……

理解的还行

   重载就只看参数列表，重写就是函数的主题不同，函数的声明还是相同的
   好好学习，加油哦

理解还不错，
反正我没找到，我跟你理解的一样
一起加油，一起努力

麦子 发表于 2013-10-26 16:52
理解的还行

   重载就只看参数列表，重写就是函数的主题不同，函数的声明还是相同的

你说的是函数主体吧……
就是大括号内的内容不同
声明指的是下面加下划线的部分还是指斜体的部分
public static void show  ( int x,int y) {
}

楼主在上面关于show（）方法的说明有问题，
首先重载是指在同一个类中存在的同名但参数不同的情况，zi类中show（）方法既不是对Fu类的重载，
重写是指与父类具有相同的方法名、参数列表，返回值类型，子类的访问权限必须大于或等于父类的权限
同时子类与父类在参数列表上也不一样，所以show()方法也不是对Fu类的重写

因此，自能将show ()看做是子类自定义的一个方法

还有，子类可以继承父类的所有方法，父类的私有方法子类是可以继承的，但是因为权限的问题，不能访问，在这上面要理解清楚
如果提供了公开的权限，就可以访问

中山狼 发表于 2013-10-26 17:33
楼主在上面关于show（）方法的说明有问题，
首先重载是指在同一个类中存在的同名但参数不同的情况，zi类中s ...

1. class Fu
   
2. {
   
3.     void speak(){}
   
4.     void show(int x){}
   
5.     void eat(){}
   
6.     private void sleep(){}
   
7.     private void jump(){}
   
8. }
   
9. class Zi extends Fu
   
10. {
    
11.     void speak(){}
    
12.     void show(int x,int y){}
    
13.     int eat(){}
    
14.     private void sleep(){}
    
15.     void jump(){}
    
16. }
    

复制代码

Zi 类继承父类
那么原 Zi 类相当于下面的形式（红色为从 Fu 类继承来的）
class Zi
{
    void speak(){}//此函数被重写
    void show(int x,int y){}
    void show(int x){}
    int eat(){}
    void eat(){}
    private void sleep(){}
    private void sleep(){}//sleep函数主体相同，没必要再定义，这是我的疏漏
    void jump(){}
    private void jump(){}
}

那么你认为 Zi 类中show函数没有重载吗？
--------------------------------------------------
假设 sleep 函数主体相同，没必要再定义，这是我的疏漏
--------------------------------------------------
私有修饰的成员可以继承，但不能直接访问，这个我倒是可以理解

以楼上为准……

李新辉 发表于 2013-10-26 18:22
Zi 类继承父类
那么原 Zi 类相当于下面的形式（红色为从 Fu 类继承来的）
class Zi

哥们怎么不回帖了呀……
如果字子父类中定义了相同声明的私有方法
结果会是怎样的呢？

重写：子类中的函数不能比父类中的函数权限小。

回天之力 发表于 2013-10-30 00:08
重写：子类中的函数不能比父类中的函数权限小。

父类中的私有方法
子类是不知道的
那么子类中定义相同的私有方法
是会覆盖还是重载呢?
我很迷惑....

回天之力 发表于 2013-10-30 00:08
重写：子类中的函数不能比父类中的函数权限小。

private void sleep(){}
private void sleep(){}

这样的函数分别在子父类中会怎样？？？

李新辉 发表于 2013-10-30 10:18
private void sleep(){}
private void sleep(){}

没人知道吗？？？

回天之力 发表于 2013-10-30 00:08
重写：子类中的函数不能比父类中的函数权限小。

这个我知道的……
只是还是有不太明白的地方……
你看我下面的回复，你明白不……
给我说说……

李新辉 发表于 2013-10-30 10:18
private void sleep(){}
private void sleep(){}

很明显  父类中定义的private void sleep(){}，是private。所以和子类中定义的sleep（），完全没有关系。因为子类根本就不能调用父类中私有成员。所以俩个private没有关系。不用纠结啦。

李新辉 发表于 2013-10-30 10:18
private void sleep(){}
private void sleep(){}

很明显  父类中定义的private void sleep(){}，是private。所以和子类中定义的sleep（），完全没有关系。因为子类根本就不能调用父类中私有成员。所以俩个private没有关系。不用纠结啦。

那位大神还有不同看法  
来说一说啊
我还是理解的不太明白………………
{:soso_e135:}{:soso_e118:}{:soso_e135:}{:soso_e118:}{:soso_e135:}{:soso_e118:}{:soso_e135:}{:soso_e118:}{:soso_e135:}{:soso_e118:}

1.重写（Override）就是把父类的那个要重写的方法复制粘贴过来，除了方法体里面的内容什么都别改
其实你用 IDE 的话，可以在方法上面加个 @Override 就会自动帮你判定这方法是不是重写
2.复载（Overload）就是几个方法同名不同参数，这个参数不只是形参，就是括号里看到那些，还有实参，就是你调用这个方法的时候实际填的参数
比如 add(int i) 和 add(int num) 你在使用其中任何一个方法的时候，传入的都是整数，它就不知道你想用哪个方法了
3.至于返回值，方法名和参数相同的方法必须有相同的返回值
比如 int add(int i) 和 double add(int i) 你在使用其中任何一个方法的时候，写法都一样，它就不知道该返回哪个值了
4.总结一下，这些规则都是为了避免你调用方法的时候会同时出现多个方法都复合语法的情况，
所以你只要反着想，只要能保证不会出现歧义的状况，就肯定是符合规则的

零下五度的水 发表于 2013-10-31 21:58
1.重写（Override）就是把父类的那个要重写的方法复制粘贴过来，除了方法体里面的内容什么都别改
其实你用  ...

private void sleep(){}
private void sleep(){}

这样的函数分别在子父类中

当方法体相同的时候会怎样？
当方法体不同的时候会怎样？

李新辉 发表于 2013-10-31 22:08
private void sleep(){}
private void sleep(){}

这样是可以定义的 不会发生冲突 因为当方法加了私有之后 ，在类之外是不能直接访问的 只能通过本类中的方法访问，这既不叫重载也不属于重写。。。

1. class ChongZaiTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Fu f = new Zi();
   
6.                 f.method();   
   
7. 
   
8.                 Zi z = new Zi();               
   
9.                 z.method();
   
10. 
    
11.                 Fu f1 = new Fu();               
    
12.                 f1.method();
    
13.         }
    
14. }
    
15. 
    
16. 
    
17. class Fu
    
18. {
    
19.         private void show()
    
20.         {
    
21.                 System.out.println("fu...show");
    
22.         }
    
23. 
    
24.         public void method()
    
25.         {
    
26.                 System.out.println("fu...method");
    
27.                 show();
    
28. 
    
29.         }
    
30. 
    
31. 
    
32. 
    
33. }
    
34. 
    
35. class Zi extends Fu
    
36. {
    
37.         private void show()
    
38.         {
    
39.                 System.out.println("zi...show");
    
40.         }
    
41. 
    
42.         public void method()
    
43.         {
    
44.                 System.out.println("zi...method");
    
45.                 show();
    
46.         }
    
47. 
    
48. }

复制代码

结果为：
zi...method
zi...show
zi...method
zi...show
fu...method
fu...show

Override 你看这词，Over 在你上面，ride 骑，Override连一起就是我都骑你脑袋上了
你想编译器要是跑子类对象实例的这个方法的时候它会怎么选，
编译器选择方法的时候不会闲到还仔细看看你的方法体里面写了啥