C#相关的题

题目

选择题

1.在C#中，下列变量命名不合规范的是（）
A A2
B int
C score
D name123

2.在C#中，定义int类型的变量a，并赋值为5，以下代码不能正确输出“5*5=25”的是（）

A Console.WriteLine(a+"*"+a+"="+(a*a))
B Console.WriteLine("a*a=(a*a)")
C Console.WriteLine("{0}*{0}={1}",a,a*a)
D Console.WriteLine("{0}*{1}={2}",a,a,a*a)

3.在C#中，以下运算优先级最高的是（）

A +
B ++
C ==
D &&

4.下列变量声明和赋值正确的是（）

A short a=32768;
B float a=10.5
C char a=“a”
D bool a=false

5.C#中5/2的结果是（）

A 2
B 1
C 2.5
D 3

6.关于自增和自减运算符说法不正确的是（）

A  int a=5; Console.WriteLine(--a); 以上代码结果为4
B   int a=5; Console.WriteLine(a--); 以上代码结果为4
C  int a=5; --a; Console.WriteLine(a); 以上代码结果为4
D   int a=5; a++; Console.WriteLine(a); 以上代码结果为6

 

7.该表达式的结果是"abcde"== “abcde” + “2006”;（）

A true2006
B false
C 0
D true

8.分析下列代码片段的执行结果（） int a=1; int b=a++; b+=2; Console.WriteLine(b);

A 4
B 3
C 2
D 1

9.下列关于Write()方法和WriteLine()方法的描述，不正确的是（ ）

A WriteLine()方法在输出字符串的后面添加换行符
B 使用Write()方法输出字符串时，光标将会位于字符串的后面
C 使用Write()方法和WriteLine()方法输出数值变量时，必须要先把数值变量转换成字符串

D 访问修饰符 方法名 返回值类型(形式参数列表)
{
方法体;
}
使用不带参数的WriteLine()方法时，将不会产生任何输出

10.哪一个选项中y的值最小（）

A int y = 10 % 3
B int y = 3 % 10
C int y = 10 % 11
D int y = 10 % 10;

11.下列选项中，正确的是（ ）

A C#是一种面向对象的开发语言，而Java不是
B C#项目编译后的可执行文件扩展名为.exe
C C#中Main()方法中的M首字母不一定要大写
D Console.WriteLine()输出不换行

12.下列变量的命名正确的是（）

A void   define   +word
B a3_b3  _123   YN
C for  –abc   Case
D 2a   DO   sizeof

13.下列关于变量说法不正确的是（）
A 变量命名必须遵循变量命名规定
B 变量是内存中一段已命名的存储空间
C 声明变量时，必须指定数据类型
D 变量不能与常量混合运算

14.分析下列代码片段的执行结果（） int x=5,y=10; Console.WriteLine(“{0}+{1}={2}”,y,x,y+x);

A y+x=15
B x+y=15
C 5+10=15
D 10+5=15

15.以下选项中那些是C#中的关键字 （）

A static
B stirng
C main
D using

简答题

1.C#中数据类型有哪些？详细说明具体的类型

2.什么是装箱和拆箱

3.重写和重载的区别?

4.c#语言的三大特性有哪些？分别都有什么作用？

5.C#中参数传递 ref 与 out 的分别有什么用处？

6.什么是运算符重载 有什么特点

7.const和readonly有什么区别？
8 简述C#成员访问修饰符有哪些
9 委托和事件的关系
10.属性 和字段的关系
11.string和StringBuilder的区别,两者性能的比较 
12.什么抽象类 有什么特点
13.什么是密封类  有什么特点
14.什么是接口   有什么特点
15.什么是泛型   有什么特点

编程题

1.创建一个int类型三维数组维度为{2，2，3}，从键盘接收其值；当用户输入非法时，提示重新输入；  直到整个3为数组元素填满，然后 计算数组中的元素平均值

2.使用抽象类完成：当你去中国四大银行办理业务时   所有银行业务，有存钱，取钱功能，还有账号余额属性     

3.设计一个苹果购买程序    
苹果类 具有价格和保质期 属性   
超过保质期的苹果价格是原来价格的一半    
假如超市现有30个苹果  其中有10个过期的 客户任意买10个苹果  计算苹果总价格。

4.有10只老鼠  一只猫      猫只有偶数日期（随机日期）才会抓老鼠      假设 每次来一只老鼠偷东西   多少天能把老鼠抓完   利用事件完成功能

答案

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace Examination
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //选择题
            //1.B
            //2.B
            //3.B
            //4.D
            //5.A
            //6.B
            //7.B
            //8.B
            //9.C D
            //10.D
            //11.B
            //12.B
            //13.C D
            //14.A
            //15.A D


            //简答题
            //1.
            //数据类型分为值类型和引用类型
            //值类型有：整数类型，单字符类型，浮点型，布尔类型，结构体（struct），枚举（enum）
            //引用类型：字符串类型，类，方法，集合，委托，接口，数组
            //整数类型包括有符号整数和无符号整数
            //有符号整数：sbyte short int long
            //无符号整数：byte ushort uint ulong

            //浮点类型：
            //单精度浮点型：float
            //双精度浮点型：double
            //高精度浮点型：decimal

            //布尔类型：bool

            //单字符类型：char
            //字符串类型：string

            //动态类型：dynamic  会根据赋值自动匹配类型

            //基类：object  所有类型的基类

            //2.
            //将值类型转化为引用类型是装箱，反之则为拆箱
            //将各种类型的值转为object类型这是装箱。
            //将转化为object类型的值在转为对应类型，这是拆箱。
            //int a = 1;
            //object b = a;
            //int c = (int)b;

            //3.
            //重载是指同一类中或父类中的方法，有多个方法名相同的方法，但参数数据类型不同或参数数量不同 以及参数中不同数据类型的顺序不同
            //重写用关键字virtual，override继承的方法方法一样，只是{}中的方法体可以用base继承或修改添加
            //只有虚方法是重写

            //4.
            //继承 多态 封装
            //灵活性，扩张性，安全性
            //继承解决类与类之间方法重复性问题，减少了代码的重复性。
            //多态就是一个接口，多种功能，同一种操作作用于不同的对象，可以有不同的解释，产生不同的作用。比如说泛型接口
            //封装就是将类中的某些信息隐藏起来，不允许外部访问，可以通过访问权限和方法进行访问

            //5.
            //以下都不会建立新内存，始终使用传入实参时定义的变量。
            //ref是引用传递，传入的实参必须赋值，在传入参数时使用ref的参数会根据在方法内的使用而改变，使用ref的参数不传入对应实参无影响。
            //out是输出传递，传入的实参不必赋值，但在传入参数后在方法中必须赋值和使用该参数，可以当返回值使用，相当于多个返回值

            //6.
            //运算符重载就是在用到运算符的对象的类中对运算符进行重新定义运算符的规则。
            //关键字：operator
            //必须在对应的类中重载运算符
            //只要使用运算符会自动调用
            //必须是public且是static
            //必须有返回值
            //不能使用ref和out

            //7.
            //const和readonly都是只读的，在方法中第一也行
            //const是静态常量，必须在定义为字段时赋值。只能定义为字段
            //readonly是非静态的常量，可以在定义为字段时赋值或不赋值，不赋值在构造函数中赋值。

            //8.
            //public internal protect private     protected internal    private protected

            //9.
            //事件是在委托基础上建立的，类似于委托的多播
            //关键词：event
            //可以直接+=方法，也可以将方法放入委托在添加
            //public delegate void DeleMothod();
            //public event DeleMothod DeleEvent;

            //10.
            //每一个属性都有一个对应的字段
            //字段为私有时可以通过属性来在类外访问字段，增加了数据安全性
            //只定义属性系统会在基层建立对应字段
            //属性可以只读或只写或只读只写

            //11.
            //string是不可变字符串，用相关的方法会深克隆原值且只会影响克隆的值，增加内存
            //StringBuilder是可变字符串，用相关的方法只影响原值，只占用一个内存

            //12.
            //在class前添加有abstract
            //public abstract class Base { }
            //关键字：abstract override
            //没有抽象字段
            //抽象类不能实例化和类名使用
            //抽象类默认公开抽象方法必须在抽象类中
            //继承抽象类的子类必须实现抽象方法
            //抽象方法没有方法体
            //抽象类能为静态的
            //抽象类能像普通类一样定义方法等

            //13.
            //密封类无法被继承,却能继承其他类
            //关键字：sealed
            //密封类不能定义protected访问权限的以及虚方法
            //public sealed class Class1 { }

            //14.
            //一般有大写i开头的类都为接口
            //关键字：interface
            //接口默认公开
            //内部成员必须public
            //接口内的成员没有方法体，接口没有字段
            //接口不能声明静态的，继承接口的类必须实现接口

            //15.
            //泛型是延迟编写的数据类型。
            //泛型不能直接使用运算符，但能使用object类型的属性和方法


            //程序题
            1.
            //int[,,] intArray = new int[2, 2, 3];
            //int intNumber;
            //int intNum = 0;
            //int result = 0;
            //for (int i = 0; i < intArray.GetLength(0); i++)
            //{
            //    for (int j = 0; j < intArray.GetLength(1); j++)
            //    {
            //        for (int k = 0; k < intArray.GetLength(2); k++)
            //        {
            //            Console.WriteLine($"intArray[{i},{j},{k}]");
            //        boolintNumber:
            //            bool b = int.TryParse(Console.ReadLine(), out intNumber);
            //            if (b)
            //            {
            //                intArray[i, j, k] = intNumber;
            //                result += intNumber;
            //                intNum++;
            //            }
            //            else
            //            {
            //                Console.WriteLine("重新输入");
            //                goto boolintNumber;
            //            }
            //        }
            //    }
            //}
            //float floatNum = result / intNum;
            //Console.WriteLine("元素平均值：{0}", floatNum);
            //Console.ReadKey();

            2.
            //Ying1 ying1 = new Ying1();
            //Ying2 ying2 = new Ying2();
            //Ying3 ying3 = new Ying3();
            //Ying4 ying4 = new Ying4();
            //int intNum1;
            //intNum:
            //Console.WriteLine("中国四大银行");
            //int.TryParse(Console.ReadLine(), out intNum1);
            //switch (intNum1)
            //{
            //    case 1:
            //        ying1.MiMa();
            //        break;
            //    case 2:
            //        ying2.MiMa();
            //        break;
            //    case 3:
            //        ying3.MiMa();
            //        break;
            //    case 4:
            //        ying4.MiMa();
            //        break;
            //    default:
            //        Console.WriteLine("输入有误");
            //        goto intNum;
            //}
            //Console.ReadKey();
            
            //3
            //List<AppleClass> appleClasses = new List<AppleClass>();
            //for (int i = 0; i < 20; i++)
            //{
            //    AppleClass appleClass = new AppleClass();
            //    appleClass.Price = 10;
            //    appleClass.BaoZhi = true;
            //    appleClasses.Add(appleClass);
            //}
            //for (int i = 0;i < 10; i++)
            //{
            //    AppleClass appleClass1 = new AppleClass();
            //    appleClass1.Price = 5;
            //    appleClass1.BaoZhi = false;
            //    appleClasses.Add(appleClass1);
            //}
            //int KeHu = 10;
            //Random random = new Random();
            //int result = 0;
            //for (int i = 0; i < KeHu; i++)
            //{
            //    int intNext = random.Next(29-i);
            //    result += appleClasses[intNext].Price;
            //    appleClasses.RemoveAt(intNext);
            //}
            //Console.WriteLine("总价：{0}",result);
            //Console.ReadKey();


            //4
            MouseClass mouseClass = new MouseClass();
            CatClass catClass = new CatClass();
            Action action = new Action(catClass.Cat);
            mouseClass.MouseEvent += action;
            int intDay = 1;
            while (true)
            {
                Console.WriteLine("\t天数：{0}",intDay);
                if (intDay%2==0)
                {
                    mouseClass.Mouse();
                    mouseClass.Num-=catClass.Num;
                    if (mouseClass.Num<1)
                    {
                        break;
                    }
                }
                else
                {
                    Console.WriteLine("老鼠逃过一劫");
                }
                intDay++;
            }
            Console.ReadKey();
        }
    }
    public abstract class YinHang
    {
        public abstract int Name { get; }
        public abstract int Pass { get; }
        public abstract int YuE { get; }
        public abstract void CunQian(int intNum);
        public abstract void QuQian(int intNum);
    }
    public class Ying1 : YinHang
    {
        private int _name = 123;
        private int _pass = 1234;
        private int _yuE = 23453;
        public override int Name
        {
            get { return _name; }
        }
        public override int Pass
        {
            get { return _pass; }
        }
        public override int YuE
        {
            get { return _yuE; }
        }
        public void MiMa()
        {
        Num:
            Console.WriteLine("账号：{0}", Name);
            Console.WriteLine("请输入密码：");
            int Num;
            bool b = int.TryParse(Console.ReadLine(), out Num);
            if (Num == Pass)
            {
                Console.WriteLine("登录成功");
                int Number;
            Number:
                Console.WriteLine("余额：{0}", YuE);
                Console.WriteLine("存钱（0）取钱（1）");
                int.TryParse(Console.ReadLine(), out Number);
                switch (Number)
                {
                    case 0:
                        int money;
                        bool boolmoney = int.TryParse(Console.ReadLine(), out money);
                        if (boolmoney)
                        {
                            CunQian(money);
                            Console.WriteLine("存入成功");
                            Console.WriteLine("余额：{0}", YuE);
                            break;
                        }
                        else
                        {
                            Console.WriteLine("系统有误");
                            goto Number;
                        }
                    case 1:
                        int money1;
                        bool boolmoney1= int.TryParse(Console.ReadLine(), out money1);
                        if (boolmoney1 && YuE > money1)
                        {
                            QuQian(money1);
                            Console.WriteLine("取出成功");
                            Console.WriteLine("余额：{0}", YuE);
                            break;
                        }
                        else
                        {
                            Console.WriteLine("你的余额不足");
                            goto Number;
                        }
                    default:
                        Console.WriteLine("输入有误");
                        goto Number;
                }
            }
            else
            {
                Console.WriteLine("密码错误");
                goto Num;
            }
        }
        public override void QuQian(int intNum)
        {
            
            _yuE -= intNum;
        }
        public override void CunQian(int intNum)
        {
            _yuE += intNum;
        }
    }
    public class Ying2 : Ying1
    {

    }
    public class Ying3 : Ying1
    {

    }
    public class Ying4 : Ying1
    {
        
    }


    public class AppleClass
    {
        private int _price;
        private bool _baoZhi;
        public int Price
        {
            get { return _price; }
            set { _price = value; }
        }
        public bool BaoZhi
        {
            get { return _baoZhi;}
            set { _baoZhi = value;}
        }
    }
    public class MouseClass
    {
        public event Action MouseEvent;
        private int _num = 10;
        public int Num
        {
            get { return _num; }
            set { _num = value; }
        }
        public void Mouse()
        {
            if (MouseEvent != null)
            {
                Console.WriteLine("老鼠来了");
                MouseEvent();
            }
            else
            {
                Console.WriteLine("未添加事件");
            }
        }
    }
    public class CatClass
    {
        private int _num = 1;
        public int Num
        {
            get { return _num; }
        }
        public void Cat()
        {
            Console.WriteLine("猫抓抓住了老鼠");
        }
    }
}