教学日志：javaSE-java中的数据类型和运算符

一、java中的标识符

/*
标识符的命名规范：
		硬性要求：
				1、必须以字母、_下划线、美元符$开头
				2、其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合
				3、大小写敏感，长度无限制
				4、不可以是Java的关键字和保留字,这些是供内部使用的
		常规建议：
				1、驼峰命名
					类名、接口名一般首字母都是大写，从第二个单词开始首字母都要大写
					变量名、方法名一般第一个单词小写，从第二个单词开始首字母大写

				2、见名知义
					看见名字就知道是什么意思
					一定不要用拼音或者中文起名字
*/

public class IdentifierDemo{
	public static void main(String[] args){

		//int a = 10;
		//int $b = 20;
	    //int a+b = 30;  错误
		//int a1 = 10;
		//int 1b = 100;// 错误
		//String a = "a";
		//String A = "a";

		//int public = 20;  错误

		//String findById = "abc";

		String name = "张三";
		int age = 20;
		System.out.println(a);

	}
}

二、变量和常量

/*
变量和常量
			定义
			  变量：在我们程序运行的过程中，值会发生变化的量成为变量；
			  常量：在我们程序运行的过程中，值不会发生变化的量成为常量；

			  语法：定义一个变量和常量的语法
			       变量：  数据类型   变量名 =  值;
				   常量： final  数据类型   变量名 =  值;

			变量：数据类型   变量名称（标识符）  作用域
			    1、先声明，后赋值
					int a;
					a = 10;
				2、声明+赋值
					int b = 20;

			常量：指的就是在程序的运行过程中，有一些是一成不变的值(最终变量)，说白了就是只能赋值一次，一般使用
				  final关键字来修饰常量

			注意：
				  在类内部，方法之外定义的变量我们称之为成员变量（全局变量），会有默认值
				  在方法内部使用的变量称之为局部变量，在使用之前必须先初始化，不会有默认值
				  一行可以定义多个变量，但是不建议这样写，最好一行只定义一个变量，增加代码的可读性
				  变量赋值的时候，那个值称为常量
*/

public class ConstantAndVar{

	static int a;//成员变量

	public static void main(String[] args){
		//int a;  //声明
		//a = 10;//赋值
		//int b = 20;
		//b = 100;
		//System.out.println(b);

		//final int c = 10;
		//c = 20;//错误
		//System.out.println(c);
		System.out.println(a);

		//int b;//错误
		//System.out.println(b);

		//int a=10,b=20; 不规范
		int a = 10;
		int b = 20;

	}
}

三、数据类型，本节重点讲解基本数据类型（4类8种），引用数据类型后面讲解

/*
数据类型
		java是一种强类型的语言
			强类型语言：在使用变量之前，必须显示的声明其变量的数据类型。    java
			弱类型语言：在使用变量之前，不需要显示声明变量的数据类型，会自动根据赋值类型识别   js,python,scala

		基本数据类型：4类8种
				整数类型：byte short int long 不同的整数类型表示不同的长度
					byte:使用1个字节存储，所以数据范围是从-128~127
					short:使用2个字节存储，所以数据范围是从-32768~32767
					int:使用4个字节存储，所以数据范围是大概是正负21亿
					long:使用8个字节存储，所以数据范围，你懂的.......

					注意：
						1、整型类型默认类型是int
						2、如果想定义一个变量为long类型的话，数字后面记得加上大写L，因为小写的l很容易和数字1混淆。

				浮点类型:float double 表示方法：小数点    科学计数法
					float:使用4个字节存储，小数点后面可以精确到7位小数
					double:使用8个字节存储，小数点后面可以精确到float精度的2倍

					注意：
						1、浮点类型默认是double
						2、单精度浮点类型定义的时候记得在小数后面加上f
						3、浮点类型并不能精确的表示一个数，它会有精度的丢失

				字符类型:char
					占用2个字节，使用字符类型的时候，使用''表示
					注意：
						char类型可以当成int类型来处理，字符对应的是ASCII码表中的值
				布尔类型：boolean
					占用1位，只有两个值，注意是小写的，true(真)或false(假)
		引用数据类型：
			类(class)
			接口(interface)
			数组(array)

*/

public class DataTypeDemo{
	public static void main(String[] args){
		//byte a = 128;  错误

		//short b = 32768; 错误

		//int a = 3111111111; 错误

		//long a = 3111111111L;

		/*float f1 = 3.3452321123123f;
		float f2 = 3.345232112312321321f;
		System.out.println(f1 == f2);*/

		//字符类型
		char a = 'B';
		System.out.println(a == 66);
		//字符串类型，一个字符序列
		//String A = "AB";
		//System.out.println(A);

		char ch1 = '\t';//转义符
		System.out.println("[" + ch1 +  "]");
		char ch2 = '\u0009';//转义符
		System.out.println("[" + ch2 +  "]");

		System.out.println("\"abc\"");

		int a1 = 10;
		boolean flag = true;
		System.out.println((a1 == 10) == flag);

	}
}

四、运算符

/*
运算符：
	算术运算符: +，-，*，/，%，++，--
	赋值运算符 =
		一个=是赋值运算符，==是关系运算符
	扩展赋值运算符:+=，-=，*=，/=
	关系运算符: >，<，>=，<=，==，!=
		两边一般都不是具体的值，而是表达式
	逻辑运算符: &&，||，!
	位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
	条件运算符 ？：

*/

public class OperatorDemo{
	public static void main(String[] args){
		int a = 1;
		int b = 2;

		//算术运算符
		System.out.println(a+b);
		System.out.println(a-b);
		System.out.println(a*b);
		//取整除，或者取商
		System.out.println(a/b);
		//取余数，或者取模
		System.out.println(a%b);

		//给一个4位数，对应取出个位、十位、百位、千位数字？
		int i = 2345;//?
		System.out.println("个位数是：" + (i%10));

		//++：单目运算符，自加1操作，如果++在前面，先自加，再运算
		//	  如果++在后面，先运算，再自加
		System.out.println(a++);
		System.out.println(++a);
		//--：单目运算符，自减1操作，如果--在前面，先自减，再运算
		//	  如果--在后面，先运算，再自减
		//System.out.println(a--);
		//System.out.println(--a);

		//面试题:运算符的优先级的问题    ++优先级是大于+
		System.out.println(++b+b++);//?  6
		System.out.println("-------------------");
		System.out.println(b);//4

		//扩展运算符
		int c = 1;
		//两种写法的结果是一样的，都是做+2操作
		//建议操作的时候都使用扩展运算符
		//c = c + 2;
		c += 2;

		//基本数据类型的转换：byte类型的d，当它+20的时候，等号右边变成了int类型，左边是byte类型，
		//                    大范围向小范围转型需要强制转换   写法：(datatype)

		byte d = 10;
		//d = d + 20;
		d += 20;
		System.out.println(d);

		//关系运算符
		System.out.println(2>3);
		System.out.println(2<3);
		System.out.println(2>=3);
		System.out.println(2<=3);
		System.out.println(2==3);
		System.out.println(2!=3);

		//逻辑运算符
		/*
			&&：短路与，当第一个表达式是false，那么后面的表达式就不再执行了
			||：短路或，当第一个表达式是true，那么后面的表达式就不再执行了
			&：逻辑与，不管第一表达式返回true还是false，两边的表达式都会执行
			|：逻辑或，不管第一表达式返回true还是false，两边的表达式都会执行

		*/
		int aa = 1;
		//System.out.println(2 > 3 && 5 > aa++);
		System.out.println(2 > 3 & 5 > aa++);
		System.out.println(aa);
		System.out.println(2 > 3 || 5 > 4);
		System.out.println(!false);
		System.out.println(!true);

		//位运算符
		System.out.println(4 & 5);//4
		System.out.println(4 | 5);//5
		System.out.println(4 ^ 5);//1
		//移码   原码  反码  补码
		System.out.println(~4);//-5  ？？

		//位运算符：
		/*
			>>：有符号右移，除2操作，移动几位就除以几个2
			<<：有符号左移,乘2操作，移动几位就乘以几个2
			>>>：无符号右移
		*/
		//把2变成16的最高效的方法是什么？
		System.out.println(2 << 3);
		System.out.println(16 >> 3);

		//条件运算符：三目运算符
		//            第一个表达式返回为true，则取？后的值，反之，取：后的值。
		System.out.println( 2 < 3 ? 2 : 3);
		System.out.println(false ? false : true ? false : true);

		/*
			基本数据类型之间的转换：
				1、一般写代码的时候，都是使用同一种数据类型，低位会向高位自动转换（隐式转换）
				2、在同一种数据类型转换的时候，高位向低位不会自动转换，需要使用强制转换
				3、强制转换会数据精度的丢失
		*/
		byte x = 10;
		x = (byte)(x + 20);
		//int y = x + 20;
		System.out.println(x);
		System.out.println((byte)270);//14

	}
}

五、作业

1. 输入自己的名字，年龄和性别，分别用不同的变量接收，并将输入的信息做输出

import java.util.Scanner;
public class TestPerson {
	public static void main(String[] args) {
		System.out.println("Please input your name here:");
		Scanner input = new Scanner(System.in);
		String Name = (String) input.next();
		System.out.println("Please input your age here:");
		int age = input.nextInt();
		System.out.println("Please input your gender here:");
		String gender = input.next();
		System.out.println("The computer recorded that ：");
		System.out.println("Your nanme is：" + Name);
		System.out.println("Your age is：" + age);
		System.out.println("Your gender is：" + gender);
	}
}

2.输入圆形半径，求圆形的周长和圆形的面积,并将结果输出。

import java.util.Scanner;
public class TestCircle {
	public static void main(String[] args) {
		// 定义圆周率
		final double PI = 3.14;
		Scanner input = new Scanner(System.in);
		// 输入半径
		System.out.println("请输入圆的半径:");
		// 计算周长和面积
		float r = input.nextFloat();
		double c = 2 * PI * r;
		double s = PI * r * r;
		// 输出周长和面积
		System.out.println("该圆的半径为：R=" + r);
		System.out.println("该圆的周长为：C=" + 2 + "*" + PI + "*" + r + "=" + c);
		System.out.println("该圆的面积为：S=" + PI + "*" + r + "*" + r + "=" + s);
	}
}

3.银行利率表如下表所示，请计算存款10000元，活期1年、活期2年，定期1年，定期2年后的本息合计。

结果如下图所示。（结果四舍五入，不保留小数位。使用Math.round(double d)实现）

public class TestDeposit {
	public static void main(String[] args) {
		//给出本金并输出
		int money = 10000;
		System.out.println("本金："+money);
		//计算活期1年本金并输出
		double result1 = money*(1+0.35/100);
		System.out.println("活期1年本金总计："+Math.round(result1));
		//计算定期1年本金并输出
		double result2 = money*(1+1.50/100);
		System.out.println("定期1年本金总计："+Math.round(result2));
		//计算活期2年本金并输出
		double result3 = money*(1+0.35/100*2);
		System.out.println("活期2年本金总计："+Math.round(result3));
		//计算定期2年本金并输出
		double result4 = money*(1+2.10/100*2);
		System.out.println("定期2年本金总计："+Math.round(result4));
	}
}

4.某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。结果如图所示。

public class TestEncryption {
	public static void main(String[] args) {
		//输入一个4位整数
		Scanner s = new Scanner(System.in);
		System.out.print("请输入一个4位正整数：");
		int num = s.nextInt();
		//获取各个位上的数
		int bit4 = (num / 1000); // 取千位的数字
		int bit3 = (num / 100) % 10; // 取百位的数字
		int bit2 = (num / 10) % 10; // 取十位的数字
		int bit1 = num % 10; // 取个位的数字
		//每位数字加5
		bit4 = (bit4+5)%10;
		bit3 = (bit3+5)%10;
		bit2 = (bit2+5)%10;
		bit1 = (bit1+5)%10;
		//交换第一位和第四位
		int  temp;
		temp = bit4;
		bit4 = bit1;
		bit1 = temp;
		//交换第二位和第三位
		temp = bit2;
		bit2 = bit3;
		bit3 = temp;
		// 输出加密后数字
		//System.out.println("加密后的数字为："+bit4+bit3+bit2+bit1);
		int ennum = bit4*1000+bit3*100+bit2*10+bit1;
		System.out.println("加密后的数字为："+ennum);

	}
}

5.利用”异或”运算的性质,对几个字符进行加密并输出密文,然后再解密。加密算法是：密钥是字符’8’，明文的每个字符和密钥进行异或运算，得到密文。密钥和密文的每个字符再次进行异或运算，重新得到明文。结果如图所示。

public class TestEncryption2 {
	public static void main(String args[]) {
		//原文
		char a1 = '十', a2 = '点', a3 = '进', a4 = '攻';
		System.out.println("加密前原文:" + a1 + a2 + a3 + a4);
		//加密
		char secret = '8';
		a1 = (char) (a1 ^ secret);
		a2 = (char) (a2 ^ secret);
		a3 = (char) (a3 ^ secret);
		a4 = (char) (a4 ^ secret);
		System.out.println("密文:" + a1 + a2 + a3 + a4);
		//解密
		a1 = (char) (a1 ^ secret);
		a2 = (char) (a2 ^ secret);
		a3 = (char) (a3 ^ secret);
		a4 = (char) (a4 ^ secret);
		System.out.println("解密后原文:" + a1 + a2 + a3 + a4);
	}
}