第十二章 C# 基础构造函数-优快云博客

本文链接：https://blog.youkuaiyun.com/qianduan2001_5/article/details/132151248

方法--构造函数特殊的方法

构造函数分为实例构造函数私有构造函数和静态构造函数

1.实例构造函数

（1）他主要用于为对象分配存储空间对数据成员进行初始化

（2）类默认自带构造函数如果需要扩展内容也可以重新定义构造函数

（3）实例构造构造函数的名字必须要和类同名

（4）实例构造函数没有返回类型它可以带参数也可以不带参数

（5）实例构造方法的访问修饰符通常是public类型的这样在其他类型都可以创建该类的对象

（6）构造方法是在创建类的对象时被调用的通常会将一些对类成员初始化放到构造函数中去完成

（7）构造函数可以重载从而提供初始化对象的不同方法（）

调用

  //MyClass() 是MyClass的实例构造函数
            MyClass myClass = new MyClass(18,"张三");
            Console.WriteLine(myClass.Age);
            Console.WriteLine(myClass.Name);
            //可以修改
            // myClass.Age = 18;
            

           MyClass myClass1 = new MyClass();

方法

    class MyClass
    {

        //构造函数
        private int _age;
        public int Age { get { return _age; } set { _age = value; } }
        private string _name;
        public string Name { get { return _name; } set { _name = value; } }
        public MyClass() {

            Console.WriteLine("MyClass构造函数调用了1");

        }
        public MyClass(int age) {

            _age = age;
            Console.WriteLine("MyClass构造函数调用了2");
        }
        public MyClass(int age,string name) {

                _age = age;
                _name = name;
            Console.WriteLine("MyClass构造函数调用了3");
        }

        public int MyClassMothod() {

            return 10;
        
        }
       

    }

2.私有构造函数

1. 私有构造函数可用于阻止外部创建

2.如果内部调用回调函数还是可以创建对象

3.如果想要一个类真正的没有对象创建使用静态类

调用

//myClass1
            //    MyClass1 myClass11 = new MyClass1();
            MyClass1 aa =      MyClass1.Create();

方法

   public class MyClass1 
    {


    
        private static int _age;
        private static string _name;

        private MyClass1() {
            _age = 10;
            _name = "张三";
        }

        public static MyClass1 Create()
        {

            MyClass1 myClass1 = new MyClass1();
            return myClass1;

        }
}

3.静态类

调用

//静态类的使用
            MyClass2.Age = 18;
            MyClass2.Name = "张三";
            MyClass2.MyClass2StaticMothod();

方法

 //静态类  一般用于工具类 
    public static class MyClass2
    {

        //静态类中无法创建构造函数
        // public MyClass2() { }
        //静态类中的所有成员为静态
        private static int _age;
        private static string _name;
        public static string Name { set { _name = value; } get { return _name; }  }
        public static int Age { set { _age = value; } get { return _age; } }

        public static void MyClass2StaticMothod()
        {

            Console.WriteLine("MyClass2StaticMothod");

        }

    }

4.静态构造函数

（1）静态构造函数既没有访问修饰符也没有参数

（2）创建第一个类实例或任何静态成员引用时自动调用静态构造函数来初始化类

（3）一个类只能有一个静态构造函数如果没有定义系统默认有反之只能定义无参静态构造函数

（4）无参数的实例构造函数可以与静态构造函数共存尽管参数列表形同但一个属于类一个属于实例所以不会冲突

（5）在类创建时系统自动调用一次静态构造函数

调用

 MyClass3 myClass31  =new MyClass3();
            MyClass3 myClass3 =new MyClass3(19);
            MyClass3._age = 20;

方法

   public class MyClass3
    {

        //静态构造函数 ：

        public static int _age;
        static MyClass3() {

            Console.WriteLine("MyClass3静态构造函数");
        }
        public MyClass3()
        {
            Console.WriteLine("MyClass3无参实例构造函数");
        }
        public MyClass3(int a)
        {
            Console.WriteLine("MyClass3有参实例构造函数");
        }
    }

强制回收析构函数

1.析构函数

（1）垃圾回收程序最终销毁对象之前调用的方法该方法称为析构函数

（2）析构函数没有返回值且不带任何参数

（3）在对象删除前用它来做一些清理工作比如一些和类相关的数据

调用

  int a;
            a = 1;
            MyClass myClass;
            myClass =new MyClass();
            myClass =new MyClass();  
            myClass =null;
            //强制开启回收 立即回收内存 调用析构函数
            GC.Collect();
            Console.ReadKey();

方法

 public class  MyClass
    {

        //构造函数
        public  MyClass() { 
        }


        ~MyClass()
        {

            Console.WriteLine("对象被释放了");
        }
    }

封装

将类的，某些信息隐藏在类内部（private）不允许外部程序直接访问

而是通过该类提供的公共属性（public）来实现对隐藏信息的操作和访问

封装的好处

（1）隐藏类的实现细节

（2）只能通过规定属性访问数据

（3）方便加入控制语句

（4）方便修改实现

继承

（1）一个类继承另一个类其中被继承的类（父类超类基类）继承的类（子类派生类）

（2）继承关系建立之后子类拥有父类的属性和方法反之父类不继承子类属性和方法

（3）继承的作用：解决类与类直接属性或者方法重复的问题

（4）C#中类与类之间是单继承关系利用接口实现多继承

（5）继承的格式 A类（子类）：B类（父类）

（6）创建子类对象时系统默认先调用父类构造方法然后再调用子类构造函数

（7）当父类有有参构造方法时如果子类有构造方法（无参或有参）要求父类必须有一个无参构造方法

（8）转型：子类可以赋值给父类但是父类不能赋值给子类

（9）覆盖：在子类中写一个和基类一样名字(参数不同也算)的非虚函数,会让基类中的函数被隐藏,编译后会提示要求使用New关键字

（10）Object 是所有引用类型的基类

调用

  Man man = new Man();

            //以下实例属性和实例方法，实例字段继承与People类
            man.Age = 5;
            man.Name = "张三";
            man.Height = 180.0f;
            man.Eat();
            man.Drink();
          //  man._age = 18;
            //man._id = 20;
           // man._weight = 10;
            //Smoke 来自于子类
            man.Smoke();

            //
            People.PeopleNumber = 20;
            Console.WriteLine(People.PeopleNumber);



            //
            Woman  xiaoli = new Woman();

方法

  public class People {
       public int _age;
       public int Age { get; set; }
       public string Name { get; set; }
       public float Height { get; set; }

        public void Eat() {

            Console.WriteLine("吃饱了");
        }
        public void Drink() {
            Console.WriteLine("喝饱了");
        }

        private int _weight;
        protected int _id;


        //静态字段
        public static int PeopleNumber;



    }

    public class Man :People
    {
       
        public void Smoke() {
            Console.WriteLine("抽烟");
            PeopleNumber = 19;
            Console.WriteLine(Man.PeopleNumber);
        }
    }

        public class  Person 
    {
        public Person() {

            Console.WriteLine("Person构造函数");
        }   
    }

    public class Woman:Person { 
        
    
    }

子类的变量保存父类的对象在编译时会报错

父类的变量保存子类的对象可以直接使用

调用

 //SubClass1 subClass1 = (SubClass1) new SuperClass1();
            //subClass1._age = 5;
            //Console.WriteLine(subClass1._age);
            

             //父类的变量 保存子类的对象 可以直接使用
            SuperClass1 superClass1 = new SubClass1();
            superClass1._age = 10;
            Console.WriteLine(superClass1._age);
            Console.ReadKey();

方法

    public class SuperClass {

        public SuperClass() { 
        
        
        }
        public SuperClass(int age)
        {


        }
    }

    public class SubClass:SuperClass {
    
      
    }



    public class SuperClass1 {

        public int _age;
    
    }
    public class SubClass1:SuperClass1 { }