Java和c#的语法对比(详细)

最新推荐文章于 2024-08-13 06:00:00 发布

万无引力-

最新推荐文章于 2024-08-13 06:00:00 发布

阅读量3k

点赞数 3

分类专栏：其他

原文链接：https://www.cnblogs.com/wxl123/p/11445916.html

版权

其他专栏收录该内容

14 篇文章 0 订阅

订阅专栏

转载链接:

https://www.cnblogs.com/wxl123/p/11445916.html

https://blog.csdn.net/diaodui3845/article/details/101243084?depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-1&utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-1

1.c#一个类只能继承一个类，继承语法：

class Dog : Anilmal{

}

2.c#中的sealed关键字相当于java中的final关键字，定义的类不能被继承，如：string类不能被继承

3.c#中protected表示继承类可以访问，外部无法访问

4.c#中的base关键字相当于java中的super关键字

5.c#中的构造函数

class A{

public A(){}

public A(string a):this(){}//表示调用上面的无参构造,this就表示调用本类的方法

public A(int a):this("123"){} //表示调用上面的string参数类型的构造

}

6.c#中对象的多态性，如果父类Animal中有一个方法public void shout(){...}，子类Dog中也有一个方法，这时候你想使用Animal animal=new Dog(),采用animal调用Dog类中的shout方法，就需要改代码了，改成以下形式(各加一个关键字)

Animal类中的shout方法改成以下代码：

public virtual void shout(){...}

Dog类中的shout方法改成以下代码：

public override void shout(){...}//即覆写掉父类的属性或方法//如果Dog还有子类，想继续覆写就不用再在Dog类中的方法加virtual关键字了，直接使用override就行了如：Dog类中还有一个子类Dog1，覆写Dog中的shout方法直接在Dog1中加下一代吗即可：public override void shout(){...}

7.c#中的抽象类：和java一样使用abstract关键字，如：

public abstract class Animal{

public abstract void shout();//抽象方法也要使用abstract关键字，抽象类不能直接实例化，需要子类继承并且子类必须覆写抽象类的抽象方法（即在方法返回值前面加上override关键字，此时就不需要在抽象方法前面加上virtual关键字了）

}注意：抽象类中也可以写普通方法

8.c#中set，get方法的写法

public 返回值类型属性名称{get;set；}

如下代码：

public string name{get;set;}

9.c#中的接口采用interface关键字

如下代码：

interface IFly{

public void Fly();//这里的public可以省略，因为接口中的方法或属性只能是public权限

}

　　如果A类继承B类，并且实现C接口，则代码如下：

class A:B,C{

}

10.c#类是单继承，接口可以多继承一个类可以继承多个接口，抽象类可以继承接口，接口不能继承抽象类。

11.struct值类型，用来定义结构体，如下代码：

class Program{

struct Location//结构体

{

public int X;

public int Y;

public Location(int x,int y){this.X=x;this.Y=y}//此处不允许定义无参构造

}

static void Test(Location loc){

loc.X=1;

loc.Y=1;

}

static void main(string[] args){

Location loc=new Location(0,0);

Test(loc);

}

12.try{...} catch(Exception e){...}finally{...}快捷键，先打出来try再连续按两次Tab建即可，如果异常此处处理不了也可以抛出来catch{throw;}

13.c#的泛型：

//1 static T Sum<T>(List<T> nums) where T:struct//这里的where是对泛型的约束，struct表示数值型

{

T sum =default(T);//表示给sum赋初值（即数值型默认的值）

return sum;

} //2 class Test{ 　　public void X(); } static void TestFunc<T>() where T:Test,new(){//如果这里不加new()，下面不能使用new T()；如果这里 不加Test约束，下面不能调用Test类 　　T t=new T(); t.X(); }

14.c#中重载操作符（赋值符号不能重载）：如下代码重载

public static bool operator ==(Location lhs,Locations rhs){

return false;

}

15.VS

　　• VS结构：一个解决方案底下可以添加多个项目，可以认为一个项目对应一个命名空间

　　• VS中创建类库，将鼠标光标放在"解决方案"上右键选择"新建"，然后选择"类库"，类库编译之后生成的就是dll文件。

　　• VS中引用类库，两种引用方法：

　　　　• 引入整个dll文件

　　　　　　在需要引用的项目的目录中有一个引用，将光标放在"引用"上面右键，选择添加引用，选择你要选择的即可（如果选择自定义的，就要选择"解决方案"下的"项目"再进行查找）

　　　　• [DllImport(...)]，仅用于方法

16.IDisposable接口结合using的使用

//1.IDisposable是一个自动释放资源的接口，里面有一个Dispose方法

//在读写流或者需要使用close()关闭的地方使用using()结合此接口使用

static void Main(string args[]){

using(StreamWriter sq=new StreamWriter(new FileStream("777.txt",FileMode.Create,FileAccess.Write))){

sq.WriteLine("123");

}

}//此时在执行using的时候，在using语句执行完毕之前会自动执行IDisposable接口的Dispose方法从而自动释放资源

17.委托（引入委托也叫作匿名方法）

class Program

{

//1.声明委托类型

delegate bool Function(int num);

static Function BigThan10=delegate(int n){//此处的n与上面的num一一对应　　　　　　return n>=10;　　　　　　};

//2.修改形参列表

static List<int> Traverse(List<int> nums,Function function){

var list=new List<int>();

foreach(var num int nums){

if(function(num)){

list.Add(num);

}

return list;

}

//3.传入委托

static void Main(string[] args){

Traverse(new List<int>(){1,2,3,4,5},BigThan10);//传入委托

Console.WriteLine();

Console.ReadLine();

}

18.委托写法的化简——Lambda表达式

　　1.语句Lambda

//语法：(type var,...)=>{...}//加类型

(var,...)=>{...}//不加类型

var=>{...}//一个参数的时候

()=>{...}//没有参数的时候 //17中的第三部传入委托也可以也成 Traverse(new List<int>(){1,2,3,4,5},delegate(int n){return n>=10;});//显然这样写有点啰嗦，

1	`使用Lambda表达式可以简化成：(1)　　Traverse(new` `List<int>(){1,2,3,4,5},(int` `n)=>{return` `n>=10;});(2)　　Traverse(new` `List<int>(){1,2,3,4,5},(n)=>{return` `n>=10;});(3)如果只有一个参数括号也不用写了：Traverse(new` `List<int>(){1,2,3,4,5},n=>{return` `n>=10;});`

　　2.表达式Lambda：没有{}，但是只能有一条语句

1	`Traverse(new` `List<int>(){1,2,3,4,5},n=> n>=10);//将return也去掉`

19.系统自带的泛型委托

（1）Action<> 例：List<T>.ForEach()

（2）Func<> 例List<T>.Sum()

（3）Predicate<> 例 List<T>.FindAll()

例 List<T>.Find()

　（1）的代码：

1 2	`var` `list=new` `List<int>(){1,2,3,4,5,6};` `list.Foreach(i=>{Console.WriteLine(i)});//这里的i表示list集合中的一个个值`

　（2）的代码：

class Program
{
//1.声明委托类型
static Func<int, bool> BigThan10 = delegate(int n)
{
return n>=4;
};

//2.修改形参列表
static List<int> Traverse(List<int> nums, Func<int, bool> function){
var list=new List<int>();

foreach(var num in nums){
if(function(num)){
list.Add(num);
}
}
return list;
}
//3.传入委托
static void Main(string[] args)
{
var list=new List<int>(){1,2,3,4,5,6};
var n=Traverse(list, BigThan10);
n.ForEach(i=>Console.WriteLine(i));
Console.ReadLine();

}
}

　（3）的代码

20.c#中的foreach是只读的，不能给其赋值。

21.c#中的Dictionary相当于java中的map，实例化直接使用Dictionary，

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

语法对比

		Java	C#
访问修饰符	public	修饰类、接口、变量、方法。对所有类可见。	修饰类、接口、变量、方法。对所有类可见。
	internal	无。	修饰类、接口、变量、方法。类，接口的缺省访问修饰符。同一个程序集的对象可见。
	protected	子类可见。	子类可见。
	private	类内部可见。	变量，方法的缺省访问修饰符类内部可见。
	default	类、接口、变量、方法的缺省修饰符。同一包内可见。	无。
基本类型		基本类型，无方法可调用。作为局部变量时，储存与栈。作为字段时，跟随于实例。	值类型，继承object，具有ToString()等方法。作为局部变量时，储存与栈。作为字段时，跟随于实例。
	布尔值	boolean	bool
	整形	short，int，long	short，int，long
	浮点数	float，double	float，double
可空基本类型		例如：Integer是引用类型，Integer是int的包装类。	例如： int?其实是Nullable<int>的语法糖，而Nullable<int>依然是值类型。
	布尔值	Boolean	bool?
	整形	Short,Integer,Long	short?,int?,long?
	浮点数	Float,Double	float?,double?
	高精度数值类型	BigDecimal	decimal?
源文件组织	导入	使用包的概念，关键字import导入	使用命名空间的概念，关键字using导入
	类文件	源文件名要和Public类名保持一致，最多存在一个Public修饰的类，文件名后缀是.java	没有java中的限制，文件名后缀是.cs
枚举	枚举	关键字enum，引用类型，和class差不多，可以有字段和方法，可以添加私有构造函数	关键字enum，值类型，默认继承int，可以继承其他值类型
常量	常量	关键字final修饰变量，字段，定义时赋值	关键字const修饰变量，字段，定义时赋值关键字readonly修饰，可以在构造函数中赋值
密封	密封	关键字final修饰方法，类，表示不可继承，不可重写	关键字sealed修饰方法，类，表示不可继承，不可重写
属性	属性	只有字段概念，一般情况下是要定义字段XX,方法getXX()和setXX()	C#引入属性概念，简化了操作，只需要定义XX{get;set;}
判断类型	判断类型	Instanceof	is
锁	锁	Synchronized	Lock
接口	接口	关键字 implements，使用注解@Override	和继承类一样，使用符号: 实现类中的方法，不需要使用override关键字，一般命名需要用大写字母I开头
类	抽象类	abstract 使用注解@Override	abstract，重写方法需要使用override关键字
	分部类	无	partial 可以将分布在不同文件，而在相同命名空间下，相同名称并用partial标识的类合并，多用于wpf，winform框架上。
	匿名类	如Runnable hello = new Runnable() { public void run() { System.out.println("hello"); } }; 简化了定义子类的步骤。	无。类似的场景基本都是用委托的
	内部类	在new的使用上,内部类要和外部类关联起来	在new的使用上,内部类和外部类用法无区别
匿名方法	匿名方法	无。	使用delegate声明匿名方法，如 delegate(int x) { Console.WriteLine("Anonymous Method: {0}", x); };
虚拟方法	虚拟方法	默认都是虚拟方法	virtual标识虚拟方法，子类用override重写
静态	静态类	使用关键字static	使用关键字static，可以有静态构造函数，
传参	引用传递	无	在方法参数加上ref，out，使参数按引用传递即方法内改变参数的值，也会影响到方法外的值
	不定长参数	如int...	如params int[]
流程控制	循环	关键字for有两种用法 for(初始化; 布尔表达式; 更新) { //代码语句 } for(声明语句 : 表达式) { //代码句子 }	分别为for和foreach for(初始化; 布尔表达式; 更新) { //代码语句 } foreach (声明语句 in 表达式) { //代码句子 }
字符	字符	String，引用类型，需要使用方法equals比较是否相等	string，引用类型，但用法和值类型类似，可以直接用==比较是否相等，实现原理就是微软重载了string的==运算符
委托	委托	无。	使用关键字Delegate声明，是存有对某个方法的引用的一种引用类型变量。使用+使用委托的多播。
泛型	泛型	<T>声明泛型， T只能是引用类型，可以用extends和super限制T的类型， <?> 表示通配，实际上是假泛型。	<T>声明泛型， T可以是引用类型也可以是值类型使用:表示泛型约束，如T:new()表示T必须要有无参构造函数，真正的泛型。
注解与特性	注解与特性	使用@声明注解，如 @Service public class AgreementFacadeClientImpl implements AgreementFacadeClient { .... }	C#引入attribute作为特性，如 [Export(typeof(IPayModule))] [Export(typeof(IModule))] public class PayModule : IModule, IPayModule { ...... }
索引器	索引器	无。	定义了索引器，就可以使用[]取值。
运算符重载	运算符重载	无。	可以对+,-,==等内置的运行符重载，string的==比较符就是运算符重载的结果。
集合	列表	List是接口，ArrayList才是实现类	IList是接口，List是实现类
	字典	Map	Dictionary
	集合处理	流式api，对象.stream().filter(x->x.getCount()>0).collect(Collectors.toList())	Linq 对象.Where(x=>x.Count>0).ToList() 使用上方便很多
lambda	lambda	()->{}, 入参类型为函数式接口, 实质上lambda表达式会在编译阶段被转换为匿名内部类	()=>{}，入参类型为委托delegate
	方法引用	类：：实例方法类：：静态方法对象：：实例方法	类.方法
扩展方法	扩展方法	无。要实现类似功能，要编写Util类。	扩展方法是定义在静态类的静态方法，入参中的this代表使用的对象，是单继承的一种补充。
命名规范	命名规范	接口命名和类命名一样，如Module。私有字段小写字母开头，如test。方法命名是小写字母开头，如getSomeThing()	接口命名开头要加大写字母I，如IModule。私有字段开头要加_，如_test。方法命名都是单词首字母大写，如GetSomeThing()