写出以下代码的输出结果
class A
{
public A()
{
i = 3;
}
public int i;
public int Calc(int j)
{
return i + j * j;
}
}
class B : A
{
new public int i;
new public int Calc(int j = 10)
{
if (j < 0)
{
return i + base.Calc(j);
}
return i + j;
}
public int? compare(int l, int n)
{
if (l > n)
{
return 1;
}
else if (l < n)
{
return -1;
}
else
{
return null;
}
}
}
static void Main(string[] args)
{
B b = new B() { i = 2 };
Console.WriteLine(b.i); 2
Console.WriteLine(((A)b).i); 3
Console.WriteLine(b.Calc()); 12
Console.WriteLine(b.Calc(1)); 3
Console.WriteLine(b.Calc(-1)); 6
Console.WriteLine(((A)b).Calc(3)); 12
}
考点：考查继承类中new的第二种用法，new的三种用法分别是：第一种 创建对象、调用构造函数;第二种 是作为修饰符，显示隐藏继承于基类的继承成员;第三种 是用在泛型中添加类型的约束
递归或冒泡排序
//一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少，用递归算法实现。
public static int foo(int n)
{
if (n < 0)
{
return 0;
}
else if (n <= 2)
{
return 1;
}
else
{
return foo(n - 1) + foo(n - 2);
}
}
//冒泡排序
public static void BubbleSort(int[] arr)
{
for (int i = 0; i < arr.Length-1; i++)
{
for (int j = i+1; j < arr.Length; j++)
{
if (arr[j] < arr[i])
{
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
}
}
写法很多不写太多答案了，考查新手编码基础，逻辑性。注意算法的时间复杂度优化，O(n2)
var b=new B();b.PrintFields();产生什么输出？
class A
{
public A()
{
PrintFields();
}
public virtual void PrintFields()
{
}
}
class B : A
{
int x = 1;
int y;
public B()
{
y = -1;
}
public override void PrintFields()
{
Console.WriteLine("x={0},y={1}", x, y);
}
}
答案：x=1,y=0
x=1,y=-1
考点：这道题就是考查类继承时执行的顺序，及继承类中override作用，在new B()时，先执行了int x = 1;int y;再执行B的构造函数，未进构造函数前会先是会先创建父类A对象构造函数，这时会执行PrintFields();方法，因为PrintFields方法为virtual 虚拟方法，在子类override 中重写的该方法，所以实际执行的为B中的PrintFields方法。为什么Y=0？这是因为调用的是父类方法，子类的中的Y还没初始化，默认值为0，这时候才会执行到B的构造函数，赋值了y = -1;，在b.PrintFields()时，自然就是x=1,y=-1了。
下面的代码输出结果
using System;
class A
{
public static int X;
static A(){
X=B.Y+1;
}
}
class B
{
public static int Y=A.X+1;
static B(){}
static void Main(){
Console.WriteLine(“X={0},Y={1}“,A.X,B.Y);
}
}
产生的输出结果是什么？
答
x=1,y=2
class Class1 {
private string str = "Class1.str";
private int i = 0;
static void StringConvert(string str) {
str = "string being converted.";
}
static void StringConvert(Class1 c) {
c.str = "string being converted.";
}
static void Add(int i) {
i++;
}
static void AddWithRef(ref int i) {
i++;
}
static void Main() {
int i1 = 10;
int i2 = 20;
string str = "str";
Class1 c = new Class1();
Add(i1);
AddWithRef(ref i2);
Add(c.i);
StringConvert(str);
StringConvert(c);
Console.WriteLine(i1);
Console.WriteLine(i2);
Console.WriteLine(c.i);
Console.WriteLine(str);
Console.WriteLine(c.str);
}
}
答案：10 21 0 str string being converted.
考点：更改的是是局部变量的值。
写出程序的输出结果
public abstract class A
{
public A()
{
Console.WriteLine('A');
}
public virtual void Fun()
{
Console.WriteLine("A.Fun()");
}
}
public class B: A
{
public B()
{
Console.WriteLine('B');
}
public new void Fun()
{
Console.WriteLine("B.Fun()");
}
public static void Main()
{
A a = new B();
a.Fun();
}
}
答案：A B A.Fun()
考点：抽像类、虚方法、继承、显示隐藏
A a = new B();创建B对象时先创建继承的A对象，先执行A构造函类，再执行B构造函数，输出A B
a.Fun();注意这个a是A的对象，虽然是以new B();创建，但声明的是A对象，执行Fun()时，会执行A的方法（new 是显式隐藏从基类继承的成员，但A类执行还是A的虚方法）
写出程序的输出结果
public class A
{
public virtual void Fun1(int i)
{
Console.WriteLine(i);
}
public void Fun2(A a)
{
a.Fun1(1);
Fun1(5);
}
}
public class B : A
{
public override void Fun1(int i)
{
base.Fun1 (i + 1);
}
public static void Main()
{
B b = new B();
A a = new A();
a.Fun2(b);
b.Fun2(a);
}
}
答案：2 5 1 6
考点：分清楚是哪个对象，调的是哪个方法， a.Fun2(b)时，调的是A类的public void Fun2(A a)，传的参数是b，此时A a实际是B的对象，a.Fun1(1)也就是B类里的Fun1(1)，B类里代码是base.Fun1 (i + 1);又调的A类的Fun1(2),输出2，Fun1(5);是直接调的A类自己的，输出5， b.Fun2(a);同理，调的是B类继承的A类的public void Fun2(A a)，传的参数是a，此时A a实际是A的对象，a.Fun1(1)也就是A类里的Fun1(1),输出1，Fun1(5);是直接调的B类复写的，输出6