码迷,mamicode.com
首页 > Windows程序 > 详细

传智的光辉岁月-C#基础篇七类和静态成员

时间:2015-01-17 19:24:55      阅读:284      评论:0      收藏:0      [点我收藏+]

标签:

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);
        }
    }
}

  技术分享

技术分享

技术分享

 

传智的光辉岁月-C#基础篇七类和静态成员

标签:

原文地址:http://www.cnblogs.com/fenglingyi/p/4230874.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!