C#简单笔记05:方法重载overload,递归,构造和析构,面向对象,封装和继承,base,new

最新推荐文章于 2023-05-01 19:38:46 发布

申佳明哥哥

最新推荐文章于 2023-05-01 19:38:46 发布

阅读量214

点赞数

分类专栏： C#和.NET学习

本文链接：https://blog.csdn.net/ishenjiaming/article/details/99619637

版权

C#和.NET学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

方法重载

    class MyClass
    {
        //重载要求:多个方法名相同.参数类型不同.
        //参数个数可以不同。
        //注意:方法重载与方法返回值类型无关(方法返回值类型不同,不算重载)
        public int Sum(int a, int b)
        {
            return a + b;
        }
        public int Sum(int a, int b,int c)
        {
            return a + b + c;
        }
        public float Sum(float a, float b)
        {
            return a + b;
        }
        public double Sum(double a, double b)
        {
            return a + b;
        }
    }
    class Program
    {   static void Main(string[] args)
        {   MyClass c = new MyClass();
            //在调用重载方法时,系统自动根据参数类型和个数匹配不同的方法
            Console.WriteLine(c.Sum(5, 15));
            Console.WriteLine(c.Sum(5, 15, 555));
            Console.WriteLine(c.Sum(5.0005, 15.11115));

            Console.ReadKey();             
        }
    }

递归

注意:递归算法很容易就崩溃.应尽量避免.例如求斐波那契数列,虽然递归算法写出来简洁优美,但是稍微大点的数就崩溃,此时不妨考虑非递归的算法.

构造和析构

构造方法

//构造方法:负责初始化对象.在对象被实例化时由系统自动调用.
//要求:1.构造方法名和类名必须相同
//要求:2.构造方法无返回值,不需要写void.写了反而出错.
//*构造方法是方法,因此允许重载
//*如果没有构造方法,系统会提供1个默认构造
//*某个构造方法可以设为private.之后会禁止外部使用此构造方法实例化对象

//析构方法:在对象销毁时由系统自动调用,用于释放内存等操作
//1每个类只能有1个析构方法
//2析构方法不能有返回值
//3析构方法不能有访问权限修饰符
//4析构方法没有参数,也没有重载
//5析构方法由系统销毁对象时调用,不允许手动调用

class Person {
        public string name;
        public int age;
        //构造方法:负责初始化对象.在对象被实例化时由系统自动调用.
        //要求:1.构造方法名和类名必须相同
        //要求:2.构造方法无返回值,不需要写void.写了反而出错.
        //*构造方法是方法,因此允许重载.
        //*如果没有构造方法,系统会提供1个默认构造
        //*某个构造方法可以设为private.之后会禁止外部使用此构造方法实例化对象
        public Person() { }//不带参数的重载,允许new时不加参数
        public Person(string name, int age) {//带参数的重载            
            this.name = name;
            this.age = age;
            Console.WriteLine("构造");
        }
        public void ShowInfo() {
            Console.WriteLine("我的姓名叫" + this.name);
            Console.WriteLine("我的年龄是" + this.age +"岁");
        }
        //析构方法:在对象销毁时由系统自动调用,用于释放内存等操作
        //1每个类只能有1个析构方法
        //2析构方法不能有返回值
        //3析构方法不能有访问权限修饰符
        //4析构方法没有参数,也没有重载
        //5析构方法由系统销毁对象时调用,不允许手动调用
        ~Person() {
            Console.WriteLine("析构");
            Console.ReadKey();
        }
    }
    class Program {
        static void Main(string[] args) {
            //使用new实例化对象时,系统自动调用构造方法初始化对象            
            Person somebody = new Person("孙悟空",500);
            somebody.ShowInfo();            
        }
    }

面向对象

面向对象思想:

把大象塞进冰箱

推而广之-->

把xx塞进冰箱

扩充功能-->为冰箱添加各种功能

......

封装和继承

面向对象三大特性:封装,继承,多态

如果我们定义了冰箱类.并给冰箱类定义了"打开"的方法.则可以在该方法中封装冰箱打开的代码.

外部调用的时候只须调用冰箱.打开()方法.它没有必要也没有权限看到冰箱.打开()内部的代码.这就是封装.

类似我们普通用户在使用遥控器控制电视台转台,调整声音大小等.至于遥控器内部是如何完成这些操作的,普通用户是看不到也无权看到的.这就是封装

*由于本讲座继承内容讲的太少,本节笔记再补充以下讲座的笔记:

黑马程序员https://www.bilibili.com/video/av8915750/?p=115 继承

访问修饰符
public:所有皆可访问.
internal:在同一程序集的可访问
protected:保护的,仅在当前类或派生类可访问.
private:私有的,仅在当前类或结构可访问
类的访问修饰符可以为 public或internal. 默认为 internal

类成员的访问修饰符可以为 public, protected internal, protected, internal, private,  private protected. 
默认为private

子类成员无法继承父类的private成员.它可以继承父类的public, internal, protected成员

问:子类有没有继承父类的构造函数?

答:子类并没有继承父类的构造函数.但是子类会默认的调用父类的无参数的构造函数(因为要)先创建父类对象,让子类可以使用父类中的成员.如果父类还有父类,依此类推先创建父类的父类对象...

所以,如果在父类中重写了1个有参数的构造函数之后,那么(系统默认生成的)无参数的就被干掉了,子类就调用不到了,所以子类会报错.

解决方法:1.在父类中的写一个无参数的构造函数.(不推荐)

解决方法:2.在子类中显示的调用父类的构造函数(改变默认调用),使用关键字:base()

class Grandpa {
        public string name;
        public Grandpa() { Console.WriteLine("Grandpa()构造方法"); }
        public Grandpa(string name){Console.WriteLine("Grandpa(string name)构造方法");
        }
    }    
    class Dad : Grandpa {
        public Dad() { Console.WriteLine("Dad()构造方法"); }
        public Dad(string name) { Console.WriteLine("Dad(string name)构造方法"); }
    }
    class Son : Dad {
        public Son() { Console.WriteLine("Son()构造方法"); }
        public Son(string name) { Console.WriteLine("Son(string name)构造方法"); }
    }
    class MainClass
    {
        static void Main(string[] args)
        {
            Son a = new Son();
            Console.WriteLine("..................");

            Son b = new Son("Jack");
            Console.WriteLine("..................");
            Console.ReadKey();
        }
    }

base 关键字

base 关键字用于从派生类中访问基类的成员：

调用基类上已被其他方法重写的方法。
指定创建派生类实例时应调用的基类构造函数。

class Person {
        private string _name;        
        private int _age;
        public string Name { get => _name; set => _name = value; }        
        public int Age { get => _age; set => _age = value; }
        public Person() {
            Console.WriteLine("调用Person()构造方法");
        }
        public Person(string name,int age) {
            this.Name = name;
            this.Age = age;
            Console.WriteLine("调用Person(string name,int age)构造方法");
        }
    }
    class Student : Person {        
        private string _school;        
        public string School { get => _school; set => _school = value; }
        public Student(string name, int age,string school)
            :base(name,age)
            //调用父类的构造方法 - 参数类型为(string name,int age)格式的构造方法
        {   this.School = school;
            Console.WriteLine("调用Student(string name, int age,string school):base(name, age)构造方法");
        }
    }
    class MainClass
    {   static void Main(string[] args)
        {
            Student s = new Student("小明",18,"家里蹲大学");
            Console.ReadKey();            
        }
    }

如上,使用子类的构造方法使用base关键字先调用父类带参数构造方法.

①主程序new了1个Student对象后,根据代码,调用了Students的父类Person类的带参数构造方法public Person(string name,int age).

②然后调用Student类自己的构造方法public Student(string name, int age,string school) :base(name,age).

new关键字

隐藏从父类那里继承过来的同名成员

如上,Man类型的对象m调用的是Man.sayHello()方法.

如果调用子类方法时想同时调用父类方法,可使用base关键字.

如上Man类型的对象m调用的是Man.sayHello()方法,在该方法中又先调用了父类Person.sayHello()方法.

class Person {
        public void sayHello() {
            Console.WriteLine("我是人!");
        }
    }
    class Man : Person {
        new public void sayHello() {
            base.sayHello();//调用基类sayHello方法
            Console.WriteLine("我是男人");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Man m = new Man();
            m.sayHello();
            Console.ReadKey();
        }
    }