封装、继承、重写和重载

封装：将类里面的成员变量和方法私有化，如果外界要访问，向外面提供一个统一访问的方法。

变量的封装

 //    private int age;

    //    public void Setage(int value)
    //        {
    //            if (value>0&&value<100)
    //            {
    //                age = value;
    //            }
    //        }
    //    public int Getage()
    //    {
    //        return age;
    //    }
    //

    //可以改成属性
    //    public int Age
    //{
    //    set;
    //    get;
    //}

方法的封装

 public void NewFun()
        {
            Age(12);
        
        }

        private void Age(int age)
        {
            Console.WriteLine("我的年龄是："+age);
        }

好处：减少耦合（减少相互访问的次数，私有的变量方法只能被特定的公开方法访问）

防止外界的修改

实现方法：1、编写public方法进行私有变量和方法的封装。

2、属性

继承：创建一个新的类（派生类/子类），可以继承现有类（基类/父类）的特性，并且还可以修改和扩充

1、父类只能有一个，子类可以有好多

2、子类能不能调用父类里的方法取决于父类里面的方法

public外界能访问，子类可以访问；

private外界不能访问，子类不能访问，只能自己用；

protected子类可以访问，外界不能访问

子类继承父类方法，但是子类方法名和父类的一致，这里我们需要覆写父类中的方法

 public class Laowang
    {
        public void play()
        {
            Console.WriteLine("我要去喝酒");
        }
        //虚方法
        //所有的虚方法可以重写
        public virtual void Eat()
        {
        }

    }
    public class Xiaowang : Laowang
    {
        //覆写，覆盖
        public new void play()
        {
            Console.WriteLine("我要去玩");
        }
        //重写
        public override void Eat()
        {
        }
    }

第一种是覆写，这里不提倡使用第二种是重写，也就是我们的虚方法，子类有自己的个性，想Eat自己的，这里我们外界调用xiaowang的Eat的时候只会输出小王的Eat，但是有时候我们子类想在父类的及基础上再加自己的Eat，即两个Eat都输出，这里我们就要使用

public class Xiaowang : Laowang
    {
        //覆写，覆盖
        public new void play()
        {
            Console.WriteLine("我要去玩");
        }
        //重写
        public override void Eat()
        {
            base.Eat();
        }
    }

base关键字可以在继承父类的基础上添加子类的方法

public class Laowang
    {
        public Laowang()
        {
        }
    }
    public class Xiaowang : Laowang
    {
        public Xiaowang()
        {
        }
    }

构造函数的继承

 public class Laowang
    {
        public Laowang()
        {
            Console.WriteLine("老王");
        }
    }
    public class Xiaowang : Laowang
    {
        public Xiaowang()
        {
            Console.WriteLine("小王");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Xiaowang xw = new Xiaowang();
            Console.ReadKey();
        }
    }

构造函数的继承和方法的继承是不同的，这里我们可以理解子类的构造函数自带base，所以结果子类父类的构造函数都会输出

而带参数的构造函数

public class Laowang
    {
        public Laowang(int age)
        {
            Console.WriteLine("老王"+age);
        }
    }
    public class Xiaowang : Laowang
    {
        public Xiaowang(int age) :base(age)
        {
            Console.WriteLine("小王" + age);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Xiaowang xw = new Xiaowang(age: 20);
            Console.ReadKey();
        }
    }

子类的构造方法需要加上base（参数名），这样子类和父类都能输出

重载：同名不同参（方法名相同，但是里面的参数不同）

封装、继承、重写和重载

猜你喜欢