C#（三）：命名空间、访问修饰符、枚举、集合、静态、只读、常量

命名空间、访问修饰符、枚举、集合、静态、只读、常量

命名空间

命名空间是一个虚拟的集合
命名空间中只能是 类 、 结构体 、 枚举 、 接口 等类型
命名空间防止类名重复，更好的管理类

using System;
using AAA;

namespace ConsoleAppDemo
{
    
    

    class MainClass
    {
    
    
        public static void Main(string[] args)
        {
    
    
            Person.name = "Lee"; // using AAA; 默认会去使用AAA中的Person
            BBB.Person.name = "Zhang";

            Animal.name = "Dog"; // using AAA; 默认会去使用AAA中的Animal
        }
    }

}

namespace AAA {
    
    
    static class Person
    {
    
    
        public static string name;
    }

    static class Animal
    {
    
    
        public static string name;
    }
}

namespace BBB
{
    
    
    static class Person
    {
    
    
        public static string name;
    }
    namespace CCC
    {
    
    
        static class Person
        {
    
    
            public static string name;
        }
    }
}

访问修饰符

注意：权限低的访问不了权限高的，权限低的也当不了权限高的的父类

访问修饰符	描述
private	成员只能在类型的内部访问，这是默认设置
internal	成员可在类型的内部或同一程序集的任何类型中访问
protected	成员可在类型的内部或从类型继承的任何类型中访问
public	成员在任何地方都可以访问
internal protected	成员可在类型的内部、同一程序集的任何类型以及从该类型继承的任何类型中访问，与虚构的访问修饰符 internal_or_protected 等效
private protected	成员可在类型的内部、同一程序集的任何类型以及从该类型继承的任何类型中访问，相当于虚构的访问修饰符 internal_and_protected。这种组合只能在C#7.2或更高版本中使用

`enum`

// 枚举中指定元素类型(并且只能配置成整型)及默认值
enum Weekday : int
{
    
    
    Sun = 0, Mon, Tue, Wed, Thu, Fri, Sat,
}

internal class Program
{
    
    
    static void Main(string[] args)
    {
    
    
        Console.WriteLine(Weekday.Sun);             // Sun
        Console.WriteLine(Weekday.Sun == 0);        // True
        Console.WriteLine((int)Weekday.Sun == 0);   // True

        Console.WriteLine(Weekday.Mon);             // Mon
        //Console.WriteLine(Weekday.Mon == 1);      // Error
        Console.WriteLine((int)Weekday.Mon == 1);   // True

        Console.WriteLine(Weekday.Tue);             // Tue
        Console.WriteLine((int)Weekday.Tue);        // 2

        Console.WriteLine(Weekday.Wed);             // Wed
        Console.WriteLine(Weekday.Thu);             // Thu
        Console.WriteLine(Weekday.Fri);             // Fri
        Console.WriteLine(Weekday.Sat);             // Sat

        Weekday weekday = Weekday.Sun;

        // 周日
        switch (weekday)
        {
    
    
            case Weekday.Sun:
                Console.WriteLine("周日");
                break;
            case Weekday.Mon:
                Console.WriteLine("周一");
                break;
            case Weekday.Tue:
                Console.WriteLine("周二");
                break;
            case Weekday.Wed:
                Console.WriteLine("周三");
                break;
            case Weekday.Thu:
                Console.WriteLine("周四");
                break;
            case Weekday.Fri:
                Console.WriteLine("周五");
                break;
            case Weekday.Sat:
                Console.WriteLine("周六");
                break;
        }
    }
}

集合

class Person
{
    
    
    public string name;
    public int age;

    public Person(string name, int age)
    {
    
    
        this.name = name;
        this.age = age;
    }
}

`List`

using System.Collections.Generic;

internal class Program
{
    
    
    static void Main(string[] args)
    {
    
    
        // List<Person> persons = new List<Person>();
        // persons.Add(new Person("Lee", 25));
        // persons.Add(new Person("ZhangSan", 30));

        List<Person> persons = new List<Person>
        {
    
    
            new Person("Lee", 25),
            new Person("ZhangSan", 30)
        };

        // List<object> persons = new List<object>
        // {
    
    
        //     new Person("Lee", 25),
        //     123,
        //     "abc"
        // };

        foreach (var person in persons)
        {
    
    
            Console.WriteLine(person.name);
            Console.WriteLine(person.age);
        }
    }
}

`ArrayList`

using System.Collections;

internal class Program
{
    
    
    static void Main(string[] args)
    {
    
    
        // ArrayList personList = new ArrayList();
        // personList.Add(new Person("Lee", 25));
        // personList.Add(123);
        // personList.Add("abc");

        ArrayList personList = new ArrayList
        {
    
    
            new Person("Lee", 25),
            123,
            "abc"
        };

        foreach (var person in personList)
        {
    
    
            Console.WriteLine(person); // ConsoleApp.Person 123 abc
        }
    }
}

`Sort` 排序

internal class Program
{
    
    
    static void Main(string[] args)
    {
    
    
        ArrayList personList1 = new ArrayList();
        personList1.AddRange(new Person[] {
    
    
            new Person("001", "Lee", 25),
            new Person("002", "张三", 10),
            new Person("003", "李四", 20),
            new Person("004", "王五", 20),
            new Person("005", "赵六", 18),
        });

        personList1.Sort();
        foreach (Person person in personList1)
        {
    
    
            //[001] Lee: 25
            //[003] 李四: 20
            //[004] 王五: 20
            //[005] 赵六: 18
            //[002] 张三: 10
            Console.WriteLine($"[{
      
      person.id}] {
      
      person.name}:{
      
      person.age}");
        }

        List<Person> personList2 = new List<Person>();
        personList2.AddRange(new Person[] {
    
    
            new Person("001", "Lee", 25),
            new Person("002", "张三", 10),
            new Person("003", "李四", 20),
            new Person("004", "王五", 20),
            new Person("005", "赵六", 18),
        });
        personList2.Sort();
        foreach (Person person in personList2)
        {
    
    
            //[001] Lee: 25
            //[003] 李四: 20
            //[004] 王五: 20
            //[005] 赵六: 18
            //[002] 张三: 10
            Console.WriteLine($"[{
      
      person.id}] {
      
      person.name}:{
      
      person.age}");
        }
    }
}

class Person : IComparable
{
    
    
    public string id;
    public string name;
    public int age;

    public Person(string id, string name, int age)
    {
    
    
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int CompareTo(object obj)
    {
    
    
        // 判断obj是不是Person
        if (obj is Person)
        {
    
    
            // 将obj转型为Person类型
            Person person = obj as Person;
            //return age - person.age; // 升序
            return person.age - age; // 降序
        }
        return 0; // 默认
    }

}

`Hashtable`

using System.Collections;

Hashtable obj = new Hashtable();
obj.Add("name", "Lee");
obj.Add("age", 18);
obj.Add(6, true);

//Hashtable obj = new Hashtable
//{
    
    
//    { "name", "Lee" },
//    { "age", 18 },
//    { 6, true }
//};

ICollection keys = obj.Keys;
ICollection values = obj.Values;

foreach (object key in keys)
{
    
    
    Console.WriteLine(key); // 6 age name
}

foreach (object value in values)
{
    
    
    Console.WriteLine(value); // True 18 Lee
}

foreach (DictionaryEntry item in obj)
{
    
    
    Console.WriteLine($"obj[{
      
      item.Key}]={
      
      item.Value}"); // obj[6]=True obj[age] = 18 obj[name] = Lee
}

`Dictionary`

using System.Collections.Generic;

Dictionary<string, object> dict = new Dictionary<string, object>
{
    
    
    {
    
     "name", "Lee" },
    {
    
     "age", 18 },
    {
    
     "sex", "男" }
};

foreach (KeyValuePair<string, object> item in dict)
{
    
    
    Console.WriteLine($"dict[{
      
      item.Key}]={
      
      item.Value}"); // dict[name]=Lee dict[age]=18 dict[sex]=男
}

static

静态的属性是属于类的需要使用类进行访问

非静态的属性是属于对象的需要实例化对象进行访问

class MainClass
{
      
      

    public static void Main(string[] args)
    {
      
      

        // 解决打印中文乱码问题
        Console.OutputEncoding = System.Text.Encoding.UTF8;

        Person.Forefathers = "类人猿"; // 静态属性归类进行访问

        Person lee = new Person();
        lee.name = "ProsperLee"; // 非静态属性归对象进行访问
        lee.Info(); // 姓名：ProsperLee

        Person zhang = new Person {
      
      
            name = "张三",
        };
        zhang.Info(); // 姓名：张三

        lee.ForefathersInfo(); // ProsperLee 的祖先是 类人猿
        zhang.ForefathersInfo(); // 张三 的祖先是 类人猿

    }

}

class Person
{
      
      

    public static string Forefathers;

    public string name;

    public void Info()
    {
      
      
        Console.WriteLine($"姓名：{
        
        name}");
    }

    public void ForefathersInfo() {
      
      
        Console.WriteLine($"{
        
        name} 的祖先是 {
        
        Forefathers}");
    }

}

静态类

静态类不能实例化对象 static Xxx{} -> new Xxx() -> Error
静态类中不允许写非静态的成员 static Xxx{ public void Fun(){} } -> Error
静态类只能有一个父类 Object 不能继承也不能被继承

示例

class MainClass
{
    
    
    public static void Main(string[] args)
    {
    
    
        Person.name = "Lee";
        Console.WriteLine(Person.name); // Person Show ~ Lee
        Console.WriteLine(Person.name); // Lee
    }
}

public static class Person {
    
    

    public static string name;

    static Person() {
    
    
        Console.WriteLine("Person Show ~");
    }
        
}

用途

一般用来设计工具类（只需要去调用类中的方法去实现功能，没必要实例化的类）

`readonly` 和 `const`

const 常量必须拥有初始值, readonly 可以没有
readonly 可以在构造方法中进行赋值修改, const 不可以

class Person
{
    
    

    public readonly int x;

    // public const int y; // Error
    public const int y = 100;

    public Person() {
    
    
        x = 200;
        // y = 200; // Error
    }

}

C#（三）：命名空间、访问修饰符、枚举、集合、静态、只读、常量

命名空间、访问修饰符、枚举、集合、静态、只读、常量

命名空间

访问修饰符

enum

集合

List

ArrayList

Sort 排序

Hashtable

Dictionary

static

readonly 和 const

猜你喜欢

`enum`

`List`

`ArrayList`

`Sort` 排序

`Hashtable`

`Dictionary`

`readonly` 和 `const`