二-C#类和对象 - 《C#学习笔记》

一、面向对象简介
三大特征分别是封装、继承、多态

二、类的定义

类的访问修饰符   修饰符    类名
{
    类的成员
}
namespace code_1
{
    class Test
    {
    }
}

类的访问修饰符：用于设定对类的访问限制，包括 public、internal 或者不写，用 internal 或者不写时代表只能在当前项目中访问类；public 则代表可以在任何项目中访问类。
修饰符：修饰符是对类本身特点的描述，包括 abstract、sealed 和 static。abstract 是抽象的意思，使用它修饰符的类不能被实例化；sealed 修饰的类是密封类，不能被继承；static 修饰的类是静态类，不能被实例化。
类名：类名用于描述类的功能，因此在定义类名时最好是具有实际意义，这样方便用户理解类中描述的内容。在同一个命名空间下类名必须是唯一的。
类的成员：在类中能定义的元素，主要包括字段、属性、方法。
尽管可以在一个命名空间中定义多个类，但不建议使用这种方式，最好是每一个文件定义一个类，这样方便阅读和查找。 !important

三、访问修饰符、修饰符
类的访问修饰符主要有两个，即 internal 和 public,如果省略了访问修饰符，即为 internal。
类中成员的访问修饰符有 4 个：
1、访问修饰符：
1) public
成员可以被任何代码访问。
2) private
成员仅能被同一个类中的代码访问，如果在类成员前未使用任何访问修饰符，则默认为private。
3) internal
成员仅能被同一个项目中的代码访问。
4) protected
成员只能由类或派生类中的代码访问

在修饰字段时通常用两个修饰符，即readonly （只读）和static （静态的）：
使用 readonly 修饰字段意味着只能读取该字段的值而不能给字段赋值。
使用 static 修饰的字段是静态字段，可以直接通过类名访问该字段。
需要注意的是常量不能使用 static 修饰符修饰。

//定义字段
访问修饰符    修饰符    数据类型    字段名；
//访问修饰符和修饰符都是可以省略的，并且访问修饰符和修饰符的位置也可以互换

字段在类中定义完成后，在类加载时，会自动为字段赋值，不同数据类型的字段默认值不同

整数类型	0
浮点型	0
字符串类型	空值
字符型	a
布尔型	False
其他引用类型	空值

四、方法的定义

访问修饰符    修饰符    返回值类型    方法名(参数列表)
{
    语句块;
}

1) 访问修饰符
所有类成员访问修饰符都可以使用，如果省略访问修饰符，默认是 private。
2) 修饰符
在定义方法时修饰符包括 virtual（虚拟的）、abstract（抽象的）、override（重写的）、static（静态的）、sealed（密封的）。override 是在类之间继承时使用的。
3) 返回值类型
用于在调用方法后得到返回结果，返回值可以是任意的数据类型，如果指定了返回值类型，必须使用 return 关键字返回一个与之类型匹配的值。如果没有指定返回值类型，必须使用 void 关键字表示没有返回值。
4) 方法名
对方法所实现功能的描述。方法名的命名是以 Pascal 命名法为规范的。
5)参数列表
在方法中允许有 0 到多个参数，如果没有指定参数也要保留参数列表的小括号。参数的定义形式是“数据类型参数名”，如果使用多个参数，多个参数之间需要用逗号隔开。

class Test
    {
        private int id;                         //定义私有的整型字段 id
        public readonly string name;            //定义公有的只读字符串类型字段 name
        internal static int age;                //定义内部的静态的整型字段 age
        private const string major = "计算机";  //定义私有的字符串类型常量 major
        private void PrintMsg()
        {
            Console.WriteLine("编号：" + id);
            Console.WriteLine("姓名：" + name);
            Console.WriteLine("年龄：" + age);
            Console.WriteLine("专业：" + major);
        }
    }

五、get和set
get 访问器和 set 访问器的使用与方法非常类似，可以在操作字段时根据一些规则和条件来设置或获取字段的值。
此外，为了保证字段的安全性，还能选择省去 get 访问器或 set 访问器。

public    数据类型    属性名
{
    get
    {
        获取属性的语句块;
        return 值;
    }
    set
    {
        设置属性得到语句块;
    }
}

1) get{} 用于获取属性的值，需要在get语句最后使用 return 关键字返回一个与属性数据类型相兼容的值
2）set{} 用于设置字段的值，这里需要一个特殊的值value，用于给字段赋值，set 访问器省略后无法在其他类中给字段赋值，因此也称为只读属性

由于属性都是针对某个字段赋值的，因此属性的名称通常是将字段中每个单词首字母大写
通过上面的实例可以看出，在定义字段属性时，属性的作用就是为字段提供 get、set 访问器，由于操作都比较类似，在 C# 语言中可以将属性的定义简化成如下写法。

public    数据类型    属性名{get;set;}

这种方式也被称为自动属性设置
如果使用上面的方法来设置属性，则不需要先指定字段。如果要使用自动属性的方式来设置属性表示只读属性，直接省略 set 访问器即可。只读属性可以写成如下形式。

public int Id{get;}=1;

这里相当于将 Id 属性的值设置成 1，并且要以分号结束。但是，在使用自动生成属性的方法时不能省略 get 访问器，如果不允许其他类访问属性值，则可以在 get 访问器前面加上访问修饰符 private，代码如下。

public int Id{private get; set;}

这样，Id 属性的 get 访问器只能在当前类中使用。

六、调用类成员
创建类对象的语法形式如下

类名对象名 = new 类名();

通过“对象名”即可调用类中的成员

对象名 . 类的成员

//  Book.cs
class Book
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public double Price { get; set; }

        public void PrintMsg()
        {
            Console.WriteLine("图书编号：" + Id);
            Console.WriteLine("图书名称：" + Name);
            Console.WriteLine("图书价格：" + Price);
        }
        public void SetInfo(int id, string name, double price)
        {
            Id = id;
            Name = name;
            Price = price;
        }
    };

// program.cs
class Program
    {
        static void Main(string[] args)
        {
            Book book = new Book();
            //book.Id = 1001;
            //book.Name = "这是一本书";
            //book.Price = 192.56;
            Console.WriteLine("请输入编号");
            int inputId = int.Parse(Console.ReadLine());
            Console.WriteLine("请输入名称");
            string inputName = Console.ReadLine();
            Console.WriteLine("请输入价格");
            double inputPrice = double.Parse(Console.ReadLine());
            book.SetInfo(inputId, inputName, inputPrice);
            book.PrintMsg();
        }
    }

七、构造函数
**
“类名()”的形式调用的是类的构造方法，也就是说构造方法的名字是与类的名称相同的

访问修饰符  类名 (参数列表)
{
    语句块；
}

访问修饰符使用 public，这样在其他类中都可以创建该对象；如果设置成 private ，则无法创建该对象的类

八、析构函数
析构方法则是在垃圾回收、释放资源时使用的

~类名()
{
    语句块；
}

在析构方法中不带任何参数，它实际上是保证在程序中会调用垃圾回收方法 Finalize()
析构方法是在程序结束后自动被调用的

九、方法重载
方法名称相同、参数列表不同。参数列表不同主要体现在参数个数或参数的数据类型不同。在调用重载的方法时系统是根据所传递参数的不同判断调用的是哪个方法
系统会自动识别参数来调用正确的方法

class BookUtils
    {
        public int Book(int a, int b) {
            return a + b;
        }
        public double Book(double a, double b) {
            return a + b;
        }
        public string Book(string a, string b)
        {
            return a + b;
        }
        public int Book(int a)
        {
            int sum = 0;
            for (int i = 1; i < a; i++)
            {
                sum += i;
            }
            return sum;
        }
    };

BookUtils book = new BookUtils();
Console.WriteLine("4+5=" + book.Book(4, 5));
Console.WriteLine("0到20的和为：{0}",book.Book(20));

十、方法的参数（实参和形参）

public int Book (int a) {
    return a;
}
// a 为形参
public void Print()
{
    Book(3);
}
// 3 为实参

方法中的参数除了定义数据类型外，还可以定义引用参数和输出参数。引用参数使用 ref 关键字定义，输出参数使用 out 关键字定义。

// ref
class BookUtils
{
    public int test(ref int a) {
        return a;
    }
};

static void Main(string[] args)
{
    BookUtils book = new BookUtils();
    int anum = 20;
    Console.WriteLine("输入的数字为{0}",book.test(ref anum));
}

//out
 class BookUtils
 {
     public void test(int a, out int b) {
         b = a + 1;
     }
 };

static void Main(string[] args)
{
    BookUtils book = new BookUtils();
    int testNum ,anum = 20;
    book.test(anum, out testNum);
    Console.WriteLine("输入20转换后的数字为{0}", testNum);
}

十一、lambda 表达式
访问修饰符修饰符返回值类型方法名(参数列表) => 表达式;

class BookUtils
{
    public void test(int a, out int b) => b = a + 1;
};
// 类似与javascript 中箭头函数，提供简介的函数（方法）声明方式

十二、递归

class BookUtils
{
    public int test(int a) {
        if (a == 0) return 1;
        return a * test(a - 1);
        //return a * 10;
    }
};

static void Main(string[] args)
{
    BookUtils book = new BookUtils();
    int testNum ,anum = 10;
    testNum = book.test(anum);
    Console.WriteLine("10的阶乘为{0}", testNum);
}

十三、嵌套类

class BookUtils
{
    public class newTest {
        public string name { get; set; }
        public string nameId { get; set; }

        public void consoleMsg() {
            Console.WriteLine("姓名为：{0}",name);
            Console.WriteLine("身份证号码为：{0}", nameId);
        }
    }
};

static void Main(string[] args)
{
    BookUtils.newTest people = new BookUtils.newTest();
    people.name = "高文雨";
    people.nameId = "123456789";
    people.consoleMsg();
}

如果在其他类中调用嵌套类的成员，需要使用“外部类.嵌套类”的方式创建嵌套类的对象，从而通过嵌套类的对象调用其成员。
如果调用的是嵌套类中的静态成员，直接通过“外部类 . 嵌套类 . 静态成员”的方式调用即可。

十四、部分类

class BookUtils
{
    public partial class secTest {
        public string name { get; set; }
        public string nameId { get; set; }
    }
    public partial class secTest
    {
        public void consoleMsg()
        {
            Console.WriteLine("姓名为：{0}", name);
            Console.WriteLine("身份证号码为：{0}", nameId);
        }
    }
};

static void Main(string[] args)
{
    BookUtils.secTest people = new BookUtils.secTest();
    people.name = "高文雨";
    people.nameId = "123456789";
    people.consoleMsg();
}

partial 即为定义部分类的关键字。部分类主要用于当一个类中的内容较多时将相似类中的内容拆分到不同的类中，并且部分类的名称必须相同

使用部分方法需要注意如下 3 点：

部分方法必须是私有的，并且不能使用 virtual、abstract、override、new、sealed、extern 等修饰符。
部分方法不能有返回值。
在部分方法中不能使用 out 类型的参数。

class BookUtils
{
    public partial class secTest {
        public string name { get; set; }
        public string nameId { get; set; }
        partial void consoleMsg();
        public void printMsg()
        {
            consoleMsg();
        }
    }
    public partial class secTest
    {
        partial void consoleMsg()
        {
            Console.WriteLine("姓名为：{0}", name);
            Console.WriteLine("身份证号码为：{0}", nameId);
        }
    }
};

static void Main(string[] args)
{
    BookUtils.secTest people = new BookUtils.secTest();
    people.name = "高文雨";
    people.nameId = "123456789";
    people.printMsg();
}

十五、Console 类

Console.Write(); // 输出内容不换行
Console.Writeine(); // 输出内容换行
Console.Read(); //从控制台上读取一个字符
Console.ReadLine(); //从控制台上读取一行字符

Console.Write(格式化字符串, 输出项, 输出项2);
在格式化字符串中使用{索引号}的形式，索引号从 0 开始。输出项 1 填充 {0} 位置的内容，依此类推

十六、Math 类

Abs	取绝对值
Ceiling	返回大于或等于指定的双精度浮点数的最小整数值
Floor	返回小于或等于指定的双精度浮点数的最大整数值
Equals	返回指定的对象实例是否相等
Max	返回两个数中较大数的值
Min	返回两个数中较小数的值
Sqrt	返回指定数字的平方根
Round	返回四舍五入后的值

Console.WriteLine("请输入第一个数字：");
double num1 = double.Parse(Console.ReadLine());
Console.WriteLine("请输入第二个数字");
double num2 = double.Parse(Console.ReadLine());
Console.WriteLine("两个数字中较大的是：{0}",Math.Max(num1,num2));
Console.WriteLine("两个数字中较小的是：{0}",Math.Min(num1, num2));

十七、Random 类

Random ram = new Random();
Console.WriteLine("随机一个正整数：{0}",ram.Next());
Console.WriteLine("随机一个1-100间的正整数：{0}",ram.Next(1,100));
Console.WriteLine("随机一个小于100的正整数{0}",ram.Next(100));
Console.WriteLine("随机一个0-1之间的浮点数{0}",ram.NextDouble());
byte[] b = new byte[5];
ram.NextBytes(b);
Console.WriteLine("产生的byte类型的值为：");
foreach (byte i in b)
{
    Console.Write(i + " ");
}
Console.WriteLine();

十八、DateTime类

DateTime 类用于表示时间，所表示的范围是从 0001 年 1 月 1 日 0 点到 9999 年 12 月 31 日 24 点。

Date	获取实例的日期部分
Day	获取该实例所表示的日期是一个月的第几天
DayOfWeek	获取该实例所表示的日期是一周的星期几
DayOfYear	获取该实例所表示的日期是一年的第几天
Add(Timespan value)	在指定的日期实例上添加时间间隔值 value
AddDays(double value)	在指定的日期实例上添加指定天数 value
AddHours(double value)	在指定的日期实例上添加指定的小时数 value
AddMinutes(double value)	在指定的日期实例上添加指定的分钟数 value
AddSeconds(double value)	在指定的日期实例上添加指定的秒数 value
AddMonths(int value)	在指定的日期实例上添加指定的月份 value
AddYears (int value)	在指定的日期实例上添加指定的年份 value