第十篇——面向对象

一、面向对象概念

1、由面向过程——到面向对象

面向过程：面对完成事件的过程，强调完成事件的过程

不足：用面对过程的思维解决需一件事，当完成这件事的执行人不同时，我们要为每个不同的人量身定做解决这件事

特点：语法主动

把大象塞进冰箱：把执行人作为对象
1、打开冰箱门
2、把大象塞进冰箱
3、关闭冰箱门

面向对象：找个对象帮我完成一件事

好处：尽量写出通用代码，规避执行人指之间的不同

特点：语法被动

把大象塞进冰箱：把冰箱作为对象
1、冰箱门可以被打开
2、大象可以被塞进冰箱
3、冰箱门可以被关闭

描述对象：描述对象的属性（特征）和方法 （行为）

对象：一定具体到能看到见摸得着

笔记本               不是对象
我面前的这台笔记本      是对象

2、类的基本语法

类的概念

类：确定对象将会拥有的特征（属性）和行为（方法）

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

类就是个模子，确定对象应该具有的特征（属性）和行为（方法）

对象是根据类创建出来的

白马非马

马为类
白马为马类下的对象

类的基本语法

语法

[public] class 类名
{
    字段;
    属性;

    方法;
}

    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);//this 当前类的对象
        }

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

使用关键字: new. 

        static void Main(string[] args)
        {
            //创建Person类的过程 Person类实例化
            Person feng = new Person();
            feng._age = 23;
            feng._name = "冯某";
            feng._gender = '男';
            feng.CHLSS();
            Console.ReadKey();
        }
    }

类不占内存，对象占内存

3、属性

属性的作用就是保护字段，对字段的赋值和取值进行限定，起过度作用

本质是两个方法：get(控制取值) 和 set （控制赋值）

有get（）,也有set（）,称之为可读可写属性；

只有get（）,没有set（）,称之为只读属性；

没有get（）,只有set（）,称之为只写属性；

    public class Person
    {
        //字段形式声明属性用来表示对象的特征
        private string _name; //访问修饰符：private 只能在类内部访问
        public string Name
        {
            get { return _name; }
            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);//this 当前类的对象 Name 执行 get；_name 只执行set;
        }
    }

Field 字段  Method 方法 Property 属性

访问修饰符：

public: 公开的、公共的，都能访问

private ：私有的，只有当前类内部才能访问，出了类就不能访问。不写public 默认为 private

属性初始化

        static void Main(string[] args)
        {
            //创建Person类的过程 Person类实例化
            Person feng = new Person();
            feng.Age = -23;//创建类之后给类的属性进行赋值，称为对象的初始化
            feng.Name = "冯某";
            feng.Gender = '夏';
            feng.CHLSS();
            Console.ReadKey();
        }

4、.的区别wmv

静态方法与非静态方法的区别

1、非静态中既可有实例成员也可有静态成员

2、非静态调用：对象名.非静态成员名

静态调用：类名.静态成员名

即静态成员必须用类名调用，非静态成员都用对象名调用

3、静态函数中只允许用静态成员，不允许使用实例成员

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

二者使用

1、如果使用的类是一个”工具类“，可以考虑写成静态类

2、静态类在整个项目中资源共享，不要过多使用，占用资源

只有在程序运行结束之后才会释放资源

堆        栈        静态存储资源

释放资源：GC Garbage Collection 垃圾回收器

5、构造函数

作用：帮助我们快捷的初始化对象（给对象的每个属性依次赋值）；可以有重载

构造函数是一个特殊的方法（原因）：

1、没有返回值，连void也不能写

2、构造函数的名称与类名相同

-------------------------------------------------------

类当中自带一个默认的无参的构造函数，当你写了一个构造函数后，无论有无参都会替代掉默认的

-------------------------------------------------------

创建对象的时候使用构造函数

    internal class Student
    {
        public Student(string name,int age,char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

        private int _age;
        public int Age
        {
            get { 
                if(_age < 0 || _age > 100)
                {
                    return _age = 0;                        
                }
                return _age; }
            set { _age = value; }
        }
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set {
                if(value != '男'&& value != '女')
                {
                    _gender = '男';
                }
                _gender = value; }
        }
        public  void  N2 ()
        {
            Console.WriteLine("我是{0}，今年{1}岁，我是{2}生", Name, Age, Gender);
        }
    }

new 关键字

帮助我们做了三件事

1、在内存堆中开辟空间

2、在开辟的空间中创造对象

3、调用对象的构造函数进行初始化对象

        static void Main(string[] args)
        {
            Student zsStudent = new Student("张三",21,'中');
            //zsStudent.Name = "张三";
            //zsStudent.Age = 21;
            //zsStudent.Gender = '夏';

            zsStudent.N2();
            Console.ReadKey();
        }

6、this关键字

两个作用

1、代表当前类的对象

this.实例名

2、在类当中的其他构造函数

调用被包含的上级构造函数，减少冗余代码

        public Student(string name,int age,char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

        public Student(string name,int age)：this(name,age，'c')
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

        public Student(string name):this(name,0,'c')
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

7、析构函数

区分于构造函数，程序结束的时候才会执行

作用：帮助我们释放资源

区别于GC：希望立即释放资源，可以使用析构函数；不然等待GC自动释放即可

    internal class Student
    {
        ~Student()
            {
        Console.WriteLine("我是析构函数");
            }    
    }

8、总结