类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
低-------------------------------------------------------------->高
byte,short,char --> int --> long --> float --> double
小数的优先级大于整数。
运算中，不同类型的数据先转化为同一类型，然后进行运算。
两种转换类型
- 强制类型转换
- 自动类型转换
常见问题
内存溢出
强制转换
int i =128;
byte b = (byte) i; //内存溢出
/*
Byte
public static final byte MIN_VALUE = -128;
public static final byte MAX_VALUE = 127;
*/
//可以看出byte最大值是127 内存溢出
//结果为-128
//强制转换 (类型)变量名 高到低
System.out.println(i);
System.out.println(b);
结果
128
-128
自动转换
//自动转换 低到高
int i1 = 128;
double c = i1;
System.out.println(i1);
System.out.println(c);
结果
128
128.0
不会上述出现强制转换产生内存溢出的问题。
注意点：
-
不能对布尔值进行转换
-
不能把对象类型转换为不相干的类型
-
在把高容量转换到低容量的时候，进行强制转换
-
转换的时候可能存在内存溢出或者精度的问题
System.out.println((int)23.7); //23 System.out.println((int)-45.89f); //-45结果
23 -45
char转换
char o = 'a';
int k = o + 1;
System.out.println(k);
System.out.println((char)k);
结果
98
b
操作较大数
public class Demo6 {
public static void main(String[] args) {
//操作比较大的数的时候，注意溢出问题
//JDK7d新特显，数字之前可以用下划线分割
int money = 10_0000_0000;
System.out.println(money);
int years = 20;
int total = money*years;
long total2 = money*years; //默认是int 算后转换为long 转换前已经存在问题
long total123 = money*((long)years); //先将一个数转换为long
System.out.println(total123);
System.out.println(total2);
System.out.println(total);
}
}
结果
1000000000
20000000000
-1474836480
-1474836480
在对较大数进行转换时，先将其中的int类型转换为long类型在进行运算，否则在转换前就会产生问题。导致结果的偏差。
变量
变量是可以变化的量。
Java是一种强类型语言，每个变量都必须声明其类型。 声明变量
Java变量是程序中最基本的存储单元，要素包括变量名，变量类型和作用域。
type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类型变量
注意事项：
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
变量作用域
类变量
实例变量
局部变量
public class Variable{
static int allClicks = 0; //类变量
String str = "hello world"; //实例变量
public void method(){
int i = 0; //局部变量
}
}
常量
常量：初始化后不能改变值，不会变动的值。
所谓常量以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名=值;
final double PI = 3.14;
常量名一般使用大写字符。
变量的命名规范
所有变量、方法、类名：见名知意
类成员能量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()， runRun()
运算符
算术运算法： +, -, *, /, %, ++, –
赋值运算符：=
关系运算符：>, <, >=, <=, ==, !=, instance of
逻辑运算符：&&, ||, ! 与或非
位运算符：&, |, ^, ~, >>, <<, >>>(了解!!!)
条件运算符：? :
扩展赋值运算符：+=， -=， *=， /=
基本运算符
二元运算符
package Operator;
public class Demo1 {
public static void main(String[] args) {
//二元运算符
//Ctrl + D: 复制当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b); //注意作用范围
}
}
结果
30
-10
200
0.5
在运算过程中，要注意作用的范围调整类型
注意：
package Operator;
public class Demo2 {
public static void main(String[] args) {
long a = 123123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); //long 凡有long类型 结果都为long 根据类型高低级
System.out.println(b+c+d); //int
System.out.println(c+d); //int
}
}
结果
123123123123264
141
18
在运算过程中，凡有long类型，结果为long类型。具体根据类型优先级
关系运算符
package Operator;
public class Demo3 {
public static void main(String[] args) {
//关系运算符返回的结果： 正确，错误 布尔值
//if
int a = 10;
int b = 20;
int c = 21;
//取余，模运算
System.out.println(c%a);//c / a 21 / 10 = 2 ... 1
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
}
}
结果
1
false
true
false
true
自增自减运算符
package Operator;
public class Demo4 {
public static void main(String[] args) {
// ++ -- 自增 自减 一元运算符
int a = 3;
int b = a++; //执行完这行代码，先给b赋值，再自增 执行完后a才是4
//a++ a = a + 1
System.out.println(a);
//a++ a = a + 1
int c = ++a; //执行完这行代码，先自增，再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
结果
4
5
3
5
过程：
①a原来的值等于3，b=a=3, ++后b=4，然后++a=5，a=5
②a是c运算后附的值，b++的值是4，但是先赋的值是3（输出为3），然后自增1，变成4，到了c的时候自增后再加1，最后结果是5，最后赋值给a，所以a最后的结果是5
工具类：
//幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具类来运算
double pow = Math.pow(2, 3); //2的3次方
System.out.println(pow);
逻辑运算符，位运算符
逻辑运算符
package Operator;
//逻辑运算符
public class Demo5 {
public static void main(String[] args) {
// 与 and 或or 非 取反
boolean a = true;
boolean b = false;
System.out.println("a && b:" + (a&&b)); //逻辑与运算：两个变量都为真 结果为true
System.out.println("a || b:"+ (a||b)); //逻辑与运算：两个变量有一个为真 结果为true
System.out.println("!(a &&b):"+ !(a&&b)); //如果是真，则变为假，如果是假则为真
//短路运算
int c = 5;
boolean d = (c < 4)&&(c++<4); //前面错了 不执行后面 所以不进行c++ 所以c到最后是5
System.out.println(d);
System.out.println(c);
}
}
结果
a && b:false
a || b:true
!(a &&b):true
false
5
位运算符
package Operator;
public class Demo6 {
public static void main(String[] args) {
/*
A = 0011 1100
B = 0000 1101
-------------------------------------------------------------
A&B = 0000 1100 都为1才1 否则0
A|B = 0011 1101 都为0就是0 否则为1 都为1就是1
A^B = 0011 0001 相同为0 不同为1
~B = 1111 0010 相反
面试题：
2*8 = 16 2*2*2*2
<< *2
>> /2
效率极高!!!
0000 0000 0
0000 0001 1
0000 0010 2
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3); //将0000 0010的1 向左移动3位得 0001 0000
}
}
结果
16
扩展赋值运算符 字符串连接符
package Operator;
public class Demo7 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b;//a = a+b
a-=b;//a = a-b
System.out.println(a);
//字符串连接符 + 在+的两侧只要有一方出现了String类型就会把另外一个操作数转换为String进行连接
System.out.println(""+a+b);
System.out.println(a+b+""); //先运算 再输出 面试题
}
}
结果
10
1020
30
三元运算符
package Operator;
public class Demo8 {
public static void main(String[] args) {
// x ? y : z
//如果x == true ，则结果为y，否则为z
int score = 80;
String type = score < 60 ? "不及格" : "及格";
//if
System.out.println(type);
}
}
结果
及格
3925
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
