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

最新推荐文章于 2023-04-03 17:49:32 发布
最新推荐文章于 2023-04-03 17:49:32 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： 精通JAVA语言 文章标签： 变量与常量 运算符 算术运算符 关系运算符 逻辑运算符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzi11322/article/details/44494361
版权

变量与常量

变量的声明和赋值

/*
 * 变量的声明和赋值
 */
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);
    }
}
陆讯
关注
专栏目录
Java学习笔记系列-基础篇-运算符
嗨
04-27 916
Java学习笔记 Java学习笔记是一个持续更新的系列，工作多年，抽个空对自身知识做一个梳理和总结归纳，温故而知新，同时也希望能帮助到更多正在学习Java 的同学们。 本系列目录 入门篇 计算机基础 计算机编程语言 面向对象的编程思想 基础篇 环境搭建 第一个Java程序 开发工具 Java中的注释 标识符与关键字 变量与常量 数据类型 运算符 运算符 ...
JAVA学习笔记04----运算符与表达式
ce121的博客
04-20 115
整除取整 package stu03; import java.util.Scanner; public class lesson04_1 { public static void main(String[] args) { int a, b; int i; Scanner sc = new Scanner(System.in); // 输入部分 System.out.print("a="); a =
《Java核心技术卷Ⅰ》读书笔记——3.5 运算符
sparrow学习博客
03-11 160
3.5.6 关系和boolean运算符 &amp;&amp;和||运算符是按照“短路”方式来求值的：如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了。 3.5.7 位运算符 3.5.8 运算符级别 3.5.9 枚举类型 enum Size{ SMAll, MEDIUM, LARGE, EXTRA_LARGE }; 现在，可以声明这种类型的变量： Size s ...
java读书笔记1(基本类型和运算符)
戎马天涯
03-10 103
java读书笔记1(基本类型和运算符) 一.程序启动: 1.java虚拟机默认是以指定类的main方法开始执行(eg:执行命令,java MyApp,这是虚拟机就从MyApp类的main方法开始执行). 2.main方法的规范:public static void main(string[] args){};(为什么必须是这样呢????) 二.java中的注释:多行注释不能嵌套的. 1....
Java 读书笔记 (九) 运算符
weixin_30617695的博客
12-22 81
短路逻辑运算符 && 当使用与逻辑运算符时，在两个操作数都为true时，结果才为true,但是当得到第一个操作为false时，其结果就必定是false,这时候就不会再判断第二个操作了。 1 public class LuoJi{ 2 public static void main(String[] args){ 3 int a=...
JAVA自学笔记，运算符。
Lxxx_H的博客
07-22 152
运算符 运算符是一些特殊符号，主要用于数学函数，一些类型的赋值语句和逻辑比较方面。Java中提供了丰富的运算符，如赋值运算符，算术运算符和比较运算符等。 一，赋值运算符。 赋值运算符以符号“=”表示，它是一个双目运算符,其功能是将右边操作数所含的值赋值给左边的操作数。如：int a = 100;将100赋值给a。左边的操作数必须是一个量，而右边的操作数则可以是变量，常量，有效的表达式（如123）....
《java编程思想》读书笔记之——java中的操作符
cullinans的博客
02-10 462
一：优先级 根据以上表格总结出的优先级为： 后缀运算符（.）>单目运算符(++)>new>乘除>加减>移位>关系(大于，小于)>相等>按位与>按位异或>按位或>逻辑与>逻辑或>条件（？：）>赋值二：逻辑操作符注意：逻辑操作符“与”，“或”，“非” 只可应用于布尔值，与c和c++不同的是，java中不可以将一个非布尔值当做一个布尔值来使用。 三：按位操作符注意：按位操作符不可以对布尔值执行非操作。
java学习笔记---从入门到精通之路.pdf
11-25
Java学习笔记---从入门到精通之路.pdf Java是当前最流行的编程语言之一，本笔记旨在帮助初学者从基础到精通J2EE高手之路。本笔记涵盖了Java基础知识、J2EE框架、Web开发、数据库操作、图形游戏开发等方面的知识点，...
java学习笔记(四)-运算符
qq_45205390的博客
02-10 434
java学习笔记(四)-运算符 文章目录java学习笔记(四)-运算符运算符赋值，算术和一元运算符简单赋值运算符算术运算符一元运算符相等，关系和条件运算符等价和关系运算符条件运算符类型比较运算符instanceof(及判断对象是否继承于父类)按位和移位运算符运算符摘要简单赋值运算符算术运算符一元运算符等于和关系运算符条件运算符类型比较运算符按位和移位运算符问题与练习：运算符问题 运算符 运算符是特...
Java运算符和表达式--学习笔记.docx
07-05
在Java中，运算符大致分为六类：算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符和其他运算符。 算术运算符包括加(+), 减(-), 乘(*), 除(/), 取模(%)以及自增(++)和自减(--). 自增和自减运算符有两种...
java初学读书笔记
Do
12-22 356
1.一个完整的java类通常由下面六个部分组成： 包定义语句                package import语句                 import 类定义{                      public class ______ 成员变量 构造方法 成员方法     } 访问修饰符：public（公共的）、protected（受保护的)，无修饰符和
局部变量 final Java,Java8 Stream编译器消息-局部变量必须是final或有效的final
weixin_29332029的博客
02-21 856
I have a little problem. When I write this for loop, the variable i in f.getAnswerScore().get(i).... is underlined with error message : - Local variable i defined in an enclosing scope must be final o...
【java】局部变量必须定义为final
XYZ
05-23 6270
今天写多线程程序时遇到一个Java的错误：Local variable i defined in an enclosing scope must be final or effectively final，即局部变量不许声明为final。详情请移步：为什么java内部类访问局部变量必须声明为final？ 其实原因就是一个规则：java内部类访问局部变量时局部变量必须声明为final。 那...
The final local variable xxx cannot be assigned, since it is defined in an enclosing type
热门推荐
雨一直下
10-21 3万+
yuanwe 本文就自己编程时候遇到的一个问题，简要描述一下，并提出解决的方法：                出错信息：The final local variable xxx cannot be assigned, since it is defined in an enclosing type“，其中xxx是一个局部变量名               首先这是一个java编
为什么java内部类访问局部变量必须声明为final？
大树的学习之路
10-18 1万+
先抛出让我疑惑了很久的一个问题 编程时，在线程中使用局部变量时候经常编译器会提示：局部变量必须声明为final package test; public class ThreadTest { public void function(String a) { new Thread(){ @Override public void run() { Syst
java 对象final_Java面向对象编程中final关键字的使用方法详解
weixin_29936201的博客
02-18 413
在Java中通过final关键字来声明对象具有不变性(immutable)，这里的对象包括变量，方法，类，与C++中的const关键字效果类似。immutable指对象在创建之后，状态无法被改变可以从三个角度考虑使用final关键字：代码本身：不希望final描述的对象所表现的含义被改变安全：final对象具有只读属性，是线程安全的效率：无法修改final对象本身，对其引用的操作更为高效final...
java final jvm_JVM对于声明为final的局部变量（local var）做了哪些性能优化？（转载）...
weixin_36145673的博客
02-16 324
参考原文：https://www.zhihu.com/question/21762917/answer/19239387http://bbs.itheima.com/thread-136974-1-1.htmlhttps://zhidao.baidu.com/question/488076257.html作者：RednaxelaFX链接：https://www.zhihu.com/question...
Java面向对象核心修饰符，final修饰符、常量、常量方法与常量类
最新发布
关注我！带你一路 "狂飙" 到底！
04-03 1702
java面向对象的3个核心修饰符：abstract、static和final，详细讲解！全文干货
Java中10的平方
csucoderlee的专栏
06-10 1万+
大晚上的犯困，写了个算法，中间有一步是需要10的c-1次方，顺手就写了个10^(c-1)，结果跑了半天结果都不对。后来打个断点，才发现这里写的有问题，10^2 代表10的二进制与2的二进制进行异或。如果，想计算10的c-1次方，就只能使用math包提供的函数了，Math.pow(10, c-1)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值