关于继承，有一个问题一直没有理解透：当子类继承了父类，沿袭了父类的功能到子类中，但子类虽有该功能，但功能内容却和父类不一致，这时应该使用覆盖，但是看视频中为什么会有父类的方法比子类还多，子类只是继承了父类的一个方法，调试也能成功，不应该都继承吗？代码如下
abstract class Stundent
{
        public abstract void study();
        public void sleep()
        {
                System.out.println("1");
        }
}


class BaseS extends Stundent
{
        public void study()
        {
                System.out.println("2.1");
        }
        public void sleep()
        {
                System.out.println("2.0");
        }
}


class AdvS extends Stundent
{
        public void study()
        {
                System.out.println("3.0");
        }
}


class de
{
        public static void main(String[] a)
        {
                BaseS bs = new BaseS();
                bs.study();
                bs.sleep();


                AdvS as = new AdvS();
                as.study();

继承是都继承了而且已经加载到内存上了，只不过没有显示啊， 你子类如果想修改父类的方法 你就重写啊 你不想修改 就不用管啊 而且可以调用啊 而且抽象方法是一定要重写的啊

淡淡柠檬茶 发表于 2014-6-2 12:10
~\(≧▽≦)/~ 节日快乐O(∩_∩)O~

也祝你节日快乐

丁绍然 发表于 2014-6-2 11:08
说的很全面了
继承相当于把父类的东西复制到子类里面去了
子类需要复写父类里面的abstract方法，必须没有ab ...

~\(≧▽≦)/~ 节日快乐O(∩_∩)O~

李小然 发表于 2014-6-2 11:05
不用谢~
是的，咱们这行如果不动手就和没学一样的。
端午节快乐！

同乐。。。。:P

说的很全面了
继承相当于把父类的东西复制到子类里面去了
子类需要复写父类里面的abstract方法，必须没有abstract方法才可以实例化

但是看视频中为什么会有父类的方法比子类还多，子类只是继承了父类的一个方法，调试也能成功，不应该都继承吗？
这里你可能没有理解，对于父类的方法，除了抽象方法，私有方法，子类都是要继承的，对于子类的特有方法，子类会重写，重写之后就成了子类的特有方法，你在视频中，看到的子类只是继承了父类的一个方法，也能调试成功是因为，太在调用了那一个方法，他如果调用其他的任何他的父类的非私有，非抽象方法，也是不会报错的。

淡淡柠檬茶 发表于 2014-6-2 11:00
我理解了，谢谢版主，光看还是不行啊，还是得手敲代码

不用谢~
是的，咱们这行如果不动手就和没学一样的。
端午节快乐！:D

武维京 发表于 2014-6-2 10:49
看看注释部分 希望对你有帮助！！！

谢谢兄弟了，大家一起努力

李小然 发表于 2014-6-2 10:36
我感觉你在概念上模糊了“重写”、“继承”与“抽象类”

这句话明确的解释了什么是“重写”，即：当子类继 ...

我理解了，谢谢版主，光看还是不行啊，还是得手敲代码

程洋 发表于 2014-6-2 10:30
比如你的例子中的advs类中虽没有写sleep方法，但是在主函数同样可以通过ss来调用，你自己可以试试。手机打 ...

谢谢，我也是看到后来感觉前面有点生疏，在复习一下，，，，结果哎。

少侠，你需要反复阅读大典（Java基础）关于OOP之继承这块内容

1. package com;
   
2. abstract class Stundent
   
3. {
   
4.         public abstract void study();//这是个抽象类 所有子类必须实现，
   
5.                                      //如果不实现那么子类也是抽象方法！！
   
6.         public void sleep()    //这是父类的特有方法。
   
7.         {
   
8.                 System.out.println("1");
   
9.         }
   
10. }
    
11. 
    
12. 
    
13. class BaseS extends Stundent
    
14. {
    
15.         public void study()//实现父类的方法。
    
16.         {
    
17.                 System.out.println("2.1");
    
18.         }
    
19.         public void sleep()//（继承中多态）复写父类的方法，并且赋予自己的特有功能。
    
20.         {
    
21.                 System.out.println("2.0");
    
22.         }
    
23. }
    
24. 
    
25. 
    
26. class AdvS extends Stundent//我的理解，你说的应该是这个子类为什么没有
    
27.                            //复写sleep（）方法还能执行吧？
    
28. {
    
29.         public void study()//实现父类方法。
    
30.         {
    
31.                 System.out.println("3.0");
    
32.         }
    
33. }
    
34. public class lianxi1 {
    
35. 
    
36.         public static void main(String[] args) {
    
37.                 // TODO Auto-generated method stub
    
38.                 BaseS bs = new BaseS();
    
39.         bs.study();
    
40.         bs.sleep();
    
41. 
    
42. 
    
43.         AdvS as = new AdvS();//这个子类其实也继承了父类的sleep（）方法。
    
44.                              //只是在子类中没有复写这个方法。
    
45.                              //你可以理解成这个子类的睡觉方法和父类一样。
    
46.         as.study();
    
47.        // as.sleep();//当你调用这个子类的sleep（）时，打印的是父类sleep（）；
    
48.         }
    
49. 
    
50. }
    

复制代码

看看注释部分 希望对你有帮助！！！

我感觉你在概念上模糊了“重写”、“继承”与“抽象类”

当子类继承了父类，沿袭了父类的功能到子类中，但子类虽有该功能，但功能内容却和父类不一致，这时应该使用覆盖

这句话明确的解释了什么是“重写”，即：当子类继承了父类的成员函数，但却不适合，所以更改了运行内容，

重写需要你手动重写

class AdvS extends Stundent
{
        //这就属于重写
        public void study()
        {
                System.out.println("3.0");
        }
}


继承：当创建类使用extends关键字，就会使得子类继承父类的所有非私有成员。
继承不需要你做动作，自动继承。

但是看视频中为什么会有父类的方法比子类还多

你如果理解了继承，就不会有这样的疑问。
父类方法为什么不能比子类方法多？
如果你愿意，你可以在父类写100个你愿意的方法
在子类中只重写1~2个所需修改的方法，也是完全可以的。


另外你这个例子中，使用的是抽象类
子类必须重写抽象类中的抽象方法才可以实例化（study方法）


感觉你的问题比较模糊，如果有什么不明白的可以继续留贴询问。:)

比如你的例子中的advs类中虽没有写sleep方法，但是在主函数同样可以通过ss来调用，你自己可以试试。手机打字真难受啊

子类继承了父类除私有以外的所有方法，子类对某些个方法有自己的独特方法体时，就会覆盖父类的方法，没有覆盖的是子父类方法相同，没有必要再在子类中再写一遍。