【原创】类和对象的综合练习

da11

//主程序文件：
        //类和对象练习主Main
        private static void Main()
        {
            //使用数组时，数组初始化必须指定大小
            //User[] userSZ = new User[10];
            //读写元素时，必须通过索引
            //userSZ[0] = new User("test1","123");

            /*现在我不想通过指定大小
             * 创建一个类：用户集合类-UserList
             * ｛
             *      //字段 private User[] data = null;  //真正存储用户的字段
             *      //构造函数两个
             *      publib UserList():this(8)
             *      {
             *          //data = new User[8];
             *      }
             *      
             *      publib UserList(int rongL)
             *      {
             *          data = new User[rongL];
             *      }
             *      
             *      //方法1-增加用户
             *      public void Add(User value)
             *      {
             *          data[?] = value;
             *          //如果容量不够？
             *          //扩容：开辟一个更大的数组，复制原数组的内容，替换原数组的引用
             *      }
             *      
             *      //方法2-获取用户
             *      public User GetUser(int index)
             *      {
             *          return data[index];
             *      }
             *      //可选增加两个功能，在指定功能插入用户，和删除用户
             *  ｝
             *  
             * 使用方式：
             * UserList list = new UserList();  //不填是默认值
             * UserList list = new UserList(10);  
             *
             * list.Add("User01");  //添加用户，且可以创建超出限定的对象大小
             *
             * for (int i=0;i<list.Count;i++)
             * {
             *      User user = UserList(i);
             *      user.printUser();
             * }
             *
            */

            UserList list = new UserList();

            for (int i = 0; i <= 35; i++)
            {
                list.Add(new User("test0"+i,"12345"));
            }

            list.Add(new User("usertest"));

            for (int j = 0; j < list.CountNumSX; j++)
            {
                Console.WriteLine(list.GetUser(j).Username);
            }


            Console.ReadLine();

        }

分割线

//User.cs类文件：
    class User
    {
        //字段
        private string username;

        public string Username
        {
            get { return this.username; }
            set { this.username = username; }
        }

        //属性
        public string password { get; set; }


        //构造函数
        public User()
        {

        }

        public User(string username,string password)
        {
            this.username = username;  //最好不要调用属性，直接修改字段
            this.password = password;
        }

        public User(string username)
        {
            this.username = username;  //最好不要调用属性，直接修改字段
        }

        //方法
        public static void printUser()
        {

        }


    }

分割线

//UserList.cs类文件：
    class UserList
    {
        private User[] UserDataSZ = null;
        /*public User[] UserData
        {
            get { return this.UserDataSZ;}
            set { this.UserDataSZ = value; }
        }
        */

        private int CountNum = 0;

        public int CountNumSX
        {
            get { return this.CountNum;}
        }

        public UserList():this(10)
        {

        }

        public UserList(int rongL)
        {
            UserDataSZ = new User[rongL];
        }

        //在类中创建方法的时候，是否静态要跟构造函数一致，一般不需要静态修饰符！！
        public User[] Add(User value)
        {
            int CountNum = 0;

            for (int i = 0; i <= UserDataSZ.Length; i++)
            {
                //
                if (i == UserDataSZ.Length)
                {
                    CountNum = i;
                    //新建一个临时数组并扩容
                    User[] newUserDataSZ = new User[i+10];
                    //复制旧数组内的索引至临时数组中
                    UserDataSZ.CopyTo(newUserDataSZ, 0);
                    //初始化旧数组,并扩容至和临时数组一致
                    UserDataSZ = new User[newUserDataSZ.Length];
                    //复制临时数组内的索引至旧数组中
                    newUserDataSZ.CopyTo(UserDataSZ, 0);
                    //初始化临时数组（删除垃圾）
                    newUserDataSZ = null;
                }

                //判断当前索引是否有对象，无对象引用时，将当前位置数组索引值赋值给CountNum
                if (UserDataSZ==null)
                {
                    CountNum = i;
                    break;
                }
            }

            //根据CountNum索引值，判断是否小于等于数组的大小，判断成功则将对象索引赋值给存储数组
            if (UserDataSZ.Length >= CountNum)
            {
                UserDataSZ[CountNum] = value;
                this.CountNum++;
            }
            return UserDataSZ;
        }

        public User GetUser(int index)
        {
            return UserDataSZ[index];
        }
    }

da11

da11

//综合练习-更新主程序cs文件：
        //类和对象练习主Main
        private static void Main()
        {
            //使用数组时，数组初始化必须指定大小
            //User[] userSZ = new User[10];
            //读写元素时，必须通过索引
            //userSZ[0] = new User("test1","123");

            /*现在我不想通过指定大小
             * 创建一个类：用户集合类-UserList
             * ｛
             *      //字段 private User[] data = null;  //真正存储用户的字段
             *      //构造函数两个
             *      publib UserList():this(8)
             *      {
             *          //data = new User[8];
             *      }
             *      
             *      publib UserList(int rongL)
             *      {
             *          data = new User[rongL];
             *      }
             *      
             *      //方法1-增加用户
             *      public void Add(User value)
             *      {
             *          data[?] = value;
             *          //如果容量不够？
             *          //扩容：开辟一个更大的数组，复制原数组的内容，替换原数组的引用
             *      }
             *      
             *      //方法2-获取用户
             *      public User GetUser(int index)
             *      {
             *          return data[index];
             *      }
             *      //可选增加两个功能，在指定功能插入用户，和删除用户
             *  ｝
             *  
             * 使用方式：
             * UserList list = new UserList();  //不填是默认值
             * UserList list = new UserList(10);  
             *
             * list.Add("User01");  //添加用户，且可以创建超出限定的对象大小
             *
             * for (int i=0;i<list.Count;i++)
             * {
             *      User user = UserList(i);
             *      user.printUser();
             * }
             *
            */

            UserList list = new UserList();

            for (int i = 0; i <= 20; i++)
            {
                list.Add(new User("test0"+i,"12345"));
            }

            list.Add(new User("usertest"));

            list = list.Insert(list, 15, new User("插入的用户","test@1234"));

            list = list.DeleteUser(list, 15);

            for (int j = 0; j < list.CountNumSX; j++)
            {
                User print = new User();
                //Console.WriteLine(User.printUser(j));
                print.printUser(list,j);
            }

            Console.ReadLine();




        }

da11

//综合练习-更新的User类cs文件
    class User
    {
        //字段
        private string username;

        public string Username
        {
            get { return this.username; }
            set { this.username = username; }
        }

        //属性
        public string password { get; set; }


        //构造函数
        public User()
        {

        }

        public User(string username,string password)
        {
            this.username = username;  //最好不要调用属性，直接修改字段
            this.password = password;
        }

        public User(string username)
        {
            this.username = username;  //最好不要调用属性，直接修改字段
        }

        //方法
        public void printUser(UserList UserListDX,int index)
        {
            if (UserListDX.CountNumSX > index)
            {
                Console.WriteLine("账号为：{0} 密码为：{1}", UserListDX.GetUser(index).username, UserListDX.GetUser(index).password);
            }           
        }


    }

da11

//综合练习--更新的UserList类cs文件   

class UserList
    {
        private User[] UserDataSZ = null;
        /*public User[] UserData
        {
            get { return this.UserDataSZ;}
            set { this.UserDataSZ = value; }
        }
        */




        private int CountNum = 0;


        public int CountNumSX
        {
            get { return this.CountNum;}
        }


        public UserList():this(10)
        {
        
        }


        public UserList(int rongL)
        {
            UserDataSZ = new User[rongL];
        }


        //在类中创建方法的时候，是否静态要跟构造函数一致，一般不需要静态修饰符！！
        public User[] Add(User value)
        {
            int CountNum = 0;


            for (int i = 0; i <= UserDataSZ.Length; i++)
            {
                //
                if (i == UserDataSZ.Length)
                {
                    CountNum = i;
                    //新建一个临时数组并扩容
                    User[] newUserDataSZ = new User[i+10];
                    //复制旧数组内的索引至临时数组中
                    UserDataSZ.CopyTo(newUserDataSZ, 0);
                    //初始化旧数组,并扩容至和临时数组一致
                    UserDataSZ = new User[newUserDataSZ.Length];
                    //复制临时数组内的索引至旧数组中
                    newUserDataSZ.CopyTo(UserDataSZ, 0);
                    //初始化临时数组（删除垃圾）
                    newUserDataSZ = null;
                }


                //判断当前索引是否有对象，无对象引用时，将当前位置数组索引值赋值给CountNum
                if (UserDataSZ==null)
                {
                    CountNum = i;
                    break;
                }
            }


            //根据CountNum索引值，判断是否小于等于数组的大小，判断成功则将对象索引赋值给存储数组
            if (UserDataSZ.Length >= CountNum)
            {
                UserDataSZ[CountNum] = value;
                this.CountNum++;
            }
            return UserDataSZ;
        }


        public UserList Insert(UserList UserListDX,int index,User UserDX)
        {
            User[] newUserDataSZ = new User[UserListDX.UserDataSZ.Length];


            //判断插入的索引值是否超过UserList对象里面的数组的最大值，是则直接返回对象
            if (index > UserListDX.UserDataSZ.Length || index < 0)
            {
                return UserListDX;
            }
            else
            {
                //如果插入数据之后把数组撑爆，则需要扩容
                if (index > UserListDX.UserDataSZ.Length)
                {
                    //新建一个临时数组并扩容
                    //User[] newUserDataSZ = new User[UserListDX.UserDataSZ.Length+1];
                    newUserDataSZ = new User[UserListDX.UserDataSZ.Length + 1];


                    //复制旧数组内的索引至临时数组中
                    UserListDX.UserDataSZ.CopyTo(newUserDataSZ, 0);
                    //初始化旧数组,并扩容至和临时数组一致
                    UserListDX.UserDataSZ = new User[newUserDataSZ.Length];
                    //复制临时数组内的索引至旧数组中
                    newUserDataSZ.CopyTo(UserListDX.UserDataSZ, 0);
                    //初始化临时数组（删除垃圾）
                    //newUserDataSZ = null;
                }




                int forXHi = 0;
                for (int i = 0; i < UserListDX.UserDataSZ.Length; i++)
                {
                    if (i==index)
                    {
                        i++;
                    }
                    newUserDataSZ = UserListDX.UserDataSZ[forXHi];
                    forXHi++;
                }
                newUserDataSZ.CopyTo(UserListDX.UserDataSZ, 0);


                newUserDataSZ = null;


                //UserListDX.UserDataSZ[index] = null;


                UserListDX.Add(UserDX);


                //this.CountNum++;


                return UserListDX;


            }
        }


        public UserList DeleteUser(UserList UserListDX, int index)
        {
            User[] newUserDataSZ = new User[UserListDX.UserDataSZ.Length];


            //判断插入的索引值是否超过UserList对象里面的数组的最大值，是则直接返回对象
            if (index > UserListDX.UserDataSZ.Length || index < 0)
            {
                return UserListDX;
            }
            else
            {


                UserListDX.UserDataSZ[index] = null;


                int forXHi = 0;
                for (int i = 0; i <= UserListDX.UserDataSZ.Length-1; i++)
                {
                    if (UserListDX.UserDataSZ==null)
                    {
                        UserListDX.UserDataSZ = UserListDX.UserDataSZ[i + 1];
                        UserListDX.UserDataSZ[i + 1] = null;
                    }
                    if (i > this.CountNum)
                    {
                        break;
                    }


                }


                this.CountNum--;
                return UserListDX;


            }
        }


        public User GetUser(int index)
        {
            return UserDataSZ[index];
        }
    }

da11