C#面向对象基础

基本概念

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

把大象放进冰箱：1.打开冰箱门；2.把大象塞进去3.关闭冰箱门，面向过程，如果有3个人就需要把三个人的过程都写出来，如果换放下小红，又要重新写一遍，这样就是写了6次

• 面向对象：这个对象帮你做事，在于写一个通用代码，屏蔽差异，一切皆对象

把大象放进冰箱：提炼 1.谁把（作用类，彭蟹，郭菊）2.大象（受作用类，猪猪，小红） 3.冰箱（物品类，冰箱，车子，电视机）

例如：今日 A账号，登陆天猫，爬取 热销店铺和热销商品 并且储存到数据库；
日期类（负责规定下载日期）：根据不同的规则可以 今日，昨日，当月 ，或者指定日期；
登陆类（负责生产coookie）：第一次登陆天猫，和带cookie登陆天猫，或者天猫其他平台cookie转换；
爬取类，储存类

例1：我在黑板上画了一个圆
张三上来用尺子画了一个特被圆的圆；
彭蟹上来用脚画了一个特别搓的圆；

圆圈可以被画在黑板上：圆圈作为对象，那么改为方块，对象就发生了改变。圆圈可以被画在黑板（天花板，门，地板） 上，实现了这个功能，侧重点是黑板

黑板可以被画圆圈：黑板作为对象，黑板可以被画圆圈（方形，长方形，菱形），这个功能，侧重点是图形

例2：描述 彭蟹（郭菊）的特征和行为
代码中描述一个对象，通过描述这个对象的属性（特征）和方法（行为）

例3：灯
属性： 外形，亮度，颜色，牌子
方法：发光，更换，修理

• 总结：类就是一个模子，把这些具有相同属性和方法的东西规定一个名字集合起来。而对象就是更具这个模子创建出来的（实例化）。

类的基本语法

添加类

image.png

Persion类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace cSharpTest
{
    
    public class Person
    {

        //person类的字段
        public string _name;
        public string _gender;
        public int _age;

        //person类的方法
        public void Action()
        {
            Console.WriteLine("My name is {0},my gerden is {1},my age is {2} and I am eating,drinking,pooing,sleeping",_name,_gender,_age);
        }
    }
}

Fxx类

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {
            Person fxx = new Person();
            fxx._name = "Fxx";
            fxx._gender = "female";
            fxx._age = 14;
            fxx.Action();
        }
    }
}

• 要想在Fxx类里面实例化Person类 必须两个具有相同的mignmign

类的属性

属性的作用是保护字段，对字段的赋值和取值进行限制
属性的本质就是两个方法get（取值） 和set（赋值）
字段不要暴露，属性交互使用

namespace cSharpTest
{
    
    public class Person
    {
 
        //person类的字段,类似于python的私有属性，不要写public
        private string _name;
        public string name
        {
            //取值时，执行get方法
            get { return _name; }
            //当给属性赋值时，首先调用set方法
            set { _name = value; }
        }

        private string _gender;
        public string gender
        {
            get
            {
                if (_gender != "男" && _gender != "女")
                {
                    return _gender = "男";
                }
                
                return _gender; }
            set { _gender = value; }
        }

        private int _age;
        //类的属性：对字段的取值和赋值进行限制
        public int age
        {
            get { return _age; }

            set { 
                    if(value<0 || value > 120)
                {
                    value = 0;
                }
                _age = value; }
        }

        //person类的方法，非static方法
        public void Action()
        {
            Console.WriteLine("My name is {0},my gerden is {1},my age is {2} and I am eating,drinking,pooing,sleeping",this.name,this.gender,this.age);
        }
    }
}

访问修饰符

public：公开的 公共的
private：私有的，只能在当前类内部访问
protected：受保护，类内部和子类中
internal：只能在当前项目中访问，同一个项目中和public的权限是一样的
protected internal： protected+internal

• 能修饰类的修饰符只有两个：public，internal
• 可访问性不一致：子类的访问权限不能高过父类
• 在非静态类中，既可以有实例成员，也可以有静态成员
• 在调用实例成员的时候需要：对象名.方法名
• 调用静态方法时候：类名.方法名，只要是静态成员 不管是方法还是属性，都必须使用该方法调用；
• 总结：

1. 静态成员必须使用类名调用，实例成员必须对象名调用，
2. 静态函数中，只能访问静态成员，不能访问实例成员；
3. 实例函数中，两个都可以使用；
4. 静态类只有放静态成员

• 使用：

1. 创建工具类的时候，可以写成静态类，写成静态很方便，直接类名使用，不需要实例化；
2. 静态类在整个项目中资源共享（例如：登陆后的Cookie放在一个静态类，这样所有的版块都可以公用这个）；

• Person类

namespace cSharpTest
{
    public class Person
    {
        public void M1()
        {
            Console.WriteLine("这是一个非静态方法");

        }

        public static void M2()
        {
            Console.WriteLine("这是一个静态方法");

        }
    }
}

• Fxx类

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {
            Person fxx = new Person();
            fxx.M1();
            Person.M2();
        }
    }
}

构造函数

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

1. 构造函数没有返回值，连void也不能写；
2. 构造函数的名称，必须跟类名一样；
3. 必须是public
4. 可以使用重载
5. 写好类的时候会默认一个无参数的构造函数

• new关键字做了三件事：1）内存中开辟空间；2）在空间中创造对象；3）调用对象的构造函数进行初始化对象

• Student类

namespace cSharpTest
{
    public class Student
    {
        /*类里面有，字段，属性，方法，构造函数*/
        public Student(string name, string gender)
        {
            this.name = name;
            this.gender = gender;
            Console.WriteLine("这是构造函数");

        }

        //重载，只有姓名的学生
        public Student(string name) 
        {
            this.name = name;
            Console.WriteLine("这是构造函数");

        }


        //name字段
        private string _name;
        //属性
        public string name
        {
            get { return _name; }
            set { _name = value; }
        }
        
        private string _gender;
        public string gender 
        {
            get { return _gender; }
            set { _gender = value; }
        }
        public void Speak()
        {
            Console.WriteLine("{0}，性别{1}在说话", this.name, this.gender);

        }

    }
}

• class1 类

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {
            //实例化的时候，先调用构造函数
            Student fxx = new Student("fxx","female");
            fxx.Speak();
            Student gjj = new Student("gff");
            gjj.Speak();
        }
    }
}

关键字this

1）代表当前类的对象；
2）在类当中显示调用本类的构造函数：this

    //this减少冗余代码
        public Student(string name) : this(name,"")
        {
        }

命名空间

解决类的重名问题，可以看作为类的文件夹，类是属于命名空间
1.添加引用
2.引入命名空间

值类型和引用类型

-值类型：int,double,char,demical,bool,enum,struct
-引用类型： string,数组，自定义类，集合，object，接口

1.值类型和应用类型在内存的存储地方不一样
2.在传递值类的类型和传递引用类型的时候，传递方式不一样

字符串方法

1.字符串不可变性（当你给字符串赋值的时候，老值并没有消失，只是内存中开辟了新的空间存储新值，GC会自动回收垃圾）

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {
            //实例化的时候，先调用构造函数
            Student fxx = new Student("fxx",18);
            fxx.SayHello();
            //可将string类型看成char类型的一个只读数组
            string s = "adfab";
            //s[0] ="b"不能这么做
            //首先将字符串转换为char类型的数组
            char[] chs = s.ToCharArray();//将字符串转为数组
            chs[0] = 'b';
            chs[0] = 'b';
            s = new string(chs);

            Console.WriteLine(s);
            Console.ReadKey(true);

        }
    }
}

• Split方法

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {
            //实例化的时候，先调用构造函数
            string s = "2009-09-09";
 /*           char[] chs = { '-' };
            string[] new_s = s.Split(chs, StringSplitOptions)
*/
            string[] new_s = s.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);

            Console.WriteLine("{0}年{1}月{2}日",new_s[0], new_s[1],new_s[2]);
            Console.ReadKey(true);
        }
    }
}

• replace

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {
            string str = "国家主席彭蟹蟹";
            if (str.Contains("彭蟹蟹"))
            {
                str = str.Replace("彭蟹蟹", "维尼熊");
            }
            Console.WriteLine(str);
            Console.ReadKey(true);
        }
    }
}

• substring 截取字符串

namespace cSharpTest
{
    class Fxx
    {
        static void Main(string[] args)
        {

            string str = "国家主席彭蟹蟹";
            //string str1 = str.Substring(0, str.Length-3);
            str = str.Substring(str.Length - 3);//彭蟹蟹
            str = str.Substring(0, 4);//国家主席

            Console.WriteLine(str);
            Console.ReadKey(true);
        }
    }
}

1)、Length：获得当前字符串中字符的个数
2)、ToUpper():将字符转换成大写形式
3)、ToLower():将字符串转换成小写形式
4)、Equals(lessonTwo,StringComparison.OrdinalIgnoreCase):比较两个字符串，可以忽略大小写
5)、Split()：分割字符串，返回字符串类型的数组。
6)、Substring()：解决字符串。在截取的时候包含要截取的那个位置。
7)、IndexOf():判断某个字符串在字符串中第一次出现的位置，如果没有返回-1、值类型和引用类型在内存上存储的地方不一样。
8)、LastIndexOf()：判断某个字符串在字符串中最后一次出现的位置，如果没有同样返回-1
9)、StartsWith():判断以....开始
10)、EndsWith():判断以...结束
11)、Replace():将字符串中某个字符串替换成一个新的字符串
12)、Contains():判断某个字符串是否包含指定的字符串
13)、Trim():去掉字符串中前后的空格
14)、TrimEnd()：去掉字符串中结尾的空格
15)、TrimStart()：去掉字符串中前面的空格
16)、string.IsNullOrEmpty():判断一个字符串是否为空或者为null
17)、string.Join()：将数组按照指定的字符串连接，返回一个字符串。