Java基础---运算符、控制台输入、随机数

Java运算符-控制台输入-Java随机数的生成

Java运算符

算术运算符

	包括:	+ - * / % ++ --
	注意:byte,short,char在参与算数运算时都会先自动转为int类型后再参与运算
	注意其中的/ % ++/--
	/  两个int类型的数相除，得到的结果一定是一个int类型，而且是无条件舍弃掉小数位的int类型
	%  取余/取模 模运算   a%b表示a/b后的余数
	++/-- 自增1/自减1
	前++和后++单独使用时没有任何区别
	但是参与运算时前++就是先自增再运算，后++就是先运算后自增

/**
 * 演示Java中的算数运算符
 * @author JackeyLov9
 *
 */
public class Operator {
	public static void main(String[] args){
		//算数运算
		short s1 = 10;
		int i1 = 15;
		double dou = 3.14;
		int i2 = s1 + i1;
		System.out.println(i2);
		//注意:	byte short char在参与算数运算时都会自动转为int类型后参与运算
		short i3 = (short)(s1 + 15);
		System.out.println(i3);
		char c1 = 'a';//97
		char c2 = 'A';//65
		char c3 = '0';//48
		int i4 = c1  + 1;
		System.out.println(i4);
		
		int i6 = 11;
		int i7 = 2;
		double i5 = 11/2;//Java中两个int类型的数相除，得到的结果一定是一个int类型，而且是小数位无条件舍弃的整数
		System.out.println(i5);
		//若要得到浮点数，则需要将其中一个int类型整数转换为double类型
		i5 = (double)i6/i7;
		System.out.println(i5);
		
		//% 模运算	取余|取模
		int i8 = i6%i7;//i6/i7取余数
		System.out.println(i8);//1
		
		//	++/--	自增1/自减1
		//	++在前和++在后的区别
		/*单独使用时，++在前和在后没有任何区别
		 * 但是参与运算时，++在前则是先自加1再运算，++在后时则是先运算后自加
		 * --同理
		 */
		int a =10;
		a++;//==>a = a+1
		++a;
		System.out.println(a);
		
		int b = 10;
		int c = b++ + 5 + ++b +2;
		System.out.println(c);//c=29
		System.out.println(b);//b=12
		
		
		int x = 5;
		int y = --x + 5 - x-- + ++x + 2 - x++;
		System.out.println(x);//x=5
		System.out.println(y);//y=7
	}
}

关系运算符

>(大于) <(小于) ==(等于) >=(大于等于) <=(小于等于) !=(不等于)
	注意:所有关系运算符的结果都是布尔类型

/**
 * 演示Java中的关系运算符
 * @author JackeyLov9
 *
 */
public static void main(String[] args) {
		int a = 5;
		int b = 10;
		int c = 15;
		boolean f1 = a > b;//false
		boolean f2 = a < b;//true
		boolean f3 = a == b;//false
		boolean f4 = a != b;//true
		boolean f5 = a >= b;//false
		boolean f6 = a <= b;//true
 //		boolean f7 = a > b > c;//编译错误,java中不能连续的写上多个关系运算符
		System.out.println(f1);//false
		System.out.println(f2);//true
		System.out.println(f3);//false
		System.out.println(f4);//true
		System.out.println(f5);//false
		System.out.println(f6);//true
		System.out.println('1'==1);//false(字符型在参与运算时会自动转换为int类型进行运算)
	}

逻辑运算符(布尔运算符)

| 逻辑或	& 逻辑且(与)
|| 短路或	&& 短路且(与)
！ 取反/非
^  逻辑异或
逻辑运算的结果也都全为boolean类型
通常用于连接多个关系运算
| 逻辑或	当两边都为false时，则结果为false,只要任意一边为true,则结果就是true-----一真则真
		  逻辑或的判断过程:无论有连接了多少个关系运算，每一个都会执行
|| 短路或	当两边都为false时，则结果为false,只要任意一边为true,则结果就是true-----一真则真
		  短路或的判断过程:只要遇到一个true,无论后面还连接了多少个关系运算都不在执行
		  
& 逻辑且	当两边都为true时，则结果为true,只要任意一边为false,则结果就是false------一假则假
		  逻辑且的判断过程:无论连接了多少个表达式，每一个表达式都会执行
&& 短路且	当两边都为true时，则结果为true,只要任意一边为false,则结果就是false------一假则假
		  短路且的判断过程:只要遇到一个false,无论后面还连接了多少个表达式都不在执行
		  
! 非(取反)	非真即假	非假即真

^ 异或	同假异真(都为相同的boolean结果时则为false,至少有一个不同的boolean结果时则为true)

/**
 * 演示Java中的逻辑运算符(布尔运算符),结果也都是boolean类型
 * @author JackeyLov9
 *
 */
public class BooleanOperator {
	public static void main(String[] args) {
		//逻辑或 |	逻辑或的执行过程，无论连接了多少个关系运算，每一个都会执行
		int a = 3;
		int b = 4;
		int c = 5;
		boolean f1 = b < a | c > ++b | c++ == b;
		System.out.println(f1);//true
		System.out.println(b);//5
		System.out.println(c);//6
	
		//短路或 || 短路或的执行过程，一旦表达式的结果为true，则无论后面还有多少个表达式都不会再执行
		int x = 3;
		int y = 4;
		int z = 5;
		boolean f2 = y > x || z > ++y;
		System.out.println(f2);//true
		System.out.println(y);//4
		
		
		//逻辑且	无论有多少个表达式，每一个表达四都会执行
		//x < y < z
		boolean f3 = x < y & y < z;
		System.out.println(f3);
		
		boolean f4 = x > y & ++y == z;
		System.out.println(f4);//false
		System.out.println(y);//5
		
		//短路且	只要遇到一个表达式结果为false,则都不再执行后面的表达式
		boolean f5 = x >y && ++y == z;
		System.out.println(f5);//false
		System.out.println(y);//5
		
		boolean boo1 = true;
		boolean boo2 = false;
		boolean boo3 = true;
		boolean boo4 = false;
		boolean f6 = boo1 | boo2;
		System.out.println(f6);//true
		//运算优先级问题	只要遇到或就加括号-->不用考虑优先级问题
		boolean f7 = boo2 && boo4 || boo1;//==>(boo2 && boo4) || boo1
		System.out.println(f7);
		//! 非(取反)
		boolean f8 = !boo1;
		System.out.println(f8);//false
		boolean f9 = !(x > y);
		System.out.println(f9);//true
		
		
		//^ 逻辑异或	同假异真
		boolean f10 = boo1 ^ boo2;
		System.out.println(f10);//true
		boolean boo5 = true;
		boolean f11 = boo1 ^ boo3;
		System.out.println(f11);//false
	
	}
}

拼接运算符

	+
	注意:若两边都为数值类型则进行算数运算，只要任意一边遇到字符串，则后面全做字符串拼接，拼接后为字符串类型

/**
 * 演示Java中的拼接运算符
 * @author JackeyLov9
 *
 */
public class StrContactOperator {
public static void main(String[] args) {
		System.out.println(1+2+3+4);//10
		//一旦遇到字符串，则后面全都是字符串
		System.out.println(1+2+3+"4");//"64"
		System.out.println(1+2+"3"+4+5);//"3345"
		System.out.println("1"+2+3+4+5);//"12345"
		System.out.println(1+2+"3"+(4+5));//"339"
		System.out.println("abc" + 4 + 5);//"abc45"
		int a = 1;
		int b = 2;
		System.out.println("a" + a + b);//"a12"
		System.out.println("a" + a + "b");//"a1b"
		String str1 = "a";
		String str2 = "b";
		System.out.println(str1 + a + str2 +b);//"a1b2"
	}
}

赋值运算符

	1. 简单赋值运算符 
		=
		等号右边的值赋值给等号左边的变量
		int a = 10;
		a++;
		System.out.println(a);//11
		int b = 10;
		int y = b++;
		System.out.println(y);//10
	
	2.扩展赋值运算符 += -= *= /= %=

/**
 * 演示Java中的简单赋值运算符
 * @author JackeyLov9
 *
 */
public static void main(String[] args) {
		//简单赋值运算符 =	将等号右边的值赋值给等号左边的变量
		int a;
		a = 5;
		int x = 5;
		int y = x++;//注意:此处是参与了赋值运算,所以++在后时是先赋值运算,再才自增
		System.out.println(y);//5
		System.out.println(x);//6
}

/**
 * 演示Java中的扩展赋值运算符
 * @author JackeyLov9
 *
 */
public static void main(String[] args) {

		//扩展赋值运算符
		//+= -= *= /= %=
		int b = 10;
//		b = b + 10;
		b += 10;//==> b = b + 10;
		System.out.println(b);//20
		b -= 10;//==> b = b - 10;
		System.out.println(b);//10
		b *= 10;//==> b = b * 10;
		System.out.println(b);//100
		b /= 10;//==> b = b / 10;
		b %= 10;//==> b = b % 10;
		System.out.println(b);//0
		
		int i1 = 5;
		i1 = i1 + 5;
		int i2 = 5;
		i2 += 5;
		System.out.println(i1 + "," + i2);
		//注意:当为byte, short时,一定要注意先会自动转为int参与运算
		short s1 = 5;
//		s1 = s1 + 5;//编译错误
		short s2 = 5;
		s2 += 5;//此处由于时扩展运算符，所以不会编译错误
//		s2 = 10;
		
		int m = 8;
		int n = 8;
		int k = 8;
		m += n += k += 1;//等号右边赋值给等号左边
		//m += (n += 9)
		//m += 17
		//m = m+17
		System.out.println(m + "," + n + "," + k);//25,17,9
		
		int j = 4;
		int r = 2;
		int z = 3;
		r -= z++ * --j;
		System.out.println(j + "," + r + "," + z);
	}

条件运算符(三元运算符/三目运算符)

语法：
	逻辑表达式 ？ 结果1 : 结果2
执行顺序:
	逻辑表达式的结果若为true，则执行结果1，否则执行结果2
注意:
	结果1和结果2的数据类型必须一致

/**
 * 演示Java中的条件运算符
 * @author JackeyLov9
 *
 */
public static void main(String[] args) {
		int age = 10;
		String str = age >= 18 ? "已成年" : "小屁孩儿";
		System.out.println(str);
		
		int a = 1;
		int b = 3;
		int c = 5;
		int d = 6;
		int result = a > b ? a : c > d ? c : d;
		//情况1: a > b 为true时，则直接执行结果1，也就是直接将a赋值给result
		//情况2: a > b 为false时，则执行结果2，也就是执行 c > d ? c : d;
		//		情况2.1: c > d 为true时，则结果为c
		//		情况2.2: c > d 为false时，则结果为d
		System.out.println(result);//6
		
		short s1 = 10;
		short s2 = 20;
		short s3 = 30;
		short s4 = s1 > s2 ? s1 : s2 > s1 ? s3 : s1;
		System.out.println(s4);
	}

控制台输入

	Scanner类
	我们需要学的Scanner类是属于引用数据类型，先了解一下引用数据类型
	
	引用数据类型的使用
		与定义基本数据类型的变量不同，引用数据类的变量定义以及赋值有一个相对固定的步骤或格式
		语法格式:
			数据类型  变量名 = new 数据类型();
		每种引用数据类型都有其功能，我们可以调用该类型实例的功能
			变量名.方法名();

    Scanner类
  		Scanner类是众多引用数据中的一种，我们可以使用该类来完成用户的键盘录入，获取到录入的数据
  		
  		Scanner的使用步骤：
  			<1>导包： import java.util.Scanner;
			<2>创建对象的实例：Scanner scan = new Scanner(System.in);
			<3>调用方法：
				int i = scan.nextInt();//获取整数
				String str = scan.next();//获取字符串
				double dou = scan.nextDouble;//获取浮点数
			<4>关闭输入流，释放底层资源
				scan.close();

/**
 * 演示Scanner的用法
 * @author JackeyLov9
 *
 */
public class ScannerDemo {
	public static void main(String[] args) {
		//创建Scanner的对象实例
		Scanner scan = new Scanner(System.in);
		//提醒用户输入
		System.out.println("请输入你要写的内容:");
		//接收控制台输入的字符串
//		String content = scan.next();
		//接收控制台输入的整数
		int content = scan.nextInt();
		System.out.println("------------这是一条分割线");
		int tota1 = content * 10;
		//使用接收到的资源
		System.out.println(tota1);
		System.out.println("您好啊，嘿嘿嘿:");
		String st = scan.next();
		System.out.println("你好啊:" + st);
		//关闭输入流，释放底层资源
		scan.close();
	}
}

Java中随机数的生成

Java中要想生成一个随机数有很多种方法，先简单介绍两种供大家参考使用
方式一:
	  使用Math.random()生成[0~1)之间的随机数
方式二:
       创建Random对象的实例
       		Random ran = new Random();
       调用Random中的方法
       		int a = ran.nextInt(n);//生成[0~n)之间的随机整数
            int b = ran.nextInt();//生成int范围内的随机整数
            double c = ran.nextDouble();//生成[0~1)之间的随机数

import java.util.Random;

/**
 * 演示随机数的生成
 * @author JackeyLov9
 *
 */
public class RandomDemo {
	public static void main(String[] args) {
		//第一种随机数的生成
		double a = Math.random();//生成[0~1)之间的随机数	[表示包括	)表示不包括
		System.out.println(a);
		//要生成[0~100)之间的随机数
		double b = Math.random() * 100;
		System.out.println(b);
		//要生成[0~100)之间的整数
		int c = (int) (Math.random() * 100);
		System.out.println(c);
		//要生成[10~20)
		double d = (Math.random() * 10) + 10;
		System.out.println(d);
		
		
		//第二种随机数的生成方式
		//创建一个Random对象的实例
		Random ran = new Random();
		//生成随机数
		int x = ran.nextInt();//在int的取值范围内随机整数
		System.out.println(x);
		//生成[0~100)之间的随机整数
		int y = ran.nextInt(100);
		System.out.println(y);
		//生成[0~1)之间的随机数
		double z = ran.nextDouble();
		System.out.println(z);
	}