JAVA学习笔记(二) - 运算符

变量与常量

变量的声明和赋值

/*
 * 变量的声明和赋值
 */
public class Test
{
    public static void main(String[] args)
    {
        // 1-可以声明的同时，对变量赋值:int x = 10;
        //局部变量，变量名符合命名规则。
        //推荐使用此种方式。
        int x = 10;

        // 2-可以先声明，再赋值：int x; x = 10;
        int y;//变量的声明
        y = 20;//将20赋值给y指向的内存空间

        // 3-可以一行声明多个变量: int x, y, z;由,分隔
//      int a, b, c, d, e;

        // 4-一行声明多个变量，且为所有变量或部分变量赋值:由,分隔
        int a, b = 10, c, d = 20, e = 100;

        // 5-建议：一行只声明一个变量，且在声明的同时，为其初始化。
        int z = 5;

        //6-如果变量在声明的时候，不初始化，则编译通不过
        //报The local variable xx may not have been initialized
        int xx;
        xx = 100;
        System.out.println(xx);//编译错误。
    }
}

常量

/*
 * 常量
 */
public class Test
{
    public static final int MAX_AGE = 25;

    public static void main(String[] args)
    {
        //1-使用final来定义Java中的常量。
        //在声明的同时为常量名赋值。一旦赋值后，该常量名的值则不能修改。
        final int BLOOD = 10;
//      BLOOD = 100;//此时报错The final local variable BLOOD cannot be assigned. 

        //2-定义常量，可以先声明常量，再为常量赋值，注意，此种情况下，只能为常量名赋值一次。
        final int AGE;
        AGE = 20;
//      AGE = 100;//第二次赋值，会报错。The final local variable AGE may already have been assigned

        //关于常量名的命名-全部大写，如果多个单词，中间用_分割
        final int MY_AGE = 20;
    }
}

交换变量

/*
 * 交换两个变量的值的方法
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 5;

        //1-方法一
//      int temp = 0;
//      temp = a;
//      a = b;
//      b = temp;
//      System.out.println("a = " + a + ", b = " + b);

        //2-方法2
//      a = a + b;//a = 15, b = 5;//注意，有可能出现数据溢出
//      b = a - b;//a = 15, b = 10;
//      a = a - b;//a = 5, b = 10;
//      System.out.println("a = " + a + ", b = " + b);

        //3-方法3
        a = a ^ b;//a=10^5  b=5
        b = a ^ b;//b=10 a=10^5
        a = a ^ b;//a=5, b = 10
        System.out.println("a = " + a + ", b = " + b);
    }
}

字符串拼接

字符串拼接

/*
 * 字符串拼接:区分哪些是可变的，哪些是不可变的，不可变的放入""内，可变的通过+连接
 */
public class Test
{
    public static void main(String[] args)
    {
        System.out.println(10 + "aaa");//"10" + "aaa"="10aaa"
        int a = 10;
        int b = 5;
        System.out.println("a + b = " + a + b);//"a + b = 105"
        System.out.println(a + b + " = a + b");//"15 = a + b"
        System.out.println("a + b = " + (a + b));//"a + b = 15"
        System.out.println(a + " + " + b + " = " + (a + b));//10 + 5 = 15

        //(10) + (5) = [15]
        //"(" + a + ") + (" + b + ") = [" + (a + b) + "]"
        System.out.println("(" + a + ") + (" + b + ") = [" + (a + b) + "]");

        //[10 + 5] + (10 - 5) = [result]
        //"[" + a + " + " + b + "] + (" +  + a + " - " + b + ") = [" + ((a + b) + (a - b)) + "]"

        //作业
        //[a] + [b] / [a - b] = [result]
    }
}

运算符

运算符-算术运算符

/*
 * 运算符-算术运算符
 */
public class Test
{
    public static void main(String[] args)
    {
        byte b1 = 10;
        byte b2 = 20;
        byte b3 = (byte)(b1 + b2);

        int x = 100;
        int y = 10;
        System.out.println(x + y);//110
        System.out.println(x - y);//90
        System.out.println(x * y);//1000
        System.out.println(x / y);//10
        //%，以后经常使用再判断条件中，判断一个数能否被另一个数整除。
        //如果整除则余数为0,否则，不为0
        System.out.println(x % y);//0 求模或求余

        int a = 12;
        int b = 5;
//      float b = 5.0f;
        //两个数相除时，如果两个数都是整数，则结果一定是整数。
        System.out.println(a / b);//2

        int w = 10;
        int q = 0;
        //编译时，发现不了分母为0的错误。
        //运行时错误，java.lang.ArithmeticException: / by zero
        System.out.println(w / q);
    }
}

自增：++与自减：–

/*
 * 自增：++    ++a或a++  相当于 a = a + 1;
 * 自减：--    --a或a--    相当于a = a - 1;
 *
 * ++/-- 位于操作数之前，该操作数参与运算时，会先自增/自减，再参与运算。
 * ++/--位于操作数之后，该操作数先用当前值参与运算，再自增/自减
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        a++;//a = a + 1;
        System.out.println(a);

        int b = 10;
        b--;//b = b - 1;
        System.out.println(b);

        //++/--位于操作数的前后
        int aa = 10;
        System.out.println(aa++);//10
        System.out.println(aa);//11
        int bb = 10;
        System.out.println(++bb);//11
    }
}

案例

/*
 * ++或--案例
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 10;
        int c = 10;
//              a=11  b=11  c=9   b=10  a=10
        //      10    11    10      10  11
        int d = a++ + ++b + c-- + --b + a--;
        System.out.println(d);
        System.out.println(a++ + 1);//11  a=11
        System.out.println(--b + --c + a++);//28  a=12,b=9,c=8

        a += b;//a = a + b;
        a -= b;//a = a - b;
        a *= b;
        a /= b;
        a %= b;

        byte b1 = 10;
        byte b2 = 10;
//      b1 = b1 + b2;//编译错误
//      b1 = (byte)(b1 + b2);
        b1 += b2;// b1 = (byte)(b1 + b2);
    }
}

关系运算符

/*
 * 关系运算符->,>=,<,<=,==,!=,instanceof
 *  使用关系运算符，如果成立，返回true，否则，返回false
 *  比较运算符，条件判断中比较常用。
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 20;

        System.out.println(a > b);//false
        System.out.println(a < b);//true
        System.out.println(a >= b);//false
        System.out.println(a <= b);//true
        System.out.println(a == b);//false
        System.out.println(a != b);//true

        boolean flag = true;
        System.out.println(flag = false);//false
//      flag = false;
//      System.out.println(flag);

        System.out.println(flag == true);//false
    }
}

逻辑运算符

/*
 * 逻辑运算符
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = 6;
        int c = 7;
        //&&  || 有短路的逻辑运算符，此种形式非常常用。
        //&&逻辑与---全部条件都为true，结果才为true
        //条件1 && 条件2 && 条件3...
        //表示条件1，2，3同时为true，结果才为true。
        System.out.println(a < b && b < c);//true
        System.out.println(a < b && b > c);//false
        System.out.println(a < b && b < c && a < c);//true
        //||逻辑或---全部条件，都为false，结果才为false
        //条件1 || 条件2 || 条件3...
        //表示条件1，2，3任何一个为true，结果为true。
        System.out.println(a < b || b < c);//true
        System.out.println(a < b || b > c);//true
        System.out.println(a < b || b < c || a < c);//true
        System.out.println(a > b || b > c);//false

        //& | 无短路的逻辑运算符
        //&逻辑与---全部条件都为true，结果为true
        System.out.println(a > b & b < c);//false
        System.out.println(a < b & b < c);//true
        //|逻辑或---全部条件，都为false，结果才为false
        System.out.println(a < b | b < c | a < c);//true
        System.out.println(a > b | b > c);//false
    }
}

位运算符

/*
 * 位运算符
 *  ~, ^, &, |
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = 7;

//      ~  按位取反
//  5   00000000000000000000000000000101
//  ~5 11111111111111111111111111111010--补码
//      11111111111111111111111111111001--反码
//      10000000000000000000000000000110--原码
        System.out.println(~a);

//      &   按位与 对应的位全部为1，结果为1.
//      特点：一个数与全1相与，得到其本身。全0相与，得到0
//  5   00000000000000000000000000000101
//  7   00000000000000000000000000000111
//  &
//      00000000000000000000000000000101
        System.out.println(a & b);

//      |   按位或 对应位，全部为0，结果为0
//      5   00000000000000000000000000000101
//      7   00000000000000000000000000000111
//      |
//          00000000000000000000000000000111
        System.out.println(a | b);

//      ^   按位异或    对应的位，相同为0，不同为1
//      5   00000000000000000000000000000101
//      7   00000000000000000000000000000111
//      ^
//          00000000000000000000000000000010
        int c = a ^ b;
//      System.out.println(c ^ a);//c^a=b
//      System.out.println(c ^ b);//c^b=a
        System.out.println(a ^ b);
//      文件 ^ 12341234---加密
//      加密后文件 ^ 12341234---解密
    }
}

/*
 * 移位运算符
 *  << 左移   10 << 2 表示10表示的二进制向左移动2位    10*2的2次方
 *  >> 右移   10 >> 2表示10的二进制向右移动2位，10/2的2次方
 * >>> 无符号右移    10 >>> 2表示10的二进制向右移动2位， 10/2的2次方。
 */
public class Test
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = -5;
//      << 有符号左移
//      5 << n  高位去掉n位，低位以0补n位，相当于x乘以n个2；
//  5   00000000000000000000000000000101--补码
//  <<2 00000000000000000000000000010100
        System.out.println(a << 2);

//  -5  10000000000000000000000000000101--原码
//  -5  11111111111111111111111111111010--反码
//      11111111111111111111111111111011--补码
//  <<2 11111111111111111111111111101100--移位后补码
//      11111111111111111111111111101011--移位后反码
//      10000000000000000000000000010100--移位后原码
        System.out.println(b << 2);

        int x = 16;
        int y = -16;
//      >> 有符号右移
//      5 >> n  低位去掉n位，高位以符号位补n位，相当于x除以n个2；
//16    00000000000000000000000000010000
//  >>2 00000000000000000000000000000100
        System.out.println(x >> 2);

//  -16  10000000000000000000000000010000
//       11111111111111111111111111101111--反码
//       11111111111111111111111111110000--补码
//-16>>2 11111111111111111111111111111100--移位后的补码
//       11111111111111111111111111111011--移位后反码
//       10000000000000000000000000000100--移位后原码
        System.out.println(-16 >> 2);

//      >>> 无符号右移
//      16 >>> 2    低位去掉n位，高位以0补n位，相当于x除以n个2；
        System.out.println(x >>> 2);

//  -16     10000000000000000000000000010000
//          11111111111111111111111111101111--反码
//          11111111111111111111111111110000--补码
//-16>>>2   00111111111111111111111111111100
        System.out.println(y >>> 2);

//      2 << 5;
//      62-63=1;
    }
}

条件运算符

/*
 * 条件运算符：
 *  条件表达式?返回值1:返回值2
 */
public class Test
{
    public static void main(String[] args)
    {
        //条件运算符一定会返回一个值。
        int a = 10;
        int b = 5;

        int c = a > b? a : b;
        System.out.println(c);

        boolean flag = false;
        int x = flag?10:20;
        System.out.println(x);

        String str = 10 < 20 ? "10 < 20" : "10 > 20";
        System.out.println(str);
    }
}
时间： 2024-10-10 20:46:33

JAVA学习笔记(二) - 运算符的相关文章

Java学习笔记二：数据类型

Java学习笔记二:数据类型 1. 整型:没有小数部分,允许为负数,Java整型分4种:int short long byte 1.1 Int最为常用,一个Int类型变量在内存中占用4个字节,取值范围从-2 147 483 6至2 147 483 647 超过20亿,如果用来存储大于20亿的值,最好使用long型. 1.2  int 与Integer: Java中的数据类型分为基本数据类型和复杂数据类型.Int为前者,integer为后者. Integer是int的封装类,提供了很多转换方法,当

Java学习笔记二：初始化（一）

1.对象初始化 在使用 new 初始化对象时,系统通常使用默认的构造函数,这个构造函数没有返回值,格式为: public class InitializeTest { private int a; // 默认构造函数 public InitializeTest() { } // 自定义构造函数 public InitializeTest(int a) { this.a = a; } } 虽然在使用 new 创建实例时,返回了这个对象的引用,但是这个与没有返回值的void方法不同 //void方法

Java学习笔记四——运算符

算术运算符 加减乘除(+.-.*./)就不说了. 求余运算符% 描述:第一个操作数除以第二个操作数,得到一个整除的结果后剩下的值就是余数 注意:求余预算的结果不一定总是整数,当操作数是浮点数时,结果可能是小数. double a = 5.2; double b = 3.1; double mod = a%b; System.out.println(mod);//值为2.1 自增运算符++ 自增运算符++有两个要点: ++是单目运算符只能操作一个操作数 ++只能操作在数值型(整数.浮点型)的变量上

Java学习笔记二：初始化（二）

这里主要学习初始化,分为: 1.变量初始化 2.构造函数初始化 3.数组初始化 4.继承初始化   1.变量初始化 成员初始化分为两种: (1)成员变量初始化 在定义成员变量时,如果没有给变量赋于初始值,系统会给出一个默认值. 这里有两种选择:要么使用系统的默认初始值,要么自己定义初始值. 系统给出的默认输出值为: boolean false char [ ] byte 0 short 0 int 0 long 0 float 0.0 double 0.0 refenece null char初

黑马程序员——JAVA学习笔记二(语法基础)

1,     Java程序都是以类的形式存在的,所以需要告诉虚拟机需要加载类的位置,那么可以设置classpath变量.classpath变量如果有;,则表示还会在当前目录查找,没有;则不会在当前目录查找. 当然如果没有classpath也会在当前目录查找. 2,    rd删除目录,加/S可以删整个目录,Windows从里向外删除. 3,    一个文件只有一个public类,文件名必须和类名相同,如果不是友好类,则不需要同名. 4,    JAVA一共有50个关键字 关键字是电脑语言里事先定

Java学习笔记二（基础语法）

1 Java 是强类型语言,提供的8中基本数据类型有以下几类: Byte :字节类型,一个字节,有符号的8位的整数.字节类型参与运算的时候,会转化为int类型. byte b;b=3;b=(byte)(b*3);  在这里第二个赋值必须经过强制类型转化,否则会编译出错. short:2个字节,Byte可行可以直接赋值给short,但是反过来需要强制类型转化. int:4字节类型的有符号的整数. long:8个字节类型的有符号的整形 char:2个字节的无符号的类型.采用的是Unicode的编码格

数组排序、递归——（Java学习笔记二）

升序: 选择排序: 选定一个元素,一次和后面的元素相比较,如果选定的元素大雨后面的比较元素,就交换位置 先出现最小值,最后出现最大值. public static void main(String[] args) { int[] arr = {5,8,9,12,55,565,421,12,2512,-5,-56}; sortMethod(arr); p(arr); } //排序核心代码 private static void sortMethod(int arr[]) { for(int i =

Java学习笔记——位运算符、方法、package包、键盘输入

位运算符: a>>b = a左移b位 = a*2^2 右移舍去低位 方法: method,function,与c函数类似 package包: 通常第一句 写域名倒着写 package --; 主要包: java.lang 核心类string.math.Integer.System.Thread等 java.awt 构建管理GUI java.net 网络相关 java.io 输入输出 java.util 定义系统特性.使用与日期日历相关的函数 (详见api) 键盘输入: 使用别的包的类需要imp

Java学习笔记二：初始化（三）

3.数组初始化 1.数组是一个固定长度的集合,在初始化大小后就不能改变其长度. 数组分配在堆中,并在栈中存有指向该数组的一个引用. class Arr { public static void main(String[] args) { int[] a = {1, 2, 3, 4}; int[] b = a; for (int i = 0; i < b.length; i++) { b[i]++; } for (int i = 0; i < a.length; i++) { System.ou