父类的构造函数可以被子类继承吗？为什么?百度了一下,说什么的都有。我都看晕了.
还有，final可以修饰构造函数吗？为什么?

我也是才刚学没多久，结合老师的讲解和自己的理解总结了一下希望对你有所帮助。
派生类通过new构造方法创建对象，在调用构造方法时，默认执行的第一行是super（）；即调用父类的无参构造方法。如果父类没有无参构造方法，系统会调用父类的默认无参构造方法（也就是一个方法体为空的无参构造方法）；如果父类存在有参的构造方法同时没有无参构造方法，子类的构造方法就不能调用父类无参构造方法，表现就是编译不能通过。

父类的构造函数可以被子类继承吗？为什么?百度了一下,说什么的都有。我都看晕了.
父类继承子类，父类的只要不被private 修饰的 成员和方法 都可以被继承到，
A
{
pblic int age;
public String name;
A( int age，String name)
{
          this.age=age;
         this.name=name;
     }
}
B extends A
{
String id;
B(int age,String name,String id)
{
super(age,name);
this.id=id;

}
}
可以继承的，排版见谅。。
还有，final可以修饰构造函数吗？为什么?

不可以, 构造方法是new 对象时候采用到的，final 是常量，

构造函数怎么能继承呢..是可以通过super调用父类的构造函数但是不能继承的。构造函数是每个类自己特有的，不算是成员变量和成员函数

子类本来就继承了父类的构造方法，final是不能修饰构造函数的，你可以自己写个简单的例子试下，编译报错

补充沙发：
在父类存在有参构造函数，且没有空参数构造函数情况下，子类必须手动super（）来调用相应的有参数构造函数
子类构函第一行，也可以手动指定this（）语句来访问本类中构造函数。但是，子类中至少有一个构造函数会访问父类中的构造函数。

原因是在子类构造函数第一行默认有一条隐式语句super();————访问父类中空参数的构造函数
子类中所有构造函数第一行默认都有super();
为什么子类一定要访问父类中的构造函数？（子类所有的构函，默认都会访问父类中空参数的构造函数）
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。
父类中没有空参数的构造函数时，子类必须手动通过super（）来指定访问父类中的构造函数。

构造函数是初始化用的，不能继承。写个小例子

1. public class Demo1{
   
2.         public static void main(String[] args){
   
3.                 new Son();       
   
4.         }
   
5. }
   
6. class Fa{
   
7.         Fa(){
   
8.                 System.out.println("Fa");
   
9.         }
   
10.         Fa(int i){
    
11.                 System.out.println("Fa::"+"int");
    
12.         }
    
13.         Fa(String str){
    
14.                 System.out.println("Fa::"+"String");
    
15.         }
    
16.         void method(){
    
17.                 System.out.println("method");
    
18.         }
    
19. }
    
20. class Son extends Fa{
    
21.         Son(){
    
22.                 super("str");//子类构造函数必须调用父类构造函数，默认为空参，也可用super指定
    
23.                 method();//子类可以调用父类方法
    
24.                 //Fa("str")
    
25.                 /*报错，子类中没用这个方法，这是父类的构造方法，不会被继承
    
26.                 更准确的说，是不存在构造函数被继承这种说法*/
    
27.                 System.out.println("Son");
    
28.         }
    
29. }
    

复制代码

父类的构造函数是不能被继承的。。子类中都有一条隐藏的super()，自动访问了父类中的空参数的构造函数。所以子类不是继承了父类的构造函数，而是一开始就已经对父类进行了访问！如果父类中的构造函数还不是空参数的，那么你就要自己手动super（）一次了，因为默认的super（）是只能访问空参数的！！！而后是final是不能修饰构造函数的哈~原因很简单，final是有终结的意思！而我们构造函数一般都是用来初始化的，并且你想下，我们调用类中的方法的时候，常常要new一个对象的，如果你final了构造函数，那我们就不能new了，因为被修饰过后的函数是不能被new对象的

白_蓝(八公) 发表于 2013-7-14 09:14  父类的构造函数是不能被继承的。。子类中都有一条隐藏的super()，自动访问了父类中的空参数的构造函数。所 ...

被final修饰的函数不能new对象?

杜天伟 发表于 2013-7-14 09:57
被final修饰的函数不能new对象?

被final修饰的类，是无法被继承的，但可以和普通的类一样使用！也就是可以new~回答你的时候打快了，我的意思是final构造函数~~

这里我可以提供一段代码：

1. public class Finals {//extends GG___提示：cannot subclass the final class GG  不能被继承
   
2. 
   
3.         public static void main(String[] args) {
   
4.                   GG f = new GG();
   
5.                 f.print();
   
6.                
   
7.         }
   
8. 
   
9. }
   
10. final class GG {
    
11.         GG(){  //如果你fianl了构造函数  它就会提示你只有公有的、私有和受保护的修饰才被允许
    
12.                         //而且这是一个逻辑问题。final修饰的父类方法，可以被继承，但却无法覆盖！
    
13.         }
    
14.     final public void print() {
    
15.         System.out.println("final修饰的GG类的输出");
    
16.     }
    
17. }

复制代码

顺道在这儿我也总结下final的用法：
1.final成员变量：
         final了成员变量  就使其变量不可变了。（补充下：基本类型是值不可变，对象变量是引用不可变，但引用变量所指向的对象中的内容是可变的）
2.fianl方法
        被final修饰的方法，个人感觉这个方法肯定很牛或者是一种恒古不变的规律。因为修饰过后这个方法不能被扩展，不能被覆写，可以被继承也可以被直接使用
        而在类中的private从某种意义上讲属于final，因为它们没办法被覆写（个人理解和结合看了些资料）
3.fianl类
        当使用到final类的时候   这个类是无法被任何人继承的，其实和方法差不多，这个类也是忒牛的！因为它是无需改变的了

你的意思是子类继承了父类的构造器？拿来当构造器使用吗？如果是的话，那无参是可以继承的，父类有默认无参就会直接继承下来，关键字是super且必须第一句。如果是有参数的话就不行了，构造器要自己写。

构造函数是不可以继承的,但是子类在创建时会调用父类的构造函数.
我贴一段黑马的基础测试的代码上来证明吧.

1. /*
   
2. * 需求:有这样三个类，Person,Student.GoodStudent。
   
3. *                 其中Student继承了Person,GoodStudent继承了Student,三个类中只有默认的构造函数，用什么样的方法证明在创建Student类的对象的时候是否调用了Person的构造函数，
   
4. *                 在创建GoodStudent类的对象的时候是否调用了Student构造函数？如果在创建Student对象的时候没有调用Person的构造函数，那么采用什么样的手段可以调用父类的构造函数？
   
5. * 方法:在Person,Student,GoodStudent的构造函数内加上特定的参数,然后创建一个新类继承GoodStudent.然后在主函数内打印新类
   
6. */
   
7. 
   
8. 
   
9. package com.itheima;
   
10. 
    
11. class Person{
    
12.         Person(){//创建构造函数.
    
13.                 String name = "LiLei";//定义姓名.
    
14.                 int age = 12;//定义年龄.
    
15.                 System.out.println("姓名:"+name);
    
16.                 System.out.println("年龄:"+age);
    
17.         }
    
18. }
    
19. 
    
20. class Student extends Person{
    
21.         Student(){
    
22.                 int Class = 1;//定义班级.
    
23.                 System.out.println("班级:"+Class);
    
24.         }
    
25.        
    
26. }
    
27. 
    
28. class GoodStudent extends Student{
    
29.         GoodStudent(){
    
30.                 int exam = 100;//定义考试成绩.
    
31.                 System.out.println("成绩:"+exam);
    
32.         }
    
33. }
    
34. 
    
35. class VeryGoodStudent extends GoodStudent{//创建一个新类,继承上面所有类.
    
36.         void run(){
    
37.                
    
38.         }
    
39. }
    
40. 
    
41. public class Test9 {
    
42.         public static void main(String[] args){
    
43.                 VeryGoodStudent Stu = new VeryGoodStudent();
    
44.                 Stu.run();//调出创建的新类,证明继承了所有的类.
    
45.         }
    
46. }
    

复制代码