4.22

最新推荐文章于 2021-02-20 16:16:49 发布

原创最新推荐文章于 2021-02-20 16:16:49 发布 · 278 阅读

0 ·

CC 4.0 BY-SA版权

JAVA

运算符余下的内容

如果使用整数除以零，运行时将出现异常（ArithmeticException）,对于整数的求余运算同样会是一个运行时异常。

如下的try 语句中的代码使用整数除以零，将抛出 ArithmeticException 异常，但是使用小数除以零时，无论是正数或是负数都会得到 Infinity(无穷大)打印结果:

public class MainClass6 {
        public static void main(String args[]) {
                //整数运算
                int i=6;
                try {
                     System.out.println(i/0);
                } catch (ArithmeticException ae) {
                      ae.printStackTrace();
                }
                System.out.println("=============");
                //小数运算
                float f=15.1F;
                //正无穷
                System.out.println((f/0));
                //负无穷
                System.out.println((f/-0));
        }
}

输出的结果如下：

F:\gz\JAVA\Ysf>java MainClass6
java.lang.ArithmeticException: / by zero
at MainClass6.main(MainClass6.java:6)
=============
Infinity
Infinity

可以看到，用整数除以零将抛出异常，而浮点数则会返回一个无穷大的数 Infinity

其中抛出异常这一原理要加以深究，为何浮点数会返回一个无穷大的数

Java语言中，加号(+)运算符被重载，不仅可以用于算术加运算，还可以用于字符串连接运算。：

public class MainClass7 {
        //主方法
        public static void main(String args[]) {
                String s="Java";
                int a=4;
                int b=6;
                System.out.println(s+a+b);
                System.out.println(s+(a+b));
                System.out.println(a+b+s);
        }
}

可以看到三种不同的输出结果，只是因为加号的运用方法不同，输出结果为：

F:\gz\JAVA\Ysf>java MainClass7
Java46
Java10
10Java

由此，可以总结为：

当加号两边都是数字时就做数学加，但是当加号两边有一边为字符串时，就进行字符串加运算

①如果一个操作数是String 字符串，则加号用作字符串连接运算符

②如果两两边都是数字，则加号用作加法运算符

下面一则例子则没有很好的理解：

public class MainClass8 {//主方法
        public static void main(String args[]) {
                int a=5;
                int b=2;
                if((a==b++)||(b<++a)) {
                      System.out.println("a="+a+" b="+b);
                }
        }
}

输出结果：F:\gz\JAVA\Ysf>java MainClass8
a=6 b=3

实际上涉及到递增与递减运算，运算符在变量前面时，先做递增或递减运算再使用变量

运算符在变量后面时，先使用变量再做递增或递减运算。

移位运算符,用于将数字(二进制)的位向左或者向右移动，以为运算符只能用在整数上，不能对浮点数使用。

<<(左移——乘以2) >>(右移——除以2) >>>(无符号右移)

public class MainClass10 {
        public static void main(String args[]) {
                int i=16;
                //右移2
                System.out.println("将"+i+
                               "逻辑右移2后得到的数为: "+(i=i>>2));
                //左移2
                System.out.println("将"+i+
                               "逻辑左移2后得到的数为: "+(i=i<<2));
                //无符号右2
                System.out.println("将"+i+
                               "逻辑无符号右移2后得到的数为: "+(i=i>>>2));
        }
}

输出结果如下：F:\gz\JAVA\Ysf>java MainClass10
将16逻辑右移2后得到的数为: 4
将4逻辑左移2后得到的数为: 16
将16逻辑无符号右移2后得到的数为: 4

等于运算符

用于比较两个变量的内容，并返回一个布尔值true 或 false ，该运算符有两种，分别是：==等于和 !=不等于

用于比较的两个变量可以是基本数据类型，布尔型，字符和对象引用。

对于比较对象引用是比较两个引用是否指向同一个对象。

:public class MainClass11 {
        public static void main(String args[]) {
                //整数
                int a=2;
                int b=3;
                System.out.println(a+"=="+b+" "+(a==b));
                System.out.println(a+"!="+b+" "+(a!=b));
                //小数
                double d1=10.2;
                double d2=56.3;
                System.out.println(d1+"=="+d2+" "+(d1==d2));
                System.out.println(d1+"!="+d2+" "+(d1!=d2));
                //字符
                char c1='c'; char c2=c1;
                System.out.println(c1+"=="+c2+" "+(c1==c2));
                System.out.println(c1+"!="+c2+" "+(c1!=c2));
                //布尔值
                boolean b1=false;
                boolean b2=true;
                System.out.println(b1+"=="+b2+" "+(b1==b2));
                System.out.println(b1+"!="+b2+" "+(b1!=b2));
        }
}

上述代码中，分别声明了两个int 类型，两个 double 类型，两个char 类型和两个 boolean类型的变量，然后分别进行等于运算并打开运算结果

输出信息如下：

F:\gz\JAVA\Ysf>java MainClass11
2==3 false
2!=3 true
10.2==56.3 false
10.2!=56.3 true
c==c true
c!=c false
false==true false
false!=true true

需要注意的是，不能将= 与 == 混淆，前者用于赋值，如下

public class MainClass12 {
        public static void main(String args[]) {
                boolean b=false;
                if(b=true) {
                     System.out.println("b=true");
                } else {
                     System.out.println("b=false");
                }
        }
}

上述代码中， if 语句的条件表达式中将 true 的值赋给 boolean 类型的变量 b ，而不是判断 b 是否等于 true

所以输出的结果为：

F:\gz\JAVA\Ysf>java MainClass12
b=true

关于等于运算符用于引用变量时，比较的内容问题：

比较的是两个引用变量是否指向同一个对象(等于运算符比较位是否相同):

public class MainClass13 {
        public static void main(String args[]) {
                //创建两个内容相同的String对象
                String s1=new String("Java");
                String s2=new String("Java");
                String s3=s2;
                System.out.println("s1==s2@@@"+(s1==s2));
                System.out.println("s2==s3@@@"+(s2==s3));
        }
}

上述中，先创建了两个内容相同的字符串对象并将其赋值给两个不同的引用变量s1 和 s2 ，然后再将s2 引用变量赋值给 s3 ，最后分别比较 s1 s2 是否相同；s2 s3 是否相同，

两个内容为 Java 字符串的 String 对象，并将 s2 赋值给了 s3

从下面所示的运行结果可以看出，s1 和 s2 虽然内容相同，但是它们指向的并不是同一个 String 对象

所以比较结果如下：

F:\gz\JAVA\Ysf>java MainClass13
s1==s2@@@false
s2==s3@@@true

数组的创建

创建数组对象时使用关键字 new ，语法格式为

数组名=new 类型[元素个数]；

public class ArrayTest {
        //主方法
        public static void main(String args[]) {
                //声明一个一维数组的引用
                int[] i;
                //创建一维数组对象并将它赋值给引用i
                i=new int[2];
                //声明一个二维数组的引用
                int[][] ii;
                //创建二维数组对象并将它赋值给引用ii
                ii=new int [2][3];
        }
}

如上，无论是声明数组引用还是创建数组对象，在Java 中都不能直接使用它们。要讲前面介绍的内容联系起来，就是完整的数组声明和创建

而且，在创建数组对象时，必须给出数组的长度信息，否则将会编译报错。

因为在数组对象被创建时，JVM 需要为此数组对象分配内存空间。所以必须在创建数组对象时给出数组的长度

一般来说，数组一旦被创建，其大小是不可改变的。但是也可以通过其他方式修改数组的大小。

在Java 语言中，数组是一个对象被赋值给一个数组引用，只要将数组引用赋值给另一个数组对象即可：

public class ArrayTest1 {
        //主方法
        public static void main(String args[]) {
                //声明并创建一维数组对象并将它赋值给引用i
                //数组大小为2
                int[] i=new int[2];
                //打印长度信息
                System.out.println("长度为: "+i.length);
                //将长度为5的新的数组对象赋值给i引用变量
                i=new int[5];
                //打印长度信息
                System.out.println("长度为: "+i.length);
        }
}

上述例子使用了数组的length 属性来获取数组的长度信息。注意是 length 属性而不是 length 方法

输出结果如下：

F:\gz\JAVA\sz>java ArrayTest1
长度为: 2
长度为: 5

初始化数组

声明和创建数组后，就可以使用数组来存储数据了，这时就需要对数组进行赋值操作，即初始化数组

如果没有显示地给数组对象赋初值，那么系统会根据具体的数组类型给予相应的初始值。

public class InitialArray {
        //主方法
        public static void main(String args[]) {
                //以一维数组为例
                //声明基本数据类型数组
                byte[] b=new byte[2];
                short[] s=new short[1];
                char[] c=new char[1];
                int[] i=new int[1];
                long[] l=new long[1];
                float[] f=new float[1];
                double[] d=new double[1];
                //声明对象类型数组
                Object[] obj=new Object[1];
                //打印数组默认初始值
                System.out.println("byte类型默认初始值为: "+b[0]);
                System.out.println("byte类型默认初始值为: "+b[1]);
                System.out.println("short类型默认初始值为: "+s[0]);
                System.out.println("char类型默认初始值为: "+c[0]);
                System.out.println("int类型默认初始值为: "+i[0]);
                System.out.println("long类型默认初始值为: "+l[0]);
                System.out.println("float类型默认初始值为: "+f[0]);
                System.out.println("double类型默认初始值为: "+d[0]);
                System.out.println("类型默认初始值为: "+obj[0]);
        }
}

如上例子分别声明了原始数据类型和对象类型的数组，然后打印数组的默认初始值

输出结果如下：

F:\gz\JAVA\sz>java InitialArray
byte类型默认初始值为: 0
byte类型默认初始值为: 0
short类型默认初始值为: 0
char类型默认初始值为:

int类型默认初始值为: 0
long类型默认初始值为: 0
float类型默认初始值为: 0.0
double类型默认初始值为: 0.0
类型默认初始值为: null

char 类型的数组没有打印任何内容，这是因为 char 类型的默认值为 \u0000, 而 \u0000 为不可见字符，所以没有打印任何内容

如上代码中，byte 数组长度为2，在对数组的长度进行访问时，在Java 语言中数组的下标从 0 开始计算。如下：

public class OutOfBounds {
        //主方法
        public static void main(String args[]) {
                //声明一个数组
                int[] i=new int[2];
                //初始化数组
                i[0]=1;
                i[1]=2;
                i[2]=3;//
        }
}

声明了一个 int 类型的一维数组并对其进行初始化操作，该程序通过了编译，但是试图运行时出现了一下错误：

F:\gz\JAVA\sz>java OutOfBounds
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
at OutOfBounds.main(OutOfBounds.java:9)

从打印结果可以看出，当访问数组下标越界时，系统将抛出运行时异常，数组的最大下标应该等于声明时的长度减1

在编程时，一般不会声明一个数组对象却使用其默认的初始值对数组进行各项操作，而是会手动地输入初始值：

public class InitialArray1 {
        //主方法
        public static void main(String args[]) {
                //声明一维数组并初始化
                int[] i=new int[]{1,2,3,4};
                //打印数组中的元素
                for(int ii:i) {
                       System.out.println(ii+" ");
                }
                System.out.println();
        }
}

上述例子声明了数组对象并对其进行初始化操作，从程序运行后的结果可以看出，数组的元素有1，2，3，4

F:\gz\JAVA\sz>java InitialArray1
1
2
3
4

除了使用枚举的方式对数组进行初始化，还有没有别的方式呢？这里关于枚举这一方式，需要了解其原理，或者说了解它的定义

接上，除了枚举的方式，对于一些有规律的数组对象还可以使用for 循环对其进行初始化：

public class InitialArrayFor {
        //主方法
        public static void main(String args[]) {
                //声明一维数组并初始化
                int[] j=new int[4];
                //使用for循环对数组进行初始化操作
                for(int i=0;i<4;i++) {
                       j[i]=i;
                }
                System.out.println("初始化结束!");
                //打印数组中的元素
                System.out.println("数组中的元素有: ");
                for(int ii:j) {
                       System.out.print(ii+" ");
                }
                System.out.println();
        }
}

通过该方式运行结束后输出如下信息：

F:\gz\JAVA\sz>java InitialArrayFor
初始化结束!
数组中的元素有:
0 1 2 3

通过以上两种方法都可以对数组进行初始化，

那么对于多维数组的初始化能不能采用上述办法？可以的：

public class InitialArray2 {
        //主方法
        public static void main(String atgs[]) {
                //声明二维数组并初始化
                int[][] i=new int[][]{
                      {1,2,3,4},
                      {4,3,2,1}
                };
                //打印数组中的元素
                for(int[] ia:i) {
                      for(int ii:ia) {
                             System.out.print(ii+" ");
                      }
                      System.out.println();
                }
        }
}