1. class Person{
   
2.         private int age;
   
3.         private String name;
   
4.         Person(String name,int age)
   
5.         {
   
6.                 this.age =age;
   
7.                 this.name=name;
   
8.         }
   
9.         public String getName()
   
10.         {
    
11.                 return name;
    
12.         }
    
13.         public int getAge()
    
14.         {
    
15.                 return age;
    
16.         }
    
17.         public void say()
    
18.         {
    
19.                 System.out.println(this.getName());
    
20.         }
    
21. }
    
22. 
    
23. class Person2
    
24. {
    
25.         public String getName()
    
26.         {
    
27.                 return "anme";
    
28. 
    
29.         }
    
30.         public int getAge()
    
31.         {
    
32.                 return 10;
    
33.         }
    
34. }
    
35. 
    
36. 
    
37. 
    
38. class SuperPerson extends Person   //初步原因：继承Person，无法将类 Person中的构造器 Person应用到给定类型。。求解释。。extends Person2没问题
    
39. {
    
40.         private Person p;
    
41.         SuperPerson(Person p)
    
42.         {
    
43.                 this.p=p;
    
44.         }
    
45. 
    
46. }
    
47. 
    

复制代码

代码贴全一点嘛

继承类的构造方法错了 ,如果父类没有无参的构造方法,在子类构造方法中就得先调用父类的构造方法
SuperPerson(Person p)

   {
        super(  "dfd"    ,    12  );
        this.p=p;

  }
还可以在父类中添加一个无参的构造方法

这个不是装饰类。下面的才是装饰类，装饰类是对简单类功能的加强。

1. /*
   
2. 装饰设计模式：
   
3. 当想要对已有的对象进行功能增强时，
   
4. 可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
   
5. 那么自定义的该类称为装饰类。
   
6. 
   
7. 装饰类通常会通过构造方法接收被装饰的对象。
   
8. 并基于被装饰的对象的功能，提供更强的功能。
   
9. 
   
10. 
    
11. */
    
12. class Person
    
13. {
    
14.         public void chifan()
    
15.         {
    
16.                 System.out.println("吃饭");
    
17.         }
    
18. }
    
19. 
    
20. class SuperPerson
    
21. {
    
22.         private Person p ;
    
23.         SuperPerson(Person p)
    
24.         {
    
25.                 this.p = p;
    
26.         }
    
27.         public void superChifan()
    
28.         {
    
29.                 System.out.println("开胃酒");
    
30.                 p.chifan();
    
31.                 System.out.println("甜点");
    
32.                 System.out.println("来一根");
    
33.         }
    
34. }
    
35. 
    
36. 
    
37. 
    
38. class  PersonDemo
    
39. {
    
40.         public static void main(String[] args)
    
41.         {
    
42.                 Person p = new Person();
    
43. 
    
44.                 //p.chifan();
    
45. 
    
46.                 SuperPerson sp = new SuperPerson(p);
    
47.                 sp.superChifan();
    
48. 
    
49.         }
    
50. }
    

复制代码

下面两句话可以解释为什么你编译不同过。
        1.如果一个类你不写构造函数，那么会隐式帮你加个空参数的构造函数；如果你显示写了构造函数，那么这
          个类的构造函数就是你写的那个或那些，即使这些构造函数中没有空参数构造函数也不会再帮你隐式加了。
        2.子类的构造函数第一行会隐式加个super()调用父类的空参数构造函数；如果父类没有空参数的构造函数，
          子类的构造函数第一行要显示的使用 super（参数）来指定调用父类哪个构造函数，不然会编译报错。
SuperPerson(Person p)
{
        super(  "abc", 10  );    //在代码里加上这句话就OK了。
        this.p=p;
  }


另外，关于装饰者模式：
  1.装饰者模式中要求：装饰者中含有被装饰者的引用.
2.装饰者模式中要求：装饰者和被装饰者应该实现同一个类型.
看如下代码

abstract class Person   //定义一个抽象类

{

        String nam;

        int ag;

        pubic abstract void sop(){};   //抽象方法

}

class Student extends Person   //定义Student类继承Person

{

    private String name;

    private int age;

    public Student(String name, int age)

    {

         this.name = name;

         this.age = age;

    }

    public void sop()

    {

         System.out.println(name+"......"+age);

    }

    public String getName()

    {return this.name;}

    public int getAge()

    {return this.age;}

}

class Student1 extends Person   //定义Student1类继承Person

{

    Person person;

    public Student1(Person person)

    {

         this.person = person;

    }

    public void sop()

    {

         person.sop();

         System.out.println("My name is tang jian");   //扩展

    }

}

public class Test

{

    public static void main(String[] args)

    {

        Student stu = new Student("tang", 24);

        Student1 stu1 = new Student1(stu);

                stu1.sop();

    }

}

运行结果：

tangjian......24

My name is tang jian

person自定义了带参构造函数，系统不提供无参构造函数，子类继承person，就必须显式调用person类的构造方法，方式就是super（name,age）；而superperson类中，没有显式调用super（name，age）；报错；
person2中没有重载构造函数，系统默认提供无参构造，子类构造函数第一行默认提供super（）语句，所以继承person2能够通过；

问题应该是出在继承上了吧？
继承具有无参构造方法的类时，系统会自动生成一个隐形的super（）帮你在子类中复写构造函数。
但如果继承的是带有参数的构造函数的类时，你需要自己重写一个super调用到父类的构造方法。

class SuperPerson extends Person   //初步原因：继承Person，无法将类 Person中的构造器 Person应用到给定类型。。求解释。。extends Person2没问题
{
        private Person p;
        SuperPerson(Person p)
        {
                super（name，age）；
                this.p=p;
        }
继承person2可以是因为person没有有参数的构造方法。
}

明白了，感谢大家的回复。