C#编程--面向对象

最新推荐文章于 2021-12-15 16:23:34 发布
最新推荐文章于 2021-12-15 16:23:34 发布
阅读量324 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37855507/article/details/86760471
版权

C# 面向对象：

类

    public class Student
    {
        //构造函数。
        //构造函数函数名和类名必须相同，并且不能有返回值。
        public Student()
        {
        }
        //构造函数重载。
        public Student(string name,string age,string gender,string sid)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
            this.SId = sid;
        }
        //创建类的属性。
        public string Name
        {
            get;
            set;
        }
        public string Age
        {
            get;
            set;
        }
        public string Gender
        {
            get;
            set;
        }
        public string SId
        {
            get;
            set;
        }
        //类中的方法体;
        public void SayHi()
        {
            Console.WriteLine("hi!!!");
        }
    }

实例化类：

        static void Main(string[] args)
        {
            Student stu = new Student("王云飞", "21", "研一", "321");
            Console.WriteLine(stu.Name);
            Console.ReadKey();
        }

添加引用与导入命名空间的区别：

  • 添加引用（前提）： 添加程序集
  • 导入命名空间 ： namespace(shift+alt+F10)

变量作用域： 离声明该变量最近的那对包含声明语句的大括号内部。

1. 封装：

  • 字段可以封装成为属性。
    属性封装的用处： 可以对字段进行限制。
        private int _age;
        public int _Age
        {
            get { return _age; }
            set
            {
                if(value<0 || value>=120)
                {
                    throw new Exception("年龄有错！");
                }
                else
                {
                    _age = value;
                }
            }
        }

2. 继承：

继承的好处：

一、代码重用；

    //基类
    class Person
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public int Hright
        {
            get;
            set;
        }
    }
    //类的继承
    //继承具有 “单根性”。 子类只能继承自一个父类。
    //继承具有 ”传递性”。 
    class Student :Person
    {
        public void SayHi()
        {
            Console.WriteLine("hi!");
        }
    }
    //类的继承
    class Teacher :Person
    {

    }
  1. 任何一个类，若没有继承，那他默认是继承自object。
  2. 继承具有 “单根性”。 子类只能继承自一个父类。
  3. 继承具有 ”传递性”。

继承中构造函数的问题：

当一个子类继承父类之后，该子类中的所有构造函数默认情况下，在自己被调用之前都会先调用一次父类的无参数的构造函数。如果此时父类中没有无参数的构造函数，则会报错。
该问题的解决方法有：

  1. 解决方法一：在父类中添加无参构造函数。
        //解决方法一：在父类中添加无参构造函数。
        //无参数构造函数
        public Person()
        {
        }
        //基类 构造函数的重载。
        public Person(string name,int age,int height)
        {
            this.Name = name;
            this.Age = age;
            this.Height = height;
        }
  1. 解决方法二：在子类的构造函数后面通过：base()的方式，指明指定要调用父类中的那个构造函数。
    ：base() 表示调用父类的构造函数。 //构造函数是不能被继承的。只能被调用。
       //解决方法二：在子类的构造函数后面通过：base()的方式，指明指定要调用父类中的那个构造函数。
        public Student(string name,int age,int height,string sid)
            :base(name,age,height)  //：base() 表示调用父类的构造函数。 //构造函数是不能被继承的。只能被调用。
        {
            this.SId = sid;
        }

    class Person
    {
        //解决方法一：在父类中添加无参构造函数。
        //无参数构造函数
        public Person()
        {
        }
        //基类 构造函数的重载。
        public Person(string name,int age,int height)
        {
            this.Name = name;
            this.Age = age;
            this.Height = height;
        }
        

        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public int Height
        {
            get;
            set;
        }
    }
    class Student:Person
    {
        //当一个子类继承父类之后，该子类中的所有构造函数默认情况下，在自己被调用之前都会先调用一次父类的无参数的构造函数。如果此时父类中没有无参数的构造函数，则会报错。
        //构造函数
        public Student(string name,int age,int height,string sid) 
        {
            this.Name = name;
            this.Age = age;
            this.Height = height;
            this.SId = sid;
        }
        //解决方法二：在子类的构造函数后面通过：base()的方式，指明指定要调用父类中的那个构造函数。
        public Student(string name,int age,int height,string sid)
            :base(name,age,height)  //：base() 表示调用父类的构造函数。 //构造函数是不能被继承的。只能被调用。
        {
            this.SId = sid;
        }

        public string SId
        {
            get;
            set;
        }
    }
    class Teacher:Person
    {
        //构造函数
        public Teacher(string name, int age, int height, string enpid)
        {
            this.Name = name;
            this.Age = age;
            this.Height = height;
            this.EmpId = enpid;
        }
        public string EmpId
        {
            get;
            set;
        }
   }
使用this 调用自己的构造函数。

使用this来调用当前类（本类）中的其他构造函数。

    class Person
    {
        public Person()
        {
        }
        public Person(string name,int age,int height)
        {
            this.Name = name;
            this.Age = age;
            this.Height = height;
        }
        //使用this来调用当前类（本类）中的其他构造函数。
        public Person(string name)
            :this(name,0,0)
        {
             // this.Name = name;
        }
        ......
     }

3. 多态 —— 增加程序的可扩展性、灵活性。

通过虚方法实现多态。
多态： 同样一句话，根据对象的不同，调用的方法不同。

    class Program
    {
        static void Main(string[] args)
        {
            //Person p1 = new American();
            Person[] pers = new Person[5];
            pers[0] = new American();
            pers[1] = new Japanese();
            pers[2] = new Chinese();
            pers[3] = new Japanese();
            pers[4] = new American();
            //遍历person数组
            for(int i=0;i<pers.Length;i++)
            {
                //希望此处只有一句话，说出各个国家的国籍
                pers[i].SayNationlity();    //该句代码体现了多态。（同样一句话，根据对象的不同，调用的方法不同。）           
            }
            Console.ReadKey();
        }
    }
    class Person
    {
        public Person()
        {
        }
        public Person(string name,int age,int height)
        {
            this.Name = name;
            this.Age = age;
            this.Height = height;
        }
        public Person(string name)
            :this(name,0,0)
        {
        }

        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public int Height
        {
            get;
            set;
        }
        //第一步：将父类中的对应方法前加virtual关键字。即：将对应的方法变为“虚方法”。
        
        public virtual void SayNationlity()
        {
            Console.WriteLine("地球人");
        }
    }
    class American :Person
    {
        //通过使用override关键字，将父类Person中的虚方法“SayNationlity”重写为子类自己想要的。
        //说出自己的国籍。
        public override void SayNationlity()
        {
            Console.WriteLine("usa");
        }
    }
    class Japanese :Person
    {
        //说出自己的国籍。
        public override void SayNationlity()
        {
            Console.WriteLine("日本");
        }
    }
    class Chinese:Person
    {
        //说出自己的国籍。
        public override void SayNationlity()
        {
            Console.WriteLine("中国");
        }
    }
溪午X
关注
C#（面向对象）
ye_liang_chen的博客
09-27 3540
C#（面向对象） 一、面向对象 1.概念 ​ 类可以派生形成子类（派生类），派生子类的类称为父类。对应一个系统最基本的类称为基类，一个基类可以有多个派生类，从基类派生出的类（子类）还可以进行派生。 ​ 对象是类的具体化，是具有属性和方法的实体（实例）。对象通过唯一的标识名以区别于其他对象，对象有固定的对外接口，它是对象与外界通信的通道。 2.对象、类与实例化 ​ 对象是类的具体化，是具有属性和方法的实体（实例）。对象通过唯一的标识名以区别于其他对象，对象有固定的对外接口，它是对象与外界通信的通道。 二、面
c#面向对象编程-通讯录全功能
01-02
在C#编程中，面向对象编程（Object-Oriented Programming, OOP）是一种核心的编程范式，尤其在开发复杂的软件系统时尤为重要。本教程针对初学者，如在校大学生和零基础人员，旨在帮助他们理解并掌握C#中的面向对象...
java四种访问权限private、public、protected、default
MTS的博客
10-04 953
修饰词:根据作用范围来进行划分 private默认的(default/friendly)protectedpublic同一个类中可见可见可见可见同一个包中不可见可见可见可见不同的包中有继承关系不可见不可见可见可见不同的包中没有继承关系不可见不可见不可见可见 四种访问权限： 1.public：只能修饰类、方法（含构造方法）、成员变量。其修饰的部分所有人都能访问； 2.默认修饰符default（friendly）：只能修饰类、方法（含构造方法）、成员变量。其修饰...
C#面向对象
dreamerfuture的博客
09-27 110
​一.封装 ​ 定义：将类的某些使用private将信息隐藏在本类中，不允许外部程序直接访问，但可以通过public使信息变为公共属性用以提供给外部程序访问，以此来实现对隐藏信息的操作和访问 作用：防止外部类恶意访问并随意修改本类属性 使用方法：案例 private int age;//字段私有化 public int Age //生成公共属性 { get { return age; } ...
C#面向对象编程-多态习题[整理].pdf
10-11
C#面向对象编程-多态习题[整理].pdf
c#面向对象编程的小案例 c#经典案例.pdf
05-07
"C#面向对象编程小案例：模拟彩票选号器" 本资源详细介绍了C#面向对象编程的小案例，模拟彩票选号器的实现。该案例主要使用C#语言，通过面向对象编程的思想，实现了一个彩票选号器的模拟。 知识点1：System.Random...
C#面向对象编程期末参考题
12-22
【标题】"C#面向对象编程期末参考题"揭示了本次讨论的核心——C#编程语言中的面向对象编程（Object-Oriented Programming, OOP）概念，这是软件开发中的一种重要方法论。C#是一种现代、类型安全且面向对象的语言，...
CH02-C#面向对象编程-OOP.md
12-27
2. C#中的集合 * ArrayList * HashTable * List * Dictionary,V> * 集合初始化器 3. out，ref，params关键字 4. 方法重载 5. 继承 6. 多态 * 虚方法实现多态 * 抽象方法实现多态 * 虚方法和抽象...
面向对象编程——C#
04-29
深入浅出的指导面向对象——C#的入门，各种案例强化对C#的认识。
C#的面向对象程序设计
12-23
C#的面向对象程序设计.ppt c#\C#的面向对象程序设计.pptc#\C#的面向对象程序设计.ppt
C# 面向对象
m0_51743362的博客
12-15 1099
什么是继承 继承(封装、多态)是面向对象编程三大特性之一，继承的思想就是摈弃代码的冗余，实现更好的重用性。 继承从字面上理解，无外乎让人想到某人继承某人的某些东西，一个给一个拿。这个语义在生活中，就像家族继承财产，爷爷将财产继承给儿女，儿女在将财产继承给子孙，有些东西可以继承有些的东西只继承给某人。映射到编程当中，其思想也大致如此。 继承的类型 实现继承： 表示一个类型派生于一个基本类型，它拥有该基类型的所有成员字段和函数。在实现继承中，派生类型采用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值