abstract class A
{
public A()
{
   this.print();
}
public abstract void print();
}
class B extends A
{
private int temp=30;
public B(int temp){
   this.temp=temp;
}
public void print(){
  System.out.println("temp="+this.temp);
}
}

问题是这样的：子类在继承父类的时候会先调用父类的构造函数，那上面的子类复写的方法里面的参数不就无法获取到了，是不是父类中被调用的抽象方法在复写不不能有参数啊？或者怎么解决这个问题啊？或者有关扩展都请指教，多谢！！

1. package com.study;
   
2. abstract class A {
   
3.         A() {
   
4.                 this.show();//this指的是new的对象，b的初始值为0；
   
5.                 this.show(null);//字符串的初始值为null;
   
6.         }
   
7.         public abstract void show(String b); //抽象方法不能有方法体
   
8.         public abstract void show();
   
9.        
   
10. }
    
11. 
    
12. class B extends A {
    
13.         int b=1;
    
14.        
    
15.         //必须无参数构造，否则不能够直接new B();
    
16.         B() {
    
17.                 //super
    
18.                 System.out.println("B");
    
19.         }
    
20.         B(int a) {
    
21.                 //super
    
22.                 System.out.println("我是带参构造B");
    
23.         }
    
24.         public  void show(){
    
25.                 System.out.println("我是空参数子类"+"---"+b);
    
26.         }
    
27.         public  void show(String b){
    
28.                 System.out.println("我是字符串参数子类"+"---"+b);
    
29.         }
    
30. 
    
31. }
    
32. class Test2{
    
33.         public static void main(String[] args) {
    
34.                 new B();
    
35.                 System.out.println("----------------");
    
36.                 new B().show();
    
37.                 System.out.println("----------------");
    
38.                 new B().show("随便给");
    
39.                 System.out.println("----------------");
    
40.                 new B(111111);
    
41.                
    
42.                
    
43.         }
    
44. }

复制代码

结果：我是空参数子类---0
我是字符串参数子类---null
B
----------------
我是空参数子类---0
我是字符串参数子类---null
B
我是空参数子类---1
----------------
我是空参数子类---0
我是字符串参数子类---null
B
我是字符串参数子类---随便给
----------------
我是空参数子类---0
我是字符串参数子类---null
带参构造B

对于抽象，你要注意：只抽取功能定义，不抽取功能主体！

学习了！！

可以有参数啊，子类只要复写父类的方法就行了。

唯爱小七 发表于 2014-12-25 13:18
可以有参数啊，子类只要复写父类的方法就行了。

子类在继承父类的时候会先调用父类的构造函数，那子类复写的方法里面的参数不就无法获取到了，你看上面的代码如果newB（10）会输出多少啊，如果可以有参数的话，你可以讲的详细一点。

是的，可以有参数，你自己可以再自己研究下。

你还是再看看方法重写定义吧，方法重写要求子类中重写方法声明部分要与父类被重写方法声明部分完全一致 ，因此只要父类抽象方法带参，子类重写也必然带参

是的，可以有参数

来学习学习

子类在继承父类的时候会先调用父类的构造函数，那上面的子类复写的方法里面的参数不就无法获取到了，是不是父类中被调用的抽象方法在复写不不能有参数啊？或者怎么解决这个问题啊？
构造函数是特殊的方法,子类如果没有显示申明构造函数,默认的就继承父类的方法,如果有构造函数则会用自己的构造函数?

对于父类是不是父类中被调用的抽象方法在复写不不能有参数啊，是可以有参数的，子类只需要实现即可。由于你定义的父类是个抽象类，它是无法实例化对象的，所以只需要实现即可。同时对于子类实现抽象方法的参数，它是一个形式参数，由调用该方法的对象所提供。

类的初始化顺序是：

• 父类的变量、初始化块
• 父类的构造器
• 子类的变量、初始化块
• 子类的构造器
  

从上面的这个过程来看，父类的构造器在执行时，调用子类的print（）方法，此时子类的变量temp还没有进行初始化，则默认值为0，所以在创建子类对象时，无论构造器参数传的什么值，则默认都打印“temp=0”。



具体代码如下：

1. abstract class A {
   
2.     public A() {
   
3.         this.print();
   
4.     }
   
5.     public abstract void print();
   
6. }
   
7. 
   
8. class B extends A {
   
9.     private int temp = 30;
   
10.    
    
11.     public B(int temp) {
    
12.         this.temp = temp;
    
13.     }
    
14.    
    
15.     public void print() {
    
16.         System.out.println("temp=" + this.temp);
    
17.     }
    
18. }
    
19. 
    
20. public class TestExtends {
    
21.     public static void main (String[] args) {
    
22.             B c = new B(3);
    
23.     }
    
24. }

复制代码

打印结果如下：
temp=0

如果是抽象类需重写抽象方法，也可以有多态，父类中的引用指向子类堆中的对象。

重写：子类的方法名、参数列表、返回值类型必须与父类一样；子类中重写后的方法 访问权限要大于等于 父类中被重写的方法。

1. 
   
2. 
   
3. abstract class A
   
4. {
   
5.         public A()
   
6.         {
   
7.                 System.out.println("调用父类的构造方法。。。");
   
8.                 this.print();
   
9.         }
   
10.         public abstract void print();
    
11. }
    
12. 
    
13. class B extends A
    
14. {
    
15.         private int temp=30;
    
16.         public B(int temp){
    
17.                 this.temp=temp;
    
18.         }
    
19.         public void print(){
    
20.                 System.out.println("temp="+this.temp);
    
21.                
    
22.         }
    
23. }
    
24. 
    
25. public class test1 {
    
26.         public static void main(String[] args) {
    
27.                
    
28.                         new B(20).print();
    
29.         }
    
30. 
    
31. }
    
32. 
    

复制代码

运行结果为：
调用父类的无参构造方法。。。
temp=0
temp=20

这是因为在示例化子类对象时，会先 调用父类的构造方法。由于此时父类并没有提供带参构造器，所以默认调用父类的无参构造方法。temp此时是其默认值0.之后调用子类的带参构造器，为temp赋值，所以打印出来的temp的值为20.


将以上程序稍加改动：

1. 
   
2. 
   
3. abstract class A
   
4. {
   
5.         public A()
   
6.         {
   
7.                 System.out.println("调用父类的构造方法。。。");
   
8.                 this.print();
   
9.         }
   
10.         public abstract void print();
    
11. }
    
12. 
    
13. class B extends A
    
14. {
    
15.         private int temp=30;
    
16.         public B(){}
    
17.         public B(int temp){
    
18.                 this.temp=temp;
    
19.         }
    
20.         public void print(){
    
21.                 System.out.println("temp="+this.temp);
    
22.                
    
23.         }
    
24. }
    
25. 
    
26. public class test1 {
    
27.         public static void main(String[] args) {
    
28.                
    
29.                         new B().print();
    
30.         }
    
31. 
    
32. }
    
33. 
    

复制代码

运行结果为：
调用父类的构造方法。。。
temp=0
temp=30

此时是因为子类 调用的是其无参构造器，this.temp的值就是其成员变量的值。

子类重写父类方法时要一致

能否不用继承，而用装饰类？我也是初学，刚有这个思路，发上来给楼主，抛砖引玉，见笑了~

1.你的子类里必须要写一个无参的构造函数，否则new B()的时候会报错误。

你子类里写的那个和父类中的方法名称一样的方法，因为有了参数，已经不是父类中的那个方法了，也就不是方法重写了。方法的重写要求，方法名和方法的参数以及参数类型必须一致。