数据类型和运算符
标识符
总的命名规则:见名知意。如果有多个单词组成，首单词小写，其余单词的首字母大写(驼峰命名法)。
1.首字母只能是字母，下划线和$
2.其余字母可以字母,下划线，$和数字
3.不能使用预留关键字
4.严格区分大小写
合法的标识符：
int a = 3; int _123 = 3; int $12aa = 3; int 变量1 = 55;
不合法的标识符：
int 1a = 3; //不能用数字开头 int a# = 3; //不能包含#这样的特殊字符 int int = 3; //不能使用关键字
关键字
Java关键字是Java语言保留供内部使用的,如class用于定义类。 关键字也可以称为保留字,它们的意思是一样的。
|
abstract |
Assert |
boolean |
break |
byte |
case |
|
catch |
char(character) |
class |
const |
continue |
default |
|
do |
Double |
else |
extends |
final |
finally |
|
float |
For |
goto |
if |
implements |
import |
|
instanceof |
Int |
interface |
long |
native |
new |
|
null |
Package |
private |
protected |
public |
return |
|
short |
Static |
strictfp |
super |
switch |
synchronized |
|
this |
Throw |
throws |
transient |
try |
void |
|
volatile |
While |
|
|
|
不能使用关键字作为变量名或方法名。
变量和常量
变量的概念:
变量就是内存空间的表示，可以用于存储数据，并在运行的过程可以重新赋值。
变量的声明
变量必须先声明，后赋值，再使用。
语法:
数据类型 变量名[=值];
int age; age=10; //声明到赋值一步完成 int age=10; 也可以一次性声明多个相同类型的变量 int a,b,c;
常量概念
常量:程序在运行过程中不能对其重新赋值，在java中使用final修饰的变量就是常量。
常量的命名规则: 使用大写字母,如果有多个单词组成，中间使用_连接。
final double PI=3.14; final int MAX_VALUE=10;
数据类型
整型变量
byte
short
int
long
区别在于不同类型的整型，最大值，最小值不一样
如果试图给byte类型的变量赋予超出其范围的值，就会产生编译错误
public class HelloWorld{ public static void main(String[] args){ byte b = 1; short s = 200; int i = 300; long l = 400; /*如果试图给byte类型的变量赋予超出其范围的值，就会产生编译错误*/ byte b2 = 200; } }
char类型
用于存放一个字符，值用单引号'表示 (双引号表示字符串)
其长度和short一样，也是16位的
只能存放一个字符，超过一个字符就会产生编译错误
public class HelloWorld{ public static void main(String[] args){ char c = '中'; //char 只能存放一个字符，超过一个字符就会产生编译错误 char c2 = '中国'; //报错 char c3 = 'ab'; //报错 } }
浮点数类型
float 长度为32位
double 长度为64位
注意： 默认的小数值是double类型的
所以 float f = 54.321会出现编译错误，因为54.321的默认类型是 double，其类型 长度为64，超过了float的长度32
在数字后面加一个字母f，直接把该数字声明成float类型
float f2 = 54.321f,
这样就不会出错了
public class HelloWorld{ public static void main(String[] args){ double d = 123.45; //该行会出现编译错误，因为54.321是double型的 float f = 54.321; float f2 = 54.321f; } }
布尔型用于表示真假
其长度为1
boolean b1 = true; boolean b2 = false;
分别代表真假
虽然布尔型真正存放的数据是0(false) 1(true)
但是，不能直接使用0 1 进行赋值
public class HelloWorld { public static void main(String[] args) { boolean b1 = true; boolean b2 = false; // 虽然布尔型真正存放的数据是0(false) 1(true) // 但是，不能直接使用0 1 进行赋值 boolean b3 = 1; } }
String类型其实并不是基本类型，但是它是如此广泛的被使用，常常被误以为是一种基本类型。
public class HelloWorld { public static void main(String[] args) { String str = "Hello Java"; } }
运算符
+ - * /
基本算数操作符
public class HelloWorld { public static void main(String[] args) { int i = 10; int j = 5; int a = i+j; int b = i - j; int c = i*j; int d = i /j; } }
%取模
public class HelloWorld { public static void main(String[] args) { int i = 5; int j = 2; System.out.println(i%j); //输出为1 } }
自增 自减
public class HelloWorld { public static void main(String[] args) { int i = 5; i++; System.out.println(i);//输出为6 } }
++
--
在原来的基础上增加1或者减少1
关系操作符
public class HelloWorld { public static void main(String[] args) { int a = 5; int b = 6; int c = 5; System.out.println(a>b); //返回 false System.out.println(a>=c); //返回 true System.out.println(a==b); //返回false System.out.println(a!=b);//返回true } }
> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等
逻辑运算符
无论长路与还是短路与
两边的运算单元都是布尔值
都为真时，才为真
任意为假，就为假
区别
长路与 两侧，都会被运算
短路与 只要第一个是false，第二个就不进行运算了
public class HelloWorld { public static void main(String[] args) { //长路与 无论第一个表达式的值是true或者false,第二个的值，都会被运算 int i = 2; System.out.println( i== 1 & i++ ==2 ); //无论如何i++都会被执行，所以i的值变成了3 System.out.println(i); //短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了 int j = 2; System.out.println( j== 1 && j++ ==2 ); //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2 System.out.println(j); } }
public class HelloWorld { public static void main(String[] args) { //长路或 无论第一个表达式的值是true或者false,第二个的值，都会被运算 int i = 2; System.out.println( i== 1 | i++ ==2 ); //无论如何i++都会被执行，所以i的值变成了3 System.out.println(i); //短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了 int j = 2; System.out.println( j== 2 || j++ ==2 ); //因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2 System.out.println(j); } }
取反!
真变为假
假变为真
public class HelloWorld { public static void main(String[] args) { boolean b = true; System.out.println(b); //输出true System.out.println(!b);//输出false } }
异或^
不同，返回真
相同，返回假
public class HelloWorld { public static void main(String[] args) { boolean a = true; boolean b = false; System.out.println(a^b); //不同返回真 System.out.println(a^!b); //相同返回假 } }
类型转换
转换规则如图所示
精度高的数据类型就像容量大的杯子，可以放更大的数据
精度低的数据类型就像容量小的杯子，只能放更小的数据
小杯子往大杯子里倒东西，大杯子怎么都放得下
大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出
需要注意的一点是
虽然short和char都是16位的，长度是一样的
但是彼此之间，依然需要进行强制转换
public class HelloWorld { public static void main(String[] args) { char c = 'A'; short s = 80; //虽然short和char都是16位的，长度是一样的 //但是彼此之间，依然需要进行强制转换 c = (char) s; //直接进行转换，会出现编译错误 s = c; } }
l 是long类型的，其类型长度是64位
i 是int类型的，其类型长度是32位
所以l的精度，比i的精度要高
l = i;
把i的值赋给l， 首先l和i彼此的类型是不一样的，那么能否转换就取决于彼此的精度
这个例子，是低精度向高精度转换 是可以正常转换的
换句话说，int比较小，要放进比较大的long,随便怎么样，都放的进去
public class HelloWorld { public static void main(String[] args) { long l = 50; int i = 50; //int比较小，要放进比较大的long,随便怎么样，都放的进去 l = i; } }
b的类型是byte,其长度是8，最大只能放127
i1 的类型是int, 其长度是32,最大，反正就是很大了，超过127
所以， 把int类型的数据转成为byte类型的数据，是有风险的
有的时候是可以转换的，比如 b = i1 (i1=10);
有的时候不可以转换 比如 b= i2 (i2=300) 因为放不下了
编译器就会提示错误
这个时候就只能采用强制转换，强制转换的意思就是，转是可以转的，但是不对转换之后的值负责。 风险自担，后果自负
public class HelloWorld { public static void main(String[] args) { byte b = 5; int i1 = 10; int i2 = 300; b = (byte) i1; //因为i1的值是在byte范围之内，所以即便进行强制转换 //最后得到的值，也是10 System.out.println(b); //因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取 //i2的值是300，其对应的二进制数是 100101100 //按照byte的长度8位进行截取后，其值为 00101100 即44 b =(byte) i2; System.out.println(b); //查看一个整数对应的二进制的方法： System.out.println(Integer.toBinaryString(i2)); } }
