Java(C#)基础差异-语法

1、long类型

Java

long类型，若赋值大于int型的最大值，或小于int型的最小值，则需要在数字后加L或者l，表示该数值为长整数，如long num=2147483650L。

举例如下：

public static void main(String[] args) {
    /*
     * 对于long类型，若赋值大于int型的最大值，或小于int型的最小值， 则需要在数字后加L或者l，表示该数值为长整数
     */
    // 1、定义普通long类型数据
    long longnum1 = 123;
    // 2、此句会报错，因为int型的最大值为2147483647
    //long longnum2 = 2147483650;
    // 3、正确定义为
    long longnum3=2147483650L;
    System.out.println(longnum3);
}

运行结果如下，第二句会报错为：

C#

举例如下：

public static void TestMethod()
{
    long longnum3 = 2147483650;
    Console.WriteLine(longnum3);
}

C#下可以直接定义long类型变量并输出。

2、foreach语句差异

Java

举例如下：

public static void main(String[] args) {
    /*
     * foreach语句差异
     */
    int arr[] = { 1, 2, 3, 4, 5 };
    for (int x : arr) {
        System.out.println(x);
    }
}

C#

举例如下：

public static void TestMethod()
{
    List<int> tempList = new List<int>() { 1, 2, 3, 4, 5 };
    foreach (var item in tempList)
    {
        Console.WriteLine(item);
    }
}

3、定义不定长参数

Java

格式为：参数数据类型...参数名称 例如：int...a

举例如下：

public static void main(String[] args) {
    // 定义不定长参数： 参数数据类型...参数名称 例如：int...a
    System.out.println("求和结果为" + add(1, 2, 3, 4, 5));
}

public static int add(int... a) {
    int s = 0;
    for (int i = 0; i < a.length; i++) {
        s += a[i];
    }
    return s;
}

C#

举例如下：

public static void TestMethod(params int[] paras)
{
    int sumResult = 0;
    for (int i = 0; i < paras.Length; i++)
    {
        sumResult += paras[i];
    }
    Console.WriteLine(sumResult);
}

4、常量

Java

定义为final的数据无论是常量、对象引用还是数组，都不能被改变。

一个被定义为final的对象引用只能指向唯一一个对象，不可以将它再指向其他对象，但是一个对象本身的值却是可以改变的。

那么为了使一个常量真正做到不可修改，可以将常量声明为static final。

在Java中定义全局常量，通常使用public static final 修饰，这样的常量只能在定义时被赋值。

举例如下：

private static Random rand = new Random();// 实例化一个Random类对象
// 随机产生0~10之间的随机数赋予定义为final的a1
private final int a1 = rand.nextInt(10);
// 随机产生0~10之间的随机数赋予定义为static final的a2
private static final int a2 = rand.nextInt(10);

public static void main(String[] args) {
    Demo4 testObj1 = new Demo4(); // 实例化一个对象
    // 调用定义为final的a1
    System.out.println("调用a1的值为：" + testObj1.a1);
    // 调用定义为static final的a2
    System.out.println("调用a2的值为:" + testObj1.a2);
    // 实例化另外一个对象
    Demo4 testObj2 = new Demo4();
    System.out.println("调用a1的值为：" + testObj2.a1);
    System.out.println("调用a2的值为：" + testObj2.a2);
}

运行结果如下：

可以看出，定义为final的常量不是恒定不变的，将随机数赋予定义为final的常量，可以做到每次运行程序时改变a1的值。但是a2与a1不同，由于它被声明为static final形式，所以在内存中为a2开辟了一个恒定不变的区域，当再次实例化一个Demo4对象时，仍然指向a2这块内存区域，所以a2的值保持不变。a2是在装载时被初始化，而不是每次创建新对象时都被初始化；而a1会在重新实例化对象时被更改。

C#

举例如下：

public const int CONST_TEST_ONE = 1;

public static void TestMethod()
{
    Console.WriteLine(CONST_TEST_ONE);
}

5、this关键字

共性：

（1）this关键字代表本类对象的引用，可以调用类的成员变量和成员方法；

（2）this可以作为方法的返回值；

Java

举例如下：

import static java.lang.System.out;

public class thisDemo {
    private String studentName;
    public String getStduentName() {
        return this.studentName;
    }
    public thisDemo(String name) {
        this.studentName = name;
    }
    public thisDemo GetObject() {
        return this;
    }

    public static void main(String[] args) {
         thisDemo thisObj = new thisDemo("terry");
         thisDemo currentObj= thisObj.GetObject();
         out.println(currentObj.studentName);
    }
}

运行结果如下：

C#

举例如下：

public class ThisDemo
{
    public string StduentName { get; }

    public ThisDemo(string name)
    {
        StduentName = name;
    }

    public ThisDemo GetObject()
    {
        return this;
    }
}
static void Main(string[] args)
{
    SyntaxDesc.ThisDemo thisObj = new SyntaxDesc.ThisDemo("terry");
    var currentObj= thisObj.GetObject();
    Console.WriteLine(currentObj.StduentName);
    Console.ReadKey();
}

运行结果如下：

从两例可以看出，我实例化了一个对象，并传递了学生姓名（StudentName）值，随后通过调用GetObject获得this对象。根据打印的结果可以看出，this引用的就是本类当前的对象。

差异：

（1）Java中，this可以调用类中的构造方法。但使用这种方式需要注意的是只可以在构造方法的第一句使用this调用另外的构造方法。

Java

举例如下：

public class ThisDemoTwo {

    public ThisDemoTwo() {
        this("terry_test");
        System.out.println("无参构造方法");
    }

    // 定义有参构造方法
    public ThisDemoTwo(String name) {
        System.out.println("有参构造方法" + name);
    }

    public static void main(String[] args) {
        ThisDemoTwo obj=new ThisDemoTwo();
    }

}

运行结果如下：

C#

不可以

6、导入API类库

（1）导入包（导入命名空间）

Java

语法如下：

import关键字的语法如下：

import com.terrydemo.*; //指定com.terrydemo包中的所有类在程序中都可以使用　　

import com.terrydemo.Math; //指定com.terrydemo包中的Math类在程序中可以使用

在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用包中的所有类。

注意：当使用import指定了一个包中的所有类时，并不会指定这个包的子包中的类，如果用到这个包中的子类，需要再次对子包作单独引用。

C#

语法如下：

using System.Text;

using System.Threading.Tasks;

（2）导入静态成员

Java

语法如下：

使用import导入静态成员的语法如下：

import static 静态成员

举例如下：

package syntaxdesc;
import static java.lang.Math.max; //导入静态成员方法
import static java.lang.System.out;//导入静态成员变量

public class ImportTest {
    public static void main(String[] args) {
        //在主方法中可以直接使用这些静态成员
        out.println("1和4的较大值为："+max(1,4));
    }
}

C#

语法如下：

在C#6.0之前是无法实现的，在C#6.0中新增了相关语法，如下：

using  static  静态类命名空间

举例如下：

using static System.Math;

namespace JavaVSNet.SyntaxDesc
{
    public class UsingTest
    {
        public int X { get; } = 2;

        public int Y { get; set; } = 1;

        public int GetMax
        {
            get { return Max(X, Y); }
        }
    }
}

Code

JavaCode-->JavaVSNet/syntaxdesc

C#Code-->JavaVSNet/SyntaxDesc

时间： 2024-11-09 12:31:11

Java(C#)基础差异-语法的相关文章

Java(C#)基础差异-泛型

1.限制泛型可用类型 Java 语法如下: class 类名称<T extends anyClass> 其中,anyClass指摸个接口或类. 使用泛型限制后,泛型类的类型必须实现或继承了anyClass这个接口或类.无论anyClass是接口还是类,在进行泛型限制时都必须使用extends关键字. 举例如下: import java.util.*; public class LimitClass<T extends List> { public static void main(

Java(C#)基础差异-字符串

1.字符串比较 Java 对字符串对象进行比较不能简单的使用比较运算符"==",因为比较运算符比较的是两个字符串的地址是否相同.即使两个字符串的内容相同,两个对象的内存地址也是不同的,使用比较运算符仍 然会返回false.需要使用equals或者equalsIgnoreCase. 举例如下: public static void main(String[] args) { /* * 对字符串对象进行比较不能简单的使用比较运算符"==",因为 * 比较运算符比较的是两

Java最最基础的语法小结

一定得记住,不然吃大亏了真的 注意不可同时运行,每次只能运行一个类型 1 package aad;///建根文件的时候选择了这一项就要写,没选择可以不用写 2 import java.io.*; 3 import java.math.BigInteger; 4 import java.util.*; 5 6 public class main///class的名字 public也是在建立main class的时候选择了就要写,没选可删掉 7 { 8 public static void main

【Java】基础语法

虽然说Java又是一门新的编程语言,但基础的语法部分还都是可以和之前学习的编程语言一样的. 既然被称之为语法,那就必然有一定的规则.其中,在标识符和关键字部分,我们就可以很明显的看出一些强制性的要求. 关键字不能作为标识符,标识符为小写字母等,这有着一系列的规则,然而我们也并不需要去记,按着常规走,结合自身的以往的一些经验,就没什么问题. 学习了这么久的编程语言,也是总结过很多次关于数据的知识点.而这一次,一层一层,把它们之间的关系联系的更紧密了. 数据在程序中是少不了的.而我们如何获取数据或者

C#与Java多态方面的语法差异

C#与Java多态方面的语法差异 2016-11-29 Java代码: public static void main(String[] args) { Mother mother=new Mother(); mother.showName(); Mother human=new Son(); human.showName(); Son sona=new Son(); sona.showName(); } public class Mother { public void showName(){

Java多线程基础总结

背景 Java采用多线程方式实现并行计算,当然并行计算也可以采用多进程方式实现,但是进程切换耗费比较高.而且进程间是隔离的,进程间通信机制比较麻烦,最后JVM本身在操作系统中就一个进程,由它再启动一个进程不太合适,所以Java采用多线程方式实现并行计算. Java从诞生之初,多线程就围绕的是Runnable接口和Thread类展开的.它的底层采用的是c的p线程方式,而且由于多线程的复杂性,p线程的很多概念知识被延伸到了Java层面,这对Java开发者来说算是一个不幸的消息.但是由于多线程的复杂性

2018.6.13 Java语言基础复习总结

Java语言基础与面向对象编程实践 第一章 初识Java 1.1机器语言 机器语言是指一台计算机全部的指令集合.机器语言室友0和1组成的二进制数,是一串串由0和1组成的指令序列,可将这些指令序列交给计算机执行. 1.2汇编语言 负责把汇编语言翻译成二进制的机器语言,这种翻译程序就是汇编程序. 1.3高级语言 1954年第一个完全脱离机器硬件的高级语言FORTRAN诞生 1.3.1C语言 是一种计算机程序设计语言,它既有高级语言的特点,又具有汇编语言的特点. 1.3.2 C++语言 是具有面向对象

java面试基础大全,绝对经典&lt;51-95&gt;&lt;转&gt;

51.类ExampleA继承Exception,类ExampleB继承ExampleA. 有如下代码片断: try { throw new ExampleB("b") } catch(ExampleA e){ System.out.println("ExampleA"); } catch(Exception e){ System.out.println("Exception"); } 请问执行此段代码的输出是什么? 答:输出:ExampleA.(

Java Web基础 --- Jsp 综述(上)

摘要: J2EE是一套规范,而Servlet/Jsp是J2EE规范的一部分,是Tomcat的主要实现部分.在最初的应用实践中,当用户向指定Servlet发送请求时,Servlet利用输出流动态生成HTML页面,这导致Servlet开发效率极为低下.JSP技术通过实现普通静态HTML和动态部分混合编码,使得逻辑内容与外观相分离,大大简化了表示层的实现,提高了开发效率.本文以JSP的本质是Servlet为主线,结合JSP转译后所得的Servlet,详细探讨了JSP的原理.执行过程.脚本元素.编译指令