java基础_第02章：运算符

掌握Java中标识符的定义；

掌握Java中数据类型的划分以及基本数据类型的使用原则；

掌握Java运算符的使用；

掌握Java分支结构、循环结构、循环控制语法的使用；

掌握方法的定义结构以及方法重载的概念应用。

Java中的注释

// 注释：单行注释；
/* ... */‘：多行注释；
/** ... */：文档注释。

Java中的关键字

Java基本数据类型的大小、范围、默认值

int型常量转换为long型常量，使用“数字L”、“数字l（小写的字母L）”完成；

int型变量转换为long型变量，使用“(long) 变量名称”

将int型变量变为double型变量:(double) 变量名称

类型强转：(目标数据类型) 变量

public class TestDemo {
    public static void main(String args[]) {
        int max = Integer.MAX_VALUE;    // 取出最大值
        int min = Integer.MIN_VALUE; // 取出最小值
        // int变量 ± long型常量 = long型数据
        System.out.println(max + 1L); // 最大值加1：2147483648
        System.out.println(min - (long) 1); // 最小值减1：-2147483649
        // long变量 ± int型常量 = long型数据
        System.out.println((long) min - 2); // 最小值减2：-2147483650
    }
}
程序执行结果：
2147483648（“System.out.println(max + 1L)”语句输出）
-2147483649（“System.out.println(min - (long) 1)”语句输出）
-2147483650（“System.out.println((long) min - 2)”语句输出）

字符可以和int型互相转换（以编码的形式出现）

public class TestDemo {
    public static void main(String args[]) {
        char c = ‘A‘ ;  // 字符
        int num = c ;// 字符可以和int型互相转换（以编码的形式出现）
        System.out.println(c) ;
        System.out.println(num) ;
    }
}
程序执行结果：

A（“System.out.println(c)”语句输出）
65（“System.out.println(num)”语句输出）

public class TestDemo {
    public static void main(String args[]) {
        char c = ‘A‘;   // 大写字母
        int num = c;    // 需要将字符变为int型才可以使用加法计算
        num = num + 32;     // 变为小写字母的编码
        c = (char) num;     // 将int变为char型
        System.out.println(c);
    }
}

程序执行结果： a

布尔型

布尔型是一种逻辑结果，主要保存两类数据：true、false，这类数据主要用于一些程序的逻辑使用上。

public class TestDemo {
    public static void main(String args[]) {
        boolean flag = false ;  // 布尔只有两种取值：true、false
        if (!flag) {    // if(布尔值) {满足条件的操作}
            System.out.println("Hello World .") ;
        }
    }
}
程序执行结果：
Hello World .

String型

String属于引用数据类型（它属于一个类，在Java里面只要是类名称，每一个单词的首字母都是大写的），但是这个类的使用比较特殊。

String表示的是一个字符串，即：多个字符的集合，String要求使用双引号“"”声明其内容。

public class TestDemo {
    public static void main(String args[]) {
        String str = "Hello World !";   // 字符串变量
        System.out.println(str);        // 输出字符串变量
        System.out.println("Hello World !");    // 输出字符串常量
    }
}
程序执行结果：
Hello World !
Hello World !

字符串连接

在字符串的操作中，如果要改变内容，则可以使用“+”进行字符串的连接操作。

public class TestDemo {
    public static void main(String args[]) {
        String str = "Hello";
        str = str + " World ";      // 字符串连接
        str += "!!!";       // 字符串连接
        System.out.println(str);
    }
}
程序执行结果：
Hello World !!!

运算符

Java运算符（1）

关系运算符

关系运算符的主要功能是进行数据的大小关系比较，返回的结果是boolean型数据（只有true、false两种取值），常用的关系运算符有：大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于（!=）。

public class TestDemo {
    public static void main(String args[]) {
        System.out.println("3 > 1 = " + (3 > 1));   // 使用大于号
        System.out.println("3 < 1 = " + (3 < 1));   // 使用小于号
        System.out.println("3 >= 1 = " + (3 >= 1)); // 使用大于等于号
        System.out.println("3 <= 1 = " + (3 <= 1)); // 使用小于等于号
        System.out.println("3 == 1 = " + (3 == 1)); // 使用等于号
        System.out.println("3 != 1 = " + (3 == 1)); // 使用不等于号
    }
}

程序执行结果：
3 > 1 = true
3 < 1 = false
3 >= 1 = true
3 <= 1 = false
3 == 1 = false
3 != 1 = false

数学运算符

数学运算符是在开发之中经常使用到的，例如，进行四则运算、求模、自增等。

public class TestDemo {
    public static void main(String args[]) {
        int numA = 10;
        int numB = 20;
        System.out.println("加法计算：" + (numA + numB));
        System.out.println("减法计算：" + (numA - numB));
        System.out.println("乘法计算：" + (numA * numB));
        System.out.println("除法计算：" + (numA / (double) numB));
    }
}

程序执行结果： 加法计算：30
减法计算：-10
乘法计算：200
除法计算：0.5

模运算

“模”也是在开发之中较为常见的计算，所谓的“模”实际上就是余数的概念，例如：10 ÷ 3的结果是商3余1，其中余数1就是“模”，对于求模，可以使用“%”运算符。

public class TestDemo {
    public static void main(String args[]) {
        int numA = 10;
        int numB = 3;
        System.out.println(numA % numB);
    }
}

程序执行结果： 1

简化运算符

虽然Java提供了四则运算操作，但是为了简化用户的编写，在运算符里面又提供了一些简化运算符：*=、/=、+=、-=、%=，这些运算符表示参与运算后直接进行赋值操作

public class TestDemo {
    public static void main(String args[]) {
        int num = 10;
        num *= 2;       // 等价：num = num * 2 ;
        System.out.println(num);
    }
}

程序执行结果： 20

自增与自减运算

还有一类运算符是“++”（自增）、“--”（自减），它根据位置不同，执行的顺序也不同；
++变量、--变量：先在前面表示的是先进行变量内容的自增1或自减1之后再使用变量进行数学计算；
变量++、变量--：先使用变量内容进行计算，而后再实现自增或自减的操作。

观察自增一

public class TestDemo {
    public static void main(String args[]) {
        int numA = 10;          // 定义整型变量
        int numB = 20;          // 定义整型变量
        // “++”写在变量前面，表示先对numA的变量内容加1
        // 使用处理后的numA变量的内容 + numB变量的内容
        int result = ++numA + numB;
        System.out.println("numA = " + numA);
        System.out.println("result = " + result);
    }
}

程序执行结果：
numA = 11
result = 31

观察自增二

public class TestDemo {
    public static void main(String args[]) {
        int numA = 10;          // 定义整型变量
        int numB = 20;          // 定义整型变量
        // “++”写在后面，表示先使用numA的内容进行加法计算
        // 加法计算完成之后在对numA的内容进行自增
        int result = numA++ + numB;
        System.out.println("numA = " + numA);
        System.out.println("result = " + result);
    }
}
程序执行结果：
numA = 11
result = 30

三目运算

三目是一种赋值运算的形式，执行三目的时候可以以一个布尔表达式的结果进行赋值，基本的语法结构如下：

数据类型 变量 = 布尔表达式 ? 满足此表达式时设置的内容 : 不满足此表达式时设置的内容 ;

public class TestDemo {
    public static void main(String args[]) {
        int numA = 10;  // 定义int型变量
        int numB = 20;  // 定义int型变量
        // 如果numA大于numB，返回true，则将numA的内容赋值给max
        // 如果numA小于numB，返回false，则将numB的内容赋值给max
        int max = numA > numB ? numA : numB;
        System.out.println(max);
    }
}
程序执行结果： 20

逻辑运算

逻辑运算一共包含三种：与（多个条件一起满足）、或（多个条件有一个满足）、非（使用“!”操作，可以实现true变false与false变true的结果转换），而与和或操作的真值表

非运算

public class TestDemo {
    public static void main(String args[]) {
        boolean flag = true;        // 定义布尔型变量
        System.out.println(!flag);  // 对变量结果进行非操作
    }
}

程序执行结果： false

观察普通与“&”

public class TestDemo {
    public static void main(String args[]) {
        if ((1 == 2) & (10 / 0 == 0)) {// 使用普通与判断多个条件
            System.out.println("Hello World !");
        }
    }
}

程序执行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.xusan.TestDemo.main(TestDemo.java:5)

使用短路与（&&）

public class TestDemo {
    public static void main(String args[]) {
        if ((1 == 2) && (10 / 0 == 0)) {
            System.out.println("Hello World !");
        }
    }
}

没有输出，不抛出错误，“&&”执行前面的语句，为假则不执行后面的语句

观察普通或操作（|）

public class TestDemo {
    public static void main(String args[]) {
        if ((1 == 1) | (10 / 0 == 0)) {
            System.out.println("Hello World !");
        }
    }
}
程序执行结果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at TestDemo.main(TestDemo.java:3)

观察短路或操作（||）

public class TestDemo {
    public static void main(String args[]) {
        if ((1 == 1) || (10 / 0 == 0)) {
            System.out.println("Hello World !") ;
        }
    }
}
程序执行结果： Hello World !

位运算

位运算在Java之中存在：&、|、^、~、>>、<<、>>>，而所有的位运算都是采用二进制数据进行操作的，基本的二进值数据操作结果如表所示。

实现位与操作

public class TestDemo {
    public static void main(String args[]) {
        int numA = 9;       // 定义整型变量
        int numB = 11;          // 定义整型变量
        System.out.println(numA & numB);    // 位与操作
    }
}
程序执行结果： 9

实现位或操作

public class TestDemo {
    public static void main(String args[]) {
        int numA = 9;   // 定义整型变量
        int numB = 11;  // 定义整型变量
        System.out.println(numA | numB);// 位或操作
    }
}
程序执行结果： 11

原文地址：https://www.cnblogs.com/xuwei1/p/8338133.html