【第十三天】13c#今日小结

原创于 2025-12-17 19:03:24 发布 · 392 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言

1.静态成员

类成员和方法分为静态和非静态俩大类
静态成员或方法找类名.进行使用，存储类中，是类共有，
非静态的成员或方法找对象.进行使用存储在每一个对象里面

静态方法 :不能访问非静态成员或方法，可以访问静态的成员或方法

非静态方法:可以访问静态的成员或方法，也可以访问非静态的方法或成员

 public class People
 {
     public string Name { get; set; } //非静态成员
     public static int Count {  get; set; } // 静态成员

     public void Test1() //非静态方法
     {
         Console.WriteLine("我是非静态方法Test1");
         
         Console.WriteLine(this.Name+"-----"); //this在本类里面可以this代表当前对象，this在本类可以省掉
         Console.WriteLine(Count+"-------");
         People.Test2();//People在本类可以省掉
     }
     public static void Test2()//静态方法 
     {
         Console.WriteLine("我是静态方法Test2");
         Console.WriteLine(Count+"+++++");
         //Console.WriteLine(this.Name+"+++++++");
         // Test2(); 不要在自己方法里面调用自己 导致死循环

     }
 }

 static void Main(string[] args)
 {
     
     People p1 = new People();
     p1.Name = "张三";// 对象.属性
     People.Count = 20;//类.属性

     p1.Test1(); //非静态方法 
     People.Test2();// 静态方法调用

     Console.ReadKey();
 }

静态小例子


        static void Main(string[] args)
        {
            People 嘉伟 = new People();
      
            嘉伟.Eat();//每次吃一个
            Console.WriteLine(嘉伟.GetShengYu());//49
            Console.WriteLine(People.Count);// 49 

            People 艺苑 = new People();
            艺苑.Eat();
            Console.WriteLine(艺苑.GetShengYu());//48
            Console.WriteLine(People.Count);//48

            People 刘语 = new People();
            刘语.Eat();
            Console.WriteLine(刘语.GetShengYu());//47
            Console.WriteLine(People.Count);//47
    
            Console.ReadLine();
        }
    }
    class People
    {
        public static int Count { get; set; } = 50;//总的苹果个数
     
        public  void Eat() //吃苹果的方法
        {
            Count--;
            
        }

        public int GetShengYu() //返回剩余的苹果
        {
            return Count;
        }
    }

}

2.常量和只读变量

只读的字段:只能获取字段值，如果想修改的话，只能在构造函数里面进行修改，在其他地方不能修改。

非静态只读的字段只能三角洲()构造函数进行修改

静态只读字段只能在静态构造函数里面修改static 三角洲() { }

const:常量不能被修改


        static void Main(string[] args)
        {
            Console.ReadKey();
        }
    }
    class 三角洲
    {
        //1只读的字段:只能获取字段值，如果想修改的话，只能在构造函数里面进行修改，在其他地方不能修改。
        //2 非静态只读的字段 只能三角洲()构造函数进行修改
        public readonly double 资产 = 10000;

       //3 静态只读字段 只能在静态构造函数里面修改static 三角洲() { }
        public static readonly string 昵称 = "伊娃诺夫斯基"; 

        //4 const:常量 不能被修改
        public const int c = 10;

        //static 三角洲() //构造函数 new的时候调用
        //{
        //   
        //    昵称 = "ss";
        //}
        public 三角洲() //构造函数 new的时候调用
        {
            
            资产 = 10000000;
            //昵称 = "ss"; //报错 静态只读字段不能在非静态构造函数赋值
        }

        public void 跑刀() //  非静态
        {
           
            //资产 = 10000000; //报错 只读的不能在其他函数赋值
            //昵称 = "ss";     报错 只读的不能在其他函数赋值
        }

        public static void 掠夺() //  静态
        {
            // 资产 = 1000000; // 报错 只读的不能在其他函数赋值
            // Console.WriteLine(资产);//报错 静态只能访问静态
            // 昵称 = "ss"; 报错 只读的不能在其他函数赋值
        }

    }

}

3.类的继承

面向对象编程语言四大特征：
封装：把一些属性和方法封装在一个类里面，这个时候对类的封装，方法的封装把一些相关代码写在一个代码块里面，通过方法名进行调用
继承:当我们一些想添加一些属性，但是这些属性已经在其他类已经存在，没必要类重新定义属性，可以让这个类继承于其他类，会把其他类型属性和方法继承过来
多态：同一个功能不同体现的方式
抽象: 把属性和方法生成一个模版，没有具体实现

继承:分为父类和子类俩个概念
父类：叫基类，把父类属性和方法继承给子类
子类：叫派生类，继承父类里面属性和方法

class People
{
    public string Name { get; set; }//姓名
    public int Age {  get; set; } //年龄 公共属性能被子类继承

    private string Sex { get; set; } //私有不能被继承
    protected string N { get; set; } = "魅魔"; //受保护的能被子类继承的 ，不能在外部被对象.属性访问

    protected internal string M { get; set; } = "梅根"; //可以在外部进行访问，可以被子类继承

    public void Test()  //方法也能被子类继承
    {
        Console.WriteLine("父类的test方法");
    }


}
//男人类继承People，
//People 父类  ；Man子类
class Man:People
{
    public string Hair { get; set; }
    public void Eat()
    {
        Console.WriteLine(this.Name+"带"+this.Hair+"型，吃着炸鸡");
    }

}
// SmallMan继承于Man Man在继承于People
//SmallMan 包含了Man 和  People 公共属性和方法
// 类不允许使用多继承，也就是不允许让a同时继承于b类 c类，但是能够让a继承于b,b类继承c类
class SmallMan :Man
{

    public void Cray()
    {
        
        Console.WriteLine(this.Name+ this.Age+ this.M+this.N+this.Hair);
    }
}

公共属性能被子类继承
私有不能被继承
protected internal 可以在外部进行访问，可以被子类继承
protected 受保护的能被子类继承的，不能在外部被对象.属性访问

static void Main(string[] args)
{
    
    People p1 = new People(); //父类对象
    p1.Name = "皮特";
    p1.Age = 30;  
    Console.WriteLine(p1.Name + p1.Age+"父类对象");


    Man  jiaozi = new Man();//子类对象
    jiaozi.Name = "饺子";
    jiaozi.Age = 5;
    jiaozi.Hair = "饺子形状";
   
    jiaozi.Test();
    jiaozi.Eat();
   Console.WriteLine(jiaozi.Name + jiaozi.Age+"子类对象");


    //创建一个 SmallMan 对象
    SmallMan s = new SmallMan();
    s.Name = "布莱恩";
    s.Age = 3;
    s.Hair = "白头";
    s.M = "路易斯";
    s.Cray();

    Console.ReadKey();
}

4.子类构造函数

调用子类构造函数，首先先去父类的不带参数构造参数
想调用父类的带参数构造函数，在子类的构造函数添加:base(参数1，参数2)调用父类有参数构造函数

class People
{
    public string Name { get; set; }
    public int Age { get; set; }
    public People()
    {
        Console.WriteLine("People父类构造函数");
    }
    public People(string a,int b)
    {
        //带参数的构造函数
        Console.WriteLine("People带参数的构造函数");
        Name  = a;
        Age = b;           
    }

}
class Student:People
{
    // Name 和Age属性可以被继承过来
    public int Id { get; set; }
    public Student()
    {
        Console.WriteLine("Student子类构造函数");
    }
    public Student(string a,int b )
    {
        Console.WriteLine("子类的带参数的构造函数");
    }
    //this 当前类对象
    //base 父类对象
    public Student(string a):base (a,20)
    {
        //调用这个方法触发父类带参数构造函数
        Console.WriteLine(a+"验证在子类如果调用父类有参数的构造 base基类 ，父类");
    }
}

 static void Main(string[] args)
 {
    
     //创建子类的对象
     Student s1 =  new Student(); //调用子类构造函数，首先先去父类的不带参数构造参数
     Student s2 = new Student("11", 10);// 调用的是子类带参数构造函数，首先调用还是父类不带参数的构造函数，


     // 能不能调用子类的有参数构造能够触发父类有参数构造函数，子类如何调用父类的构造
     Student s3 = new Student("张三"); //调用带一个参数构造
     


     Console.ReadKey();
 }

5.结构体和类的区别

类和结构体的区别
1 结构体是值类型，类是引用类型
2 结构体不能定义无参数的构造函数，如果定义有参数构造函数，在函数里面必须对所有属性进行赋值
3 结构体在定义属性或者字段时候不能赋初始值
4 结构体不能继承其他结构体或者类，也不能被继承。

struct Book
{
    public string Name { get; set; }
    public int Price {  get; set; }
    private int a1;


    //public Book()
    //{
    //    Name = "ss";
    //    Price = 10;
    //}
    //在结构体里面添加构造函数，只能定义带参数的构造函数，必须给全部属性
    //或者字段在构造函数里面赋值
    public Book(string a,int b)
    {
        Name = a;
        Price =b;
        a1 = 20;
    }
    public void Test()
    {
        Console.WriteLine("struct里面的方法");
    }
}

static void Main(string[] args)
{
   
    //使用结构体
    Book b1 = new Book("三国演义",100);
    b1.Test();
    Console.WriteLine(b1.Name);

    Book b2 = b1;//把b1赋值给b2
    b1.Name = "西游记";
    Console.WriteLine(b2.Name);//三国演义
    Console.WriteLine(b1.Name);//西游记

    Console.ReadKey();
}