语言对比-语法

引用符号：

c++使用#include引入特定文件
c#使用using namespace引入命名空间即可，无需指定特定的文件
java使用import引入包

 

构造函数

c++ c# java都是把与类同名的一个函数当做构造函数
 

析构函数

c++是类同名的一个函数前加上"~"
c#是类同名的一个函数前加上"~"，但是编译器会将其转换为finalize的一个重写方法
java没有，但对象析构时会调用void finalize()方法
 

面向对象特性之封装

 

面向对象特性之继承

结构体：不加访问限制的方法默认是public
c++：不加访问限制的方法默认是private
c#：不加访问限制的方法默认是private
java：不加访问限制的方法默认是default

c++：使用private修饰构造函数阻止该类被继承
c#：使用sealed修饰类名可以阻止该类被继承
c++：使用final修饰类名阻该类被继承

 

 

 

 

面向对象特性之多态

 

 

 

关于虚方法
c++：在基类中必须使用virtual修饰的成员方法才是虚方法，否则是普通方法。比如void virtual jiao(){TRACE("jiao\n");  }
c#：在基类中必须使用virtual修饰并且需要实现同时在子类中实现时必须使用override修饰的成员方法才是虚方法
java：所有成员方法默认就是虚方法，如果想不是加final修饰

关于纯虚方法(抽象方法，基类中不需实现的方法)
c++：在基类中定义=0的虚函数是纯虚函数，而含有纯虚函数的类为抽象类，不能被实例化。比如 virtual void eat()=0;  
c#：叫抽象方法。在基类中必须使用abstract修饰并且不用实现同时在子类中实现时必须使用override修饰的成员方法才是抽象方法。含有抽象方法的基类必须使用abstract修饰，叫抽象类，不能被实例化。 比如 public abstract void eat();  
java：同c#，只不过在子类实现的时候不需用override修饰。

关于接口：
c++:没有接口，但可以多重继承
c#:有
java:有

 

c++多态

//Animal.h
#pragma once
class Animal
{
public:
	Animal(void);
	~Animal(void);
public:
	virtual void eat()=0;  
	void virtual jiao(){
		TRACE("jiao\n");  
	}
};

//Animal.cpp
#include "StdAfx.h"
#include "Animal.h"
Animal::Animal(void)
{
TRACE("构造函数\n");
}
Animal::~Animal(void)
{
}

//Cat.h
#pragma once
#include "animal.h"
class Cat :
	public Animal
{
public:
	Cat(void);
	~Cat(void);
public:
	void jiao(){
		TRACE("miao\n");  
	}
	void eat()  {  
		TRACE("吃鱼\n");  
	}  
	void catchMouse()  {  
		TRACE("抓老鼠\n");  
	}  
};

//Cat.cpp
#include "StdAfx.h"
#include "Cat.h"
Cat::Cat(void)
{
}
Cat::~Cat(void)
{
}

//Dog.h
#pragma once
#include "animal.h"
class Dog :	public Animal
{
public:
	Dog(void);
	~Dog(void);
public:
	void jiao(){
		TRACE("wang\n");  
	}
	void eat()  {  
		TRACE("吃骨头\n");  
	}  
	void kanJia()   {  
		TRACE("看家\n");  
	}  

};

//Dog.cpp
#include "StdAfx.h"
#include "Dog.h"
Dog::Dog(void)
{
}
Dog::~Dog(void)
{
}

//客户端
#include "Animal.h"
#include "Cat.h"
#include "Dog.h"
void CtestDlg::OnBnClickedButton1()
{
	// TODO: 在此添加控件通知处理程序代码
	Animal *bosi = new Cat();
	bosi->eat();
	bosi->jiao();

	Animal *wangcai = new Dog();
	wangcai->eat();  
	wangcai->jiao();

	((Cat*)bosi)->catchMouse();
	((Dog*)wangcai)->kanJia();
}

 

 

 

 

c#的多态

 

 

 

 

 

//Animal.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WpfApplication7
{
    public abstract class Animal
    {
        public Animal()
        {
            Console.WriteLine("构造函数");
        }
        public abstract void eat();
        public virtual void jiao()
        {
            Console.WriteLine("jiao");
        }
    }
}

//Cat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WpfApplication7
{
    class Dog :Animal
    {

        public override void jiao(){
            Console.WriteLine("wang");  
        }
        public override void eat()
        {
            Console.WriteLine("吃骨头");  
        }
        public void kanJia()
        {
            Console.WriteLine("看家");  
        }   
    }
}

//Dog.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WpfApplication7
{
    class Cat :Animal
    {
        public override void jiao(){
   	    Console.WriteLine("miao");  
    }
        public override void eat()  {
        Console.WriteLine("吃鱼");  
    }
        public void catchMouse()  {
        Console.WriteLine("抓老鼠");  
    }  
    }
}

//客户端
            Animal bosi = new Cat();
            bosi.eat();
            bosi.jiao();

            Animal wangcai = new Dog();
            wangcai.eat();
            wangcai.jiao();

            ((Cat)bosi).catchMouse();
            ((Dog)wangcai).kanJia();

 

java多态

 

 

//Animal.java
package animal;

public abstract class Animal  
{  
	 public Animal(){System.out.println("构造函数");} ;
	 public abstract void eat();  
	 public void jiao(){
    	 System.out.println("jiao");  
     }
}  

//Cat.java
package animal;

import animal.Animal;

public class Cat extends Animal  
{  
	public void jiao(){
   	 System.out.println("miao");  
    }
    
	public void eat()  {  
        System.out.println("吃鱼");  
    }  
    
	public void catchMouse()  {  
        System.out.println("抓老鼠");  
    }  
}  
  

//Dog.java
package animal;

import animal.Animal;

public class Cat extends Animal  
{  
	public void jiao(){
   	 System.out.println("miao");  
    }
    
	public void eat()  {  
        System.out.println("吃鱼");  
    }  
    
	public void catchMouse()  {  
        System.out.println("抓老鼠");  
    }  
}  
  

 

//test.java
//客户端
import animal.*;

public class test{
  // 程序的入口
  public static void main(String args[]){
    // 向控制台输出信息
  
      Animal bosi = new Cat();
      bosi.eat();
      bosi.jiao();

      Animal wangcai = new Dog();
      wangcai.eat();  
      wangcai.jiao();
      
      ((Cat)bosi).catchMouse();
      ((Dog)wangcai).kanJia();

  }
  
}

3个例子都是输出：

 

构造函数
吃鱼
miao
构造函数
吃骨头
wang
抓老鼠
看家

 

 

 

 

对比变量的声明和大小写敏感

先看静态语言和动态语言的定义：
静态语言：编译期间做数据类型检查。即写程序时要声明所有变量的数据类型。比如c,c++,java,c#
动态语言：运行期间做数据类型检查。即写程序时，不需要变量指定数据类型，该语言会在第一次赋值给变量时，在内部将数据类型记录下来。之后根据赋值再动态变化数据类型。php.jsp,python,shell。
看起来，动态语言都属于解释型的，静态语言都属于编译型的。

所以，
对于c,c++,java,c#，程序员需要了解语言具体支持的数据类型，这样才能正确的声明变量。比如c里的int n1 = 6;
对于jsp,php,python,shell，程序员即使不知道语言具体支持的数据类型，也能正确声明变量。比如jsp里的var n1 = 6;一个var打遍天下。而有些语言却也不需要使用var去声明变量名，直接就可用。比如php里的 $n1=9
动态语言里的php,python,shell，变量名不需要声明，直接使用，变量类型自动根据赋值而变化。
动态语言里的jsp，变量名需要使用var声明，然后才能使用，变量类型自动根据赋值而变化。

c,c++,java,c#和jsp,php,python,shell：都是大小写敏感。

 

 

 

 

 

 

对比语言对普通数组和关联数组支持的力度

http://blog.csdn.net/opencpu/article/details/41786517

 

 

 

 

对比函数的书写风格