C#的引用类型 -3

C#的内置引用类型

**object、string、dynamic**

string 代码演示

           //C#的字符类型的声明，且赋值
           string s = "lihaoyang";
           string s1 = "zhanghaiqi";

           //使用@ 不需要转义
            string at = @"c:\lihaoyang.cs";
            //不使用@就需要加 \ 来进行转义
            string noat = "c:\\lihaoyang.cs";

            //字符串合并操作
            s1 += s;

            //拆分字符串 返回指定下标的字符
            char char1 = at[2];

            //判断两个字符串的值是否相等 返回boolean
            Console.WriteLine(at == noat);

            //判断两个字符串的内存地址是否相同 返回boolean
            Console.WriteLine((object)at == (object)noat);

            //判断字符串是否包含某个字符 返回boolean
            at.Contains("lihao");

            //判断字符串的某个字符首次出现的位置 返回int
            at.IndexOf("li");

            //获取字符串的长度
            Console.WriteLine(at.Length);

StringBuilder的使用
1.为什么要使用StringBuilder？

在大量的字符串的操作时，使用stringbuilder
好处是：1.不需要限定长度，在处理好后再通过tostring转回 string类型 即可。
       2.大量字符串操作的时候，对内存比string小。

2.StringBuilder的声明

            StringBuilder builder = new StringBuilder();

3.StringBuilder的使用

              /*
             下面的字符串和并 和  s1 += s;的区别
             * 使用builder 只是分配一次内存空间，然后在后面追加
             * 
             *  s1 += s; 则是分配了两次内存空间，内存开销大
             */
            builder.Append("lihaoyang");
            builder.Append("zhanghaiqi");
            Console.WriteLine(builder);

            /*
             格式化字符串：就是是按照指定的格式显示
             * 书写格式：
             *  第一部分 "hello{0}{1}" 规定了格式的名称以及参数的个数
             *  
             *  第二部分  "hello","world"。。。 上面规定了几个参数，就
             *             写有几个双引号，里面填写参数值 
             */
            builder.AppendFormat("hello：{0}{1}","hello","world");
            Console.WriteLine(builder);

            //输出格式
            hello：helloworld

C#的Class

class 的声明

    //class的默认修饰符是 internal(同一命名空间可以访问)
    class Person
    {
        /*
         成员变量默认的修饰符是 private
         * (只能class内部进行访问)
         */
        int age;

        //静态成员变量
        static int age1;

        /*
         属性的创建与说明
         * 1.int(在不赋值的情况下，默认缺省值是0)
         * 
         */
        public int Age
        {
            get 
            {
                return age + 10;
            }
            set 
            {
                //这里的value 指代Age实际调用中设置的值 
                age = value - 10;
            }
        }

        /*
         * 在创建class的时候,
         * 会默认创建一个无参的构造函数
         */
        public Person() 
        {
        }

        /*
         重写无参构造函数,
         */
        public Person( int age)
        {
            this.age = age;
        }

        /*
           方法默认的修饰符是 
         * private(只能class内部进行访问)
         * 所有要加上public 这样外部才可以访问
         */

         public int GetAge() 
        {
            return age;
        }
        /*
         创建一个静态方法
         * 静态方法只能通过类去调用，
         * 无法使用实例化后的对象调用。
         * 
         * 因为static 的变量或方法是存储在类上的
         * 而不是static 的变量或方式是存储在实例化后的对象上的
         */
        public static int GetFive(){

            return 5;
        }

    }  

class 的调用

    class Program
    {
        static void Main(string[] args)
        {
            /**
             * 1.通过变量var 代表任何数据类型
             * 2.通过默认的构造函数实现实例化Person类
             */

            var person = new Person(5);

            //通过实例化对象person调用了Getage方法
            person.GetAge();

            //通过类名调用静态方法
            Person.GetFive();

            /*
             使用实例化对象 获得属性的值
             * person.Age调用的是Age属性的get方法
             */
            Console.WriteLine(person.Age);

            /*
             使用实例化对象 设置属性的值
             * person.Age = 10; 调用了Age属性的set方法
             */
            person.Age = 10;
        }
    }

C# 的 Interface

interface(接口) 的声明

 interface ISuper
    {
        int GetSuper();
    }

interface 的实现

—命名规则：通常是以大写的 “I ” 开头 表示他是一个 interface 类

//继承接口
class Person : ISuper
{
    //实现接口内的所有方法
     public int GetSuper() 
        {
            return 50;
        }
}

C#的 abstract

abstract 的声明

abstract class Man 
    {
        public int num;
        public void content() 
        {
            num++;
        }
        //抽象方法
        public abstract void GetAbstract();
    }

abstract 的实现

class Person :Man,ISuper
{
    //只需要 重写 抽象方法，其他的方法或成员变量会自动继承

        //重写abstract类的抽象方法
        public  override void GetAbstract() 
        {
        }
}

个人笔记

类继承 接口或抽象类 的方法：
        class Person : ISuper
        ps：
            1.格式说明
                Person 类名
                ISuper 接口名
                :      继承符
类 继承 多个 接口或 抽象类 的写法：
    class Person : ISuper,Man {}                


vs快捷键 ctrl +shift + b 编译代码
        F5              运行代码

abstract(抽象类) 和 interface(接口)的区别？

1.先说说 abstract

       a.抽象类的声明是使用 abstract关键字+class+类名 

       b.adstract 类不能被实例化

       c.adstract 类 至少有一个抽象方法，
         但也可以包含正常方法 和 成员变量...

       d.继承抽象类的 类，只需要实现抽象方法，其他
         正常的方法和 成员变量不需要重写也可以实现继承。

       e.抽象类的抽象方法需要使用 override 关键字
         只需要重写抽象方法。
         正常的方法和成员变量不需要重写。

2.在说说 interface

    a.接口的声明是 interface关键字+接口名 

    b.接口也不能被实例化

    c.接口只能有方法 

    b.接口 被继承后 类必须实现 接口内 的所有方法