C#基础篇七类和静态成员

1.new关键字做的4个事情
1.1 开辟堆空间
a.开辟多大的空间呢？
当前类 所有的 成员变量类型所占空间的总和 + 类型指针(方法表的地址)
b.开辟了空间干什么用呢？
存放 成员变量

1.2 创建对象
a.将对应类型 中的 实例成员模板区 里的 实例变量 复制到 堆空间空间中；
b.将 对应类型 的 方法表地址 设置 对象！
1.3 调用构造函数

a.将 前面创建 的对象 的堆地址，先传给 构造函数里的 this!
b.再 执行 构造函数里的代码！

1.4 返回堆地址

2.静态成员 和 实例成员的区别
2.1静态成员
加载：是当程序 第一次遇到 某个类的时候，进行 类型加载；加载中就会 创建该类的类型 和方法表，在类型中就会将 静态成员 保存到 静态成员区中；
访问：通过 类名.静态成员：Dog.dogNum++;

2.2实例成员
加载：是通过 new关键字 创建对象的时候加载的！
访问：通过 对象名.实例成员： Dog d =new Dog(); d.name="小白";

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P01MethodOverload
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.方法重载：方法名相同 + 参数不同(个数 或 类型) ，和 返回值无关！
            //1.1 同一个类中 不允许出现 方法名 和 参数(参数的类型和个数，与参数名无关) 完全一样的 两个方法
            //1.2 但是 允许 出现 方法名相同，但是 参数 的 【个数 或 类型】 不同 的多个方法 同时存在！-- 这个机制就叫做【方法重载】！

            Console.WriteLine("哈哈哈哈");
            Console.WriteLine(123123);
            Console.WriteLine(true);
        }


        static int SayHi(string strName)
        {
            return 1;
        }


        static int SayHi(string strName,int age)
        {
            return 1;
        }

        static int SayHi(int strPwd)
        {
            return 1;
        }

        /// <summary>
        /// 1.1 求和 2个数
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        static int Add(int x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// 1.2 求和 3个数
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        /// <returns></returns>
        static int Add(int x, int y, int z)
        {
            return x + y + z;
        }

    }
}

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P02OOP
{
    class Program
    {
        static string aaa="123";

        static void Main(string[] args)
        {
            /*1.类
             * 1.1 语法： class 类名 { }
             * 1.2 作用 a.【分类】-为程序里的 各种 变量 方法 做分类！
             *             怎么分类呢？ - "名词提炼法"；
             *             类里放什么呢？ - 放 数据(全局变量) 和 方法；
             * 1.3 作用 b.【复用】-复用代码结构 和 方法
             */

            //1.2.1 类之间的调用
            //a.如果 被 访问类 的 成员 或 方法 被 static 修饰的话，则直接通过 类名.成员 的方式来访问

            //1.3关于类的加载： 当程序执行某个方法时，会优先将 方法里的 第一次遇到的所有的 类 都加载到内存中；然后再 由上至下  的 执行 方法里的代码！
            Console.WriteLine("begin");
            Test();


            Console.ReadLine();
        }

        static void Test()
        {
            Dog.type = "苏格兰牧羊犬";
            Dog.sex = false;
            Dog.age = 1;
            Dog.Bark();

            Cat.name = "";

        }
    }

    /// <summary>
    /// 犬 类
    /// </summary>
    class Dog
    {
        /* 类的成员 都有 访问修饰符：
         * a.私有成员,private：凡是私有成员，只能 在当前类中被访问！ -- 类的所有成员 默认都是 private
         * b.公有成员,public ：可以在类中 或 类的外部 访问！
         */
        //private static string type;
        public static string type=Console.ReadLine();
        public static int age;
        public static bool sex;

        public static void Bark()
        {
            Console.WriteLine("汪汪~~~~~" + Dog.type);
        }

        static void Pee()
        {
            Console.WriteLine("对着电线杆尿尿~~~~~~~~~");
        }
    }

    class Cat
    {
        public static string name = Console.ReadLine();
    }
}

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P03Object
{
    class Program
    {
        /// <summary>
        /// 类 和 对象
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            /*  Dog d1 = new Dog()
             *  等号左侧 叫生成 Dog类的【变量】！ 在 栈 中开辟空间，存放 =号右边创建的堆空间地址
             *  等号右边 叫做创建(实例化) Dog类的 【对象】！在 堆 中开辟空间，在堆中存放 实例成员
             */
            Dog d1 = new Dog("小白", 1, false);
            //d1.name = "小白";
            //d1.age = 2;
            //d1.sex = false;
            d1.Bark();
            Dog.dogNum++;

            Dog d2 = new Dog("小黑", 2, true);
            //d2.name = "小黑";
            //d2.age = 3;
            //d2.sex = true;
            d2.Bark();
            Dog.dogNum++;

            Console.ReadLine();
        }
    }

    class Dog
    {
        /* 在类中，没有被static修饰 叫做 【实例成员】
         *        实例成员的访问方式，是通过 【对象】.【实例成员】
         */
        public string name;
        public int age;
        public bool sex;
        public static int dogNum = 0;

        /* 构造函数：无返回值类型，并且 方法名 必须 和 类名一致！
         *          只能被new关键字调用
         */
        public Dog(string name1,int age1,bool sex1)
        {
            this.name = name1;
            this.age = age1;
            this.sex = sex1;
        }

        public void Bark()
        {
            Console.WriteLine("汪汪~~~我是一只小狗狗，叫做{0},年龄{1},性别{2}", name, age, sex);
        }
    }
}