JAVA与C#经典程序比较－－ 抽象类
2009-10-28 20:53:49 来源：WEB开发网核心提示：java与C#都是面向对象的语言，它们都有各自的抽象类，JAVA与C#经典程序比较－－ 抽象类，都能实现多态性，一、在JAVA中实现学生和老师打招呼的代码import java.util.ArrayList;//导入ArrayList集合类/** 抽象父类Person*/abstract class Person{ S
java与C#都是面向对象的语言，它们都有各自的抽象类，都能实现多态性。
一、在JAVA中实现学生和老师打招呼的代码
import java.util.ArrayList;//导入ArrayList集合类
/**
抽象父类Person
*/
abstract class Person
{
String name;//姓名
int age;//年龄
Person(String name,int age)
{
this.name=name;
this.age=age;
}
//抽象方法sayHi()由子类来实现
abstract void sayHi();
}
/**
学生类继承了Person也就继承了父类的属性
父类中含有抽象方法因此在子类中要重写父类的抽象方法
*/
class Student extends Person
{
String hobby;//附加属性，爱好
Student(String name,int age,String hobby)
{
super(name,age);
this.hobby=hobby;
}
/**
重写父类中的sayHi()方法
*/
void sayHi()
{
System.out.PRintln("大家好，我是"+name+"同学，今年"+age+"岁了，我喜欢"+hobby);
}
}
/**
教师类继承Person
重写抽象父类Person中的抽象方法sayHi()
*/
class Teacher extends Person
{
int yearOfService;//附加属性，工作年限
Teacher(String name,int age,int yearOfService)
{
super(name,age);
this.yearOfService=yearOfService;
}
/**
重写父类中的sayHi()方法
*/
void sayHi()
{
System.out.println("大家好，我是"+name+"老师，今年"+age+"岁了，我已经工作了"+yearOfService);
}
}
/**
测试类
*/
class PersonTest
{
public static void main(String[] args)
{
//生成泛型集合对象
ArrayList<Person> persons = new ArrayList<Person>();
//生成学生对象
Student student = new Student("张三",22,"唱歌");
//生成教师对象
Teacher teacher = new Teacher("李四",44,10);
//将学生和教师添加到泛型集合对象中，自动将student和teacher上溯造型为Person对象
persons.add(student);
persons.add(teacher);
//遍历集合
for(int i=0;i<persons.size();i++)
{
persons.get(i).sayHi();
}
}
}
二、在C#中实现学生和老师打招呼的代码
using System;
using System.Collections.Generic;
using System.Text;
namespace Person
{
/// <summary>
/// 抽象父类Person
/// </summary>
abstract class Person
{
public Person(string name,int age)
{
this.Name = name;
this.Age = age;
}
//姓名
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
//年龄
private int age;
public int Age
{
get { return age; }
set { age = value; }
}
/// <summary>
/// 抽象方法SayHi()将在子类中被重写
/// </summary>
public abstract void SayHi();
}
/// <summary>
/// 子类Student继承抽象父类Person，重写抽象方法SayHi()
/// </summary>
class Student : Person
{
public Student(string name, int age, string hobby)
:base(name,age)
{
this.Hobby = hobby;
}
//附加属性，爱好
private string hobby;
public string Hobby
{
get { return hobby; }
set { hobby = value; }
}
/// <summary>
/// 重写父类中的SayHi()方法
/// </summary>
public override void SayHi()
{
string message = string.Format("大家好，我是{0}同学，今年{1}岁了，我喜欢{2}。",this.Name,this.Age,this.Hobby);
Console.WriteLine(message);
}
}
/// <summary>
/// 子类Teacher继承抽象父类Person，并实现抽象方法SayHi
/// </summary>
class Teacher : Person
{
public Teacher(string name,int age,int yearOfService)
:base(name,age)
{
this.YearOfService = yearOfService;
}
//工作年限
private int yearOfService;
public int YearOfService
{
get { return yearOfService; }
set { yearOfService = value; }
}
public override void SayHi()
{
string message = string.Format("大家好，我是{0}老师，今年{1}岁了，我已经工作{2}年了。",this.Name,this.Age,this.YearOfService);
Console.WriteLine(message);
}
}
class Program
{
static void Main(string[] args)
{
//实例化泛型集合对象
List<Person> persons = new List<Person>();
//生成学生对象
Student student = new Student("张三", 22, "唱歌");
//生成教师对象
Teacher teacher = new Teacher("李四", 44, 10);
//将学生和教师添加到泛型集合对象中，自动将student和teacher上溯造型为Person对象
persons.Add(student);
persons.Add(teacher);
//遍历集合
for (int i = 0; i < persons.Count; i++)
{
persons[i].SayHi();
}
Console.ReadLine();
}
}
}
由上面用两种语言编写的程序可以看出，它们都很相似，都实现了同一个功能就是学生和老师打招呼介绍自己的行为。它们都用到了抽象类，在子类中都重写了抽象父类中的抽象方法，都用到了泛型集合，也都表现出了面向对象的特性之一－多态性。
只不过这两种语言在语法上有许多不同之处。
1、 继承
在JAVA中继承使用关键字extends，而在C#中继承使用符号:。
2、 调用父类的构造方法（构造函数）
在JAVA中在子类的构造方法中使用super(参数列表)来调用父类的构造方法，而在C#中在子类后面加上:base(参数列表)。
3、 重写父类的抽象方法
在JAVA中，只需要在子类中重写父类的抽象方法即可，而在C#中需要在这个重写的抽象方法前加上关键字override以表明该方法重写了父类的方法。
4、 属性
在JAVA中只有属性，而在C#中除了有属性，还有字段，并且字段设为私有变量，通过属性给这个私有变量赋值，这样做的好处就是加强了对数据的校验，保证了数据的安全性，其实在JAVA中可以通过定义set方法和get方法来实现，只不过在C#中，微软增加了属性，并在属性中又增加了set访问器和get访问器。
5、 命名规范
在JAVA中，变量名和方法名全部采用Camel命名法，类名和构造方法名采用Pascal命名法；而在C#中私有成员采用Camel命名法，而公有成员采用Pascal命名法。
6、 对属性的操作
在JAVA中一般将属性设为私有成员，不允许用户直接对属性操作，而在C#中因为
在属性中增加了访问器，因此可以对属性直接进行操作，这样做的好处之一就是提高了性能。
7、 对集合的访问
在JAVA中对集合中对象的访问一般通过get方法来获得集合中的元素，而在C#中
可以直接通过索引器来直接访问集合中的元素，这样做的好处主要是为了方便用户访问提高程序的性能。
还有其他很多不同之处这里就不再一一阐述。
这两种语言的相同之处：
1. 都实现了面向对象的三大特性－继承、封装、多态。
2. 都使用到了最流行的技术：泛型集合。
JAVA的优势：
1. 可以实现跨平台操作，在手机程序开发方面占有很大的优势。
2. SUN公司提供的类库都是开源代码，这样就方便了开发人员开发程序。
3. 可以发挥程序员的创造性，为程序员带来成就感。
.NET的优势：
1. 可跨语言语言操作。（据说也可以实现跨平台，但我没试过，它应该还是在windows上的性能表现最佳）
2. 增加了很多特性，提高了性能，例如：属性、索引器等。
3. 微软提供的开发工具非常棒，操作简单容易上手。
.NET是在JAVA之后发展起来的，.NET作为小弟吸收借鉴了大哥的长处摒弃了其短处，并以高效便捷的开发工具和.NET框架吸引了一大批程序员，但让人感到不适的地方在于它将很多东西都封装起来，根本看不到其内部机制，有时候想改还不知道该如何改。JAVA作为大哥，也有许多要不断完善的地方。不过就做为教学而言，我想与C#.NET比较，JAVA更适合作为教学用语言，这样更容易帮助学生了解其内部机制。
一、在JAVA中实现学生和老师打招呼的代码
import java.util.ArrayList;//导入ArrayList集合类
/**
抽象父类Person
*/
abstract class Person
{
String name;//姓名
int age;//年龄
Person(String name,int age)
{
this.name=name;
this.age=age;
}
//抽象方法sayHi()由子类来实现
abstract void sayHi();
}
/**
学生类继承了Person也就继承了父类的属性
父类中含有抽象方法因此在子类中要重写父类的抽象方法
*/
class Student extends Person
{
String hobby;//附加属性，爱好
Student(String name,int age,String hobby)
{
super(name,age);
this.hobby=hobby;
}
/**
重写父类中的sayHi()方法
*/
void sayHi()
{
System.out.PRintln("大家好，我是"+name+"同学，今年"+age+"岁了，我喜欢"+hobby);
}
}
/**
教师类继承Person
重写抽象父类Person中的抽象方法sayHi()
*/
class Teacher extends Person
{
int yearOfService;//附加属性，工作年限
Teacher(String name,int age,int yearOfService)
{
super(name,age);
this.yearOfService=yearOfService;
}
/**
重写父类中的sayHi()方法
*/
void sayHi()
{
System.out.println("大家好，我是"+name+"老师，今年"+age+"岁了，我已经工作了"+yearOfService);
}
}
/**
测试类
*/
class PersonTest
{
public static void main(String[] args)
{
//生成泛型集合对象
ArrayList<Person> persons = new ArrayList<Person>();
//生成学生对象
Student student = new Student("张三",22,"唱歌");
//生成教师对象
Teacher teacher = new Teacher("李四",44,10);
//将学生和教师添加到泛型集合对象中，自动将student和teacher上溯造型为Person对象
persons.add(student);
persons.add(teacher);
//遍历集合
for(int i=0;i<persons.size();i++)
{
persons.get(i).sayHi();
}
}
}
二、在C#中实现学生和老师打招呼的代码
using System;
using System.Collections.Generic;
using System.Text;
namespace Person
{
/// <summary>
/// 抽象父类Person
/// </summary>
abstract class Person
{
public Person(string name,int age)
{
this.Name = name;
this.Age = age;
}
//姓名
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
//年龄
private int age;
public int Age
{
get { return age; }
set { age = value; }
}
/// <summary>
/// 抽象方法SayHi()将在子类中被重写
/// </summary>
public abstract void SayHi();
}
/// <summary>
/// 子类Student继承抽象父类Person，重写抽象方法SayHi()
/// </summary>
class Student : Person
{
public Student(string name, int age, string hobby)
:base(name,age)
{
this.Hobby = hobby;
}
//附加属性，爱好
private string hobby;
public string Hobby
{
get { return hobby; }
set { hobby = value; }
}
/// <summary>
/// 重写父类中的SayHi()方法
/// </summary>
public override void SayHi()
{
string message = string.Format("大家好，我是{0}同学，今年{1}岁了，我喜欢{2}。",this.Name,this.Age,this.Hobby);
Console.WriteLine(message);
}
}
/// <summary>
/// 子类Teacher继承抽象父类Person，并实现抽象方法SayHi
/// </summary>
class Teacher : Person
{
public Teacher(string name,int age,int yearOfService)
:base(name,age)
{
this.YearOfService = yearOfService;
}
//工作年限
private int yearOfService;
public int YearOfService
{
get { return yearOfService; }
set { yearOfService = value; }
}
public override void SayHi()
{
string message = string.Format("大家好，我是{0}老师，今年{1}岁了，我已经工作{2}年了。",this.Name,this.Age,this.YearOfService);
Console.WriteLine(message);
}
}
class Program
{
static void Main(string[] args)
{
//实例化泛型集合对象
List<Person> persons = new List<Person>();
//生成学生对象
Student student = new Student("张三", 22, "唱歌");
//生成教师对象
Teacher teacher = new Teacher("李四", 44, 10);
//将学生和教师添加到泛型集合对象中，自动将student和teacher上溯造型为Person对象
persons.Add(student);
persons.Add(teacher);
//遍历集合
for (int i = 0; i < persons.Count; i++)
{
persons[i].SayHi();
}
Console.ReadLine();
}
}
}
由上面用两种语言编写的程序可以看出，它们都很相似，都实现了同一个功能就是学生和老师打招呼介绍自己的行为。它们都用到了抽象类，在子类中都重写了抽象父类中的抽象方法，都用到了泛型集合，也都表现出了面向对象的特性之一－多态性。
只不过这两种语言在语法上有许多不同之处。
1、 继承
在JAVA中继承使用关键字extends，而在C#中继承使用符号:。
2、 调用父类的构造方法（构造函数）
在JAVA中在子类的构造方法中使用super(参数列表)来调用父类的构造方法，而在C#中在子类后面加上:base(参数列表)。
3、 重写父类的抽象方法
在JAVA中，只需要在子类中重写父类的抽象方法即可，而在C#中需要在这个重写的抽象方法前加上关键字override以表明该方法重写了父类的方法。
4、 属性
在JAVA中只有属性，而在C#中除了有属性，还有字段，并且字段设为私有变量，通过属性给这个私有变量赋值，这样做的好处就是加强了对数据的校验，保证了数据的安全性，其实在JAVA中可以通过定义set方法和get方法来实现，只不过在C#中，微软增加了属性，并在属性中又增加了set访问器和get访问器。
5、 命名规范
在JAVA中，变量名和方法名全部采用Camel命名法，类名和构造方法名采用Pascal命名法；而在C#中私有成员采用Camel命名法，而公有成员采用Pascal命名法。
6、 对属性的操作
在JAVA中一般将属性设为私有成员，不允许用户直接对属性操作，而在C#中因为
在属性中增加了访问器，因此可以对属性直接进行操作，这样做的好处之一就是提高了性能。
7、 对集合的访问
在JAVA中对集合中对象的访问一般通过get方法来获得集合中的元素，而在C#中
可以直接通过索引器来直接访问集合中的元素，这样做的好处主要是为了方便用户访问提高程序的性能。
还有其他很多不同之处这里就不再一一阐述。
这两种语言的相同之处：
1. 都实现了面向对象的三大特性－继承、封装、多态。
2. 都使用到了最流行的技术：泛型集合。
JAVA的优势：
1. 可以实现跨平台操作，在手机程序开发方面占有很大的优势。
2. SUN公司提供的类库都是开源代码，这样就方便了开发人员开发程序。
3. 可以发挥程序员的创造性，为程序员带来成就感。
.NET的优势：
1. 可跨语言语言操作。（据说也可以实现跨平台，但我没试过，它应该还是在windows上的性能表现最佳）
2. 增加了很多特性，提高了性能，例如：属性、索引器等。
3. 微软提供的开发工具非常棒，操作简单容易上手。
.NET是在JAVA之后发展起来的，.NET作为小弟吸收借鉴了大哥的长处摒弃了其短处，并以高效便捷的开发工具和.NET框架吸引了一大批程序员，但让人感到不适的地方在于它将很多东西都封装起来，根本看不到其内部机制，有时候想改还不知道该如何改。JAVA作为大哥，也有许多要不断完善的地方。不过就做为教学而言，我想与C#.NET比较，JAVA更适合作为教学用语言，这样更容易帮助学生了解其内部机制。
中查找“JAVA与C#经典程序比较－－ 抽象类”更多相关内容
中查找“JAVA与C#经典程序比较－－ 抽象类”更多相关内容更多精彩
赞助商链接
