C#面向对象基础知识学习

最新推荐文章于 2024-10-29 18:57:39 发布

马一林

最新推荐文章于 2024-10-29 18:57:39 发布

阅读量216

点赞数

文章标签： c#

本文链接：https://blog.youkuaiyun.com/qq_29760029/article/details/103911579

版权

面向过程

面向过程：面向的是完成这件事儿的过程，强调的是完成这件事儿的动作。
思想来解决这件事儿，当执行这件事的人的不同的时候，
我们需要为每个不同的人量身定做解决事情的方法。

面向对象

找个对象帮你做事。

class 类名
{
字段;
属性;
方法;
}

//创建Person类
public class Person
    {
    	//字段
        public  string _name;
        public  int _age;
        public  char _gender;
        //方法，static是静态方法，不加是非静态的方法
        public void Doing()
        {
            Console.WriteLine("我是{0}，我{1}岁，我是{2}生", this._name, this._age, this._gender);
        }
    }

写好了一个类之后，我们需要创建这个类的对象，那么，我们管创建这个类的对象过程称之为类的实例化。
使用关键字 new.
this:表示当前这个类的对象
类是不占内存的，而对象是占内存的

class Program
    {
        static void Main(string[] args)
        {
            //创建person对象
            Person person = new Person();
            //Person类的字段person对象赋初值
            person._name = "123";
            person._gender = '男';
            person._age = 33;
            //调用Person类中的方法
            person.Doing();
        }
    }

属性

属性的作用就是保护字段、对字段的赋值和取值进行限定。
属性的本质就是两个方法，一个叫get()一个叫set()。
既有get()也有set()我们诚之为可读可写属性。
只有get()没有set()我们称之为只读属性
没有get()只有set()我们称之为只写属性

Field字段
Method方法
Property属性

public class Person
    {
        public  string _name;
        //字段的属性，属性没有存值，对字段再处理，过渡
        public string Name
        {
            //取值，本质就是一个方法，当输出属性的值的时候，会执行get方法
            //（本实例是在 Console.WriteLine("我是{0}，我{1}岁，我是{2}生", this.Name, this._age, this._gender)时候取值执行;
            get { return _name; }
            //设置，本质就是一个方法，当给属性赋值的时候，首先会执行set方法
            //（本实例在main函数调用赋值时候执行person._name = "张灿";）。
            set { _name = value; }
        }
        public  int _age;
        public int Age
        {
            get { return _age; }
            //对age设置范围
            set {
                if (value<0||value>120)
                {
                    value = 0;
                }
                    _age = value;
                 }
        }
        public  char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }
        public void Doing()
        {
            Console.WriteLine("我是{0}，我{1}岁，我是{2}生", this.Name, this.Age, this.Gender);
        }
    }

访问修饰符

public：公开的公共的，在哪都能访问。
private：私有的，只能在当前类的内部进行访问，出了这个类就访问不到了。

当我们创建好一个类的对象后，需要给这个对象的每个属性去赋值。
我们管这个过程称之为对象的初始化。

person方法设置

public class Person
    {
        //字段私有private，属性公共public，字段给属性存数值。
        private string _name;
        //字段的属性，属性没有存值，对字段再处理，过渡
        public string Name
        {
            //取值，本质就是一个方法，当输出属性的值的时候，会执行get方法
            //（本实例是在 Console.WriteLine("我是{0}，我{1}岁，我是{2}生", this.Name, this._age, this._gender)时候取值执行;
            get { return _name; }
            //设置，本质就是一个方法，当给属性赋值的时候，首先会执行set方法
            //（本实例在main函数调用赋值时候执行person._name = "张灿";）。
            set { _name = value; }
        }
        private int _age;
        public int Age
        {
            get { return _age; }
            set {//赋值的时候设置
                    if (value<0||value>120)
                    {
                        value = 0;
                    }
                    _age = value;
                }
        }
        private char _gender;
        public char Gender
        {
            get {//取值的时候设置
                    if (_gender != '男' && _gender != '女')
                    {
                        return _gender='男';
                    }
                    else
                    {
                        return _gender;
                    }
                 }
            set { _gender = value; }
        }
        public void Doing()
        {
            Console.WriteLine("我是{0}，我{1}岁，我是{2}生", this.Name, this.Age, this.Gender);
        }
    }

main函数调用

class Program
    {
        static void Main(string[] args)
        {
            //创建person对象
            Person person = new Person();
            //Person类的字段person对象赋初值
            person.Name = "张灿";
            person.Gender = '春';
            person.Age = 33;
            //调用Person类中的方法
            person.Doing();
        }
    }

静态和非静态的区别

在非静态类中，既可以有实例成员，也可以有静态成员。
在调用实例（非静态）成员的时候，需要使用对象名.实例成员;
在调用静态成员的时候，需要使用类名.静态成员名;

总结：

静态成员必须使用类名去调用，而实例成员使用对象名调用。
静态函数中，只能访问静态成员，不允许访问实例成员。(静态只能在静态圈子里玩)
实例函数中，既可以使用静态成员，也可以使用实例成员。（实例都可以玩）
静态类中只允许有静态成员，不允许出现实例成员。（静态类不允许实例化）

使用：

如果你想要你的类当做一个 “工具类”（例如Console.WriteLine(),不需要创建对象，直接类名点调用，方便） 去使用，这个时候可以考虑将类写成静态的。
静态类在整个项目中资源共享。只有在程序全部结束之后，静态类才会释放资源。
《堆栈静态存储区域》
释放资源 GC Garbage Collection垃圾回收器

构造函数

作用：帮助我们初始化对象(给对象的每个属性依次的赋值)
构造函数是一个特殊的方法：
1)、构造函数没有返回值，连void也不能写。
2)、构造函数的名称必须跟类名一样。
创建对象的时候会执行构造函数
构造函数是可以有重载的。
类当中会有一个默认的无参数的构造函数，当你写一个新的构造函数之后，不管是有参数的还是无参数的，那个默认的无参数的构造函数都被干掉了。

创建构造函数

class Student
    {
    	//系统会自创建一个无参数的构造函数，没有Void和static修饰
        //构造函数必须是public，可以重载
        public Student(String name,int age,char gender,int chinese,int math,int english)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
            this.Chinese = chinese;
            this.Math = math;
            this.English = english;
        }
        //重载构造函数
        public Student(String name,int age,char gender,int chinese)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
            this.Chinese = chinese;
        }
       
        //字段
        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; }
        }
        private int _chinese;
        public int Chinese
        {
            get { return _chinese; }
            set { _chinese = value; }
        }
        private int _math;
        public int Math
        {
            get { return _math; }
            set { _math = value; }
        }
        private int _english;
        public int English
        {
            get { return _english; }
            set { _english = value; }
        }
        public void SayHello()
        {
            Console.WriteLine("大家好，我是{0}，我{1}岁了，我是{2}生",this.Name,this.Age,this.Gender);
        }
        public void Chengji()
        {
            Console.WriteLine("我语文考了{0}分，数学考了{1}分，英语考了{2}分,总分{3}，平均分{4}",
                this.Chinese, this.Math, this.English, (this.Chinese + this.Math + this.English), (this.Chinese + this.Math + this.English) / 3);
            Console.ReadKey();
        }
    }

main函数调用构造函数

class Program
    {
        static void Main(string[] args)
        {
       	    //调用构造函数
            Student ZS_student = new Student("张三", 12, '男', 60, 100, 20);
            ZS_student.SayHello();
            ZS_student.Chengji();
        }
    }

new关键字

Person zsPerson=new Person();
new帮助我们做了3件事儿：

在内存中开辟一块空间
在开辟的空间中创建对象
调用对象的构造函数进行初始化对象

this关键字

代表当前类的对象
在类当中显示的调用本类的构造函数 :this
实例：

 //构造函数
        public Student(string name, int age, char gender, int chinese, int math, int english)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
            this.Chinese = chinese;
            this.Math = math;
            this.English = english;
        }
        public Student(string name, int age, char gender, int chinese): this(name,age,gender,chinese,0,0)
        {
            //this.Name = name;
            //this.Age = age;
            //this.Gender = gender;
            //this.Chinese = chinese;
            //this.Math = math;
            //this.English = english;
        }