c#和Java中的继承

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Node.js›Node.js教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

c#和Java:

1.首先，子类继承了父类的属性和方法，但是子类并没有继承父类的私有字段。

2.子类并没有继承父类的构造函数，但是。子类会默认的调用父类无参数的构造函数，创建父类对象，让子类可以使用父类中的成员。

所以，如果在父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，子类就调用不到了，所以子类会报错。

解决办法(c#)：

1)、在父类中重新写一个无参数的构造函数。

2)、在子类中显示的调用父类的构造函数，使用关键字:base()

    public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }
        public Person(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }
    }
    public class Reporter : Person
    {
        public Reporter(string name, int age, char gender, string hobby)
            : base(name, age, gender)
        {
            this.Hobby = hobby;
        }
        private string _hobby;
        public string Hobby
        {
            get { return _hobby; }
            set { _hobby = value; }
        }
        public void ReporterSayHello()
        {
            Console.WriteLine("我叫{0},我是一名狗仔，我的爱好是{1}，我是{2}生，我今年{3}岁了",this.Name,this.Hobby,this.Gender,this.Age);
        }
    }

在Java中：有必要介绍一下super关键字：

super关键字代表了父类空间的引用。

super关键字的作用：
1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

super关键字调用父类构造方法要注意的事项：
1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。


super关键字与this关键字的区别：
1. 代表的事物不一致。
1. super关键字代表的是父类空间的引用。    
2. this关键字代表的是所属函数的调用者对象。
2. 使用前提不一致。
1. super关键字必须要有继承关系才能使用。
2. this关键字不需要存在继承关系也可使用。
3. 调用构造函数的区别：
1. super关键字是调用父类的构造函数。
2. this关键字是调用本类的构造函数。

 1 class Fu{
 2     int x = 10;
 3     String name;
 4     public Fu(){
 5         System.out.println("Fu类无参的构造方法..");
 6     }
 7     public Fu(String name){
 8         this.name = name;
 9         System.out.println("Fu类带参的构造方法..");
10     }
11     public void eat(){
12         System.out.println("小头爸爸吃番薯..");
13     }
14 }
15 class Zi extends Fu{
16     int x = 20; 
17     int num;
18     public Zi(String name,int num){
19         super(name); //指定调用了父类带参的 构造方法...
20         this(); // 调用本类无参构造方法..
21         //super(); //指定调用了父类无参构造方法。。。
22         System.out.println("Zi类带参的构造方法..");
23     }
24     public Zi(){
25         System.out.println("Zi类无参的构造方法..");
26     }
27     public void print(){
28         System.out.println("x = " +super.x);
29     }
30     public void eat(){
31         System.out.println("大头儿子吃龙虾..");
32     }
33 }
34 
35 class Demo{
36     public static void main(String[] args) 
37     {
38         Zi z = new Zi("狗娃");
39     
40     }
41 }