Java进击C#——语法之面向对象

本章简言

上一章笔者讲到关于ADO.NET相关的知识，知道了如何去访问数据库。本章将来讲关于面向对象的思想。不管在JAVA还是在C#面向对象思想的重要性都是占了一个很大的成份。往往他就像呼吸一样子，更多的时候我们会忽略。面向对象编程有三大特性：封装、多态、继承。关于这三大特性的定义笔者不会过多的介绍。网络上类似这样子的文章一搜一片。相信里面肯定有你需要的。而本系列主要目标是想让JAVA程序员进入C#的开发环境。所以更多会在俩者之间的差别进行讲解。

类和对象

在进入面向对象思想的讲解之前，笔者认为应该先明白什么是类，什么是对象，及他们之间的关系。这样子的话才能更加明白面向对象思想。相关类和对象的讲解在网络上一搜也是一大片资料。笔者不想过多的解讲。笔者只是把自己的理解写出来，希望能给大家一些帮助。通常笔者喜欢把类理解为建房子时候用到的房子结构图纸。而对象便是根据房子结构图纸而建造成功的房子。这里的图纸便是.cs文件，图纸上面的结构图就是类了。而建造成功的房子便是对象，也就是内存中的实例。这是笔者的理解。有了这一个之后，我们就来看一下三大特性。

面向对象的封装

对于封装的里面，笔者是这样子看的。如果有过面向过程开发的读者们就会明白。所谓的封装就是把相关的数据放在同一个区域的，然后给这个区域命个名字。这样子将来开发的时候就可以知道来源。代码中的那个“.”就是最好的证明了。笔者不想讲过多没有用的话。我们就以代码的形式来学习。如下

C#：

1  public class Person
2     {
3         public string Name { set; get; }
4
5         public string Sex { set; get; }
6
7         public void Move()
8         {
9
10         }
11     }

笔者定义一个叫Person的类。显然最大的区别在代码的中的“{ set; get; }”这一个部分。相信JAVA中我们常常会看到一些习惯的写法。算了。为了方便阅读笔者还是写代码贴出来吧。

JAVA:

1 public class Person {
2
3     private String name;
4     private String sex;
5
6     public String getName() {
7         return name;
8     }
9     public void setName(String name) {
10         this.name = name;
11     }
12     public String getSex() {
13         return sex;
14     }
15     public void setSex(String sex) {
16         this.sex = sex;
17     }
18
19     public void Move()
20     {
21
22     }
23
24 }

我们可以看到JAVA这边如果类外面的想要用内部成员的话，就必须通过对应的set或get方法来实现。而在C#中却没有这样子写法。他有自己一个概念叫属性。上面的C#代码就是属性的写法。只不过他还是缩写的。为了学习我们还是在看一下正真的写法吧。

C#:

1 public class Person
2     {
3         private string _name;
4         private string _sex;
5         public string Name
6         {
7             set { this._name = value; }
8             get { return this._name; }
9         }
10
11         public string Sex
12         {
13             set { this._sex = value; }
14             get { return this._sex; }
15         }
16
17         public void Move()
18         {
19
20         }
21     }

上面的代码就是C#属性的完整写法。可是C#开发人员往往不喜欢用而以。我们还都清楚知道JAVA在给类的内部成员变量赋值的时候，可能会做一些判断或处理。 对应的C#这边你们看到set后面的大括号了没有。就是在大括号里面写。其中关键字value就是将来外面传进来的值。代码如下

C#：

1  public string Name
2         {
3             set
4             {
5                 if (string.IsNullOrWhiteSpace(value))//判断传进来的值是不是空的。其中包括空格键
6                     throw new ArgumentNullException("名字不能赋空值");
7                 this._name = value;
8             }
9             get { return this._name; }
10         }

C#属性的使用：

Person person = new Person();
person.Name = "Aomi";
person.Move();

在我们建设类的时候，往往会定义一个叫常量的成员。JAVA用是关键字final来实现。而C#用的是关键字const。当然这里还有一个关键字readonly。从某种意义来讲他跟常量有一点类似。但又不能说是常量。只能说是一个只读的变量成员。并且他们俩个在赋值的时候又有很大的差别。如下

关键字const：在定义的时候就要给也赋值。

关键字readonly：在定义的时候就要给也赋值。同时候在构造函数里面。

C#：

private readonly string Nick ="aaa";
public const string DefaultName = "Person";

除了赋值和定义不同之外，还有明白他们在使用的时候也不同。关键字const是用类来使用。如 Person.DefaultName。但是关键字readonly是对象内部自己的。这一点要注意。

当我们把数据封装成为一个类的时候，我们要用这个类就必须跟类的构造函数打交道。这里有着跟JAVA一个很大差别。如下代码

C#：

public Person():this("Aomi")
{

}
public Person(string name)
{
this.Name = name;
}

从上面的代码我们就能明白：JAVA的写法是写在构造函数里面。而C#却是在函数名后面。注意思加上“:”。

面向对象的继承

关于继承的话，大多数跟JAVA没有多的差别。主要是extends和implements都要用“:”来写了。这一点到是比较JAVA简单一点。而值得注意还有一点那便是跟构造函数有关系。我们都知道JAVA的super关键字吧。C#是用base关键字。同时用法不同。如下

public class Child : Person
{
public Child()
: base("Aomi")
{

}
}

笔者想了一会儿，觉得好像继承这边没有别的不同了。

面向对象的多态

笔者个人觉得JAVA在多态这边可能理解起来比较简单。为什么这样子讲呢？我们知道多态分为重写和重载。其中最大的差别是在重写身上。

1.重载。即是一名多用的意思。语法跟C#一样子。必须要方法名相同，但是参数类型或是个数不同。

2.重写。意思跟JAVA一样子。只是写法上却有很大的不同。

C#的Person类：

1  public class Person
2     {
3
4         private string _name;
5         private string _sex;
6         public readonly string Nick ="aaa";
7         public const string DefaultName = "Person";
8
9         public Person():this("Aomi")
10         {
11
12         }
13         public Person(string name)
14         {
15             this.Name = name;
16         }
17         public string Name
18         {
19             set
20             {
21                 if (string.IsNullOrWhiteSpace(value))//判断传进来的值是不是空的。其中包括空格键
22                     throw new ArgumentNullException("名字不能赋空值");
23                 this._name = value;
24             }
25             get { return this._name; }
26         }
27
28         public string Sex
29         {
30             set { this._sex = value; }
31             get { return this._sex; }
32         }
33
34         public void Move()
35         {
36             Console.WriteLine("person move");
37         }
38     }

C#的Child类：

1    public class Child : Person
2     {
3         public Child()
4             : base("Aomi")
5         {
6
7         }
8         public void Move()
9         {
10             Console.WriteLine("child move");
11         }
12     }

C#的Program类：

class Program
{
static void Main(string[] args)
{
Person person = new Child();
person.Name = "Aomi";
person.Move();
}
}

执行结果：



我们看到上面代码的执行结果是：person move。Child类重写了Person类的Move方法，在用Person类包装Child类实例。笔者用类似的功能在JAVA做了实验发现执行结果是：child move。在C#这里事实到关系到三个关键字：virtual、new、override。上面C#代码中Child类的Move方法事实上是 public new void Move()。也就是说没有重写原来父类的方法。所以在执行用Person类包装Child类实例的时候，会执行Person类的方法。所以C#这边重写的用法。应该是如下面这样子。

C#的Person类：

public class Person
{
public virtual void Move()
{
Console.WriteLine("person move");
}
}

C#的Child类：

public class Child : Person
{
public override void Move()
{
Console.WriteLine("child move");
}
}

看到了吧。父类如果将来有方法可能会被重写的话，最好用关键字virtual来修饰这个方法。同样子子类要重写父类的话，就必须用关键override。至于关键new就是重新子类自己在写一个方法，不影响父类。

本章总结

本章主要讲到面向对象在C#时候应该明白的一些地方。我们可以看到差别不大的继承。封装和多态还是有一定的差别。同是就是构造函数上的一些差别。