C#面向对象学习笔记（1）

面向对象

面向对象与面向过程

面向过程：面向的是完成这件事的过程，强调的是完成这件事的动作。

如果我们用面向过程的思想来解决这件事，当执行这件事的人不同的时候，我们需要为每个不同的人量身定做解决事情的方法。

面向对象：找个对象帮你做事。意在写出一个通用的代码，屏蔽差异

对象

我们在代码中描述一个对象，通过描述这个对象的属性和方法

我们把这些既有相同属性和相同方法的对象进行进一步的封装，抽象出来 类 这个概念

类就是个模子，确定了对象应该具有的属性和方法

对象是根据类创建出来的
类是抽象的，对象是具体的

类

        [public] class 类名
        {
            字段;
            属性;
            方法;
            构造函数;
        }

写好了一个类之后，我们需要创建这个类的对象，那么，我们管创建这个类的对象过程称之为类的实例化。

使用关键字new

this：表示当前这个类的对象。

类是不占内存的，而对象是占内存的。

namespace _01.net.demo1
{
     public class Person
    {
        public string _name;
        public int _age;
        public char _gender;

        public void CHLSS()
        {
            Console.WriteLine("我叫{0},我今年{1}岁了，我是{2}生，我可以吃喝拉撒睡",this._name,this._age,this._gender);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Person sunQuan =new Person();
            sunQuan._name = "孙全";
            sunQuan._age = 23;
            sunQuan._gender = '男';
            sunQuan.CHLSS();
        }
    }
}

属性

属性的作用就是保护字段、对字段的赋值和取值进行限定。

过渡的作用

属性的本质就是两个方法：

1. get()----对属性进行取值
2. set()----对属性进行赋值

有get()set()–可读可写属性

有get()–只读属性

有set()–只写属性

Field 字段

Metho 方法

Property 属性

字段就是女人，属性才是男人

字段受属性保护，属性在外不断储存与调用

namespace _01.net.demo1
{
    public class Person
    {
        private string _name;//字段，字段私有
        public string Name//属性
        {
            //当你输出属性的值的时候 会执行get()方法
            get { return _name; }
            //当你给属性赋值的时候 首先会执行set()方法
            set { _name = value; }
        }

        private int _age;
        public int Age
        {
            get { return _age; }
            set
            {
                if (value < 0 || value > 100)
                {
                    value = 0;
                }
                _age = value;
            }
        }

        private char _gender;
        public char Gender
        {
            get
            {
                if(_gender!='男'&&_gender!='女')
                {
                    return _gender = '男';
                }
                return _gender;
            }
            set { _gender = value; }
        }
        public void CHLSS()//方法
        {
            Console.WriteLine("我叫{0},我今年{1}岁了，我是{2}生，我可以吃喝拉撒睡", this.Name, this.Age, this.Gender);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Person sunQuan =new Person();
            sunQuan.Name = "孙全";
            sunQuan.Age = 23;
            sunQuan.Gender = '男';
            sunQuan.CHLSS();
            Console.ReadKey();
        }
    }
}

访问修饰符

public：公开的公共的，在哪都能访问。

private：私有的，只能在当前类的内部进行访问，出了这个类就访问不到了。类中的成员如果不加访问修饰符，默认都是private

静态和非静态的区别

1. 在非静态类中，既可以有实例成员，也可以有静态成员。
2. 在调用实例成员的时候，需要使用

        对象名.实例成员;

在调用静态成员的时候，需要使用

        类名.静态成员名;

静态成员必须使用类名去调用，而实例成员使用对象名调用

静态函数中，只能访问静态成员，不允许访问实例成员

实例函数中，既可以使用静态成员，也可以使用实例成员

静态类中只允许有静态成员，不允许出现实例成员

静态类不允许类的实例化(不能new)

使用：

1. 如果你想要你的类当作一个“工具类”去使用，这个时候可以考虑将类写成静态的
2. 静态类在整个项目中资源共享
3. 只有在程序全部结束后，静态类才会释放资源

构造函数

作用：帮助我们初始化对象（给对象的每个属性依次赋值）

构造函数是一个特殊的方法：

1. 构造函数没有返回值，连void也不能写。
2. 构造函数的名称必须跟类名一样

构造函数可以有重载的

    public class Person
    {
        public Person(string name,int age,char gender)//构造函数的函数名必须和类名相同
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }
        public Person(string name,int age)//构造函数的重载
        {
            this.Name = name;
            this.Age = age;
        }
    }
        static void Main(string[] args)
        {
            Person sunQuan =new Person("张三",18,'男');
        }

创建对象的时候先会调用构造函数

类当中会有一个默认的无参数的构造函数，当你写了一个新的构造函数之后，不管是有参数的，还是无参数的，那个默认的无参数的构造函数都被干掉了