zoukankan      html  css  js  c++  java
  • java基础_0204:运算符

    掌握Java中标识符的定义;
    掌握Java中数据类型的划分以及基本数据类型的使用原则;
    掌握Java运算符的使用;
    掌握Java分支结构、循环结构、循环控制语法的使用;
    掌握方法的定义结构以及方法重载的概念应用。

    Java中的注释
    // 注释:单行注释;
    /* ... */':多行注释;
    /** ... */:文档注释。
    
    Java中的关键字

    Java基本数据类型的大小、范围、默认值
    No. 数据类型 大小/位 可表示的数据范围 默认值
    1 byte(字节) 8 -128 ~ 127 0
    2 short(短整型) 16 -32768~32767 0
    3 int(整型) 32 -2147483648 ~ 2147483647 0
    4 long(长整型) 64 -9223372036854775808 ~ 9223372036854775807 0
    5 float(单精度) 32 -3.4E38(-3.41038) ~ 3.4E38(3.41038) 0.0
    6 double(双精度) 64 -1.7E308(-1.710308)~ 1.7E308(1.710308) 0.0
    7 char(字符) 16 0 ~ 255 'u0000'
    8 boolean(布尔) - true或false false

    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的结果转换),而与和或操作的真值表

    No. 条件1 条件2
    1 true true true true
    2 true false false true
    3 false true false true
    4 false false false false
    非运算
    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
    
  • 相关阅读:
    10分钟学会SpringBoot入门
    单链表常见的4道笔试题(Java版)
    Java面试、跳槽必刷200+真面试题,让你披荆斩棘走进大厂
    金三银四JAVA面试总结:Java+并发+Spring+MySQL+分布式+Redis+算法+JVM等
    最新整理的spring面试题从基础到高级,干货满满
    面试阿里百分百问的Jvm,别问有没有必要学,真的很有必要朋友
    面试官:你们前后端分离的接口规范是什么?
    “金九银十”已过,总结我的天猫、蚂蚁、头条面试经历(Java岗)
    350道面试题分享,拿下京东offer工资double
    2019大厂Java岗面试题全曝光,刷完这1020道,金三银四大厂等你
  • 原文地址:https://www.cnblogs.com/xuwei1/p/8338133.html
Copyright © 2011-2022 走看看