java的语言的基础组成
1.关键字: 被java赋予了特殊意义的单词
2.标识符: 类名 函数 26个字母 0-9 _ $ ,不能数字开头 不使用关键字
包名: 全小写
类名 接口名: XxxYxxZzzz 所有单词首字母大写
变量和函数名: xxxYyyZzzz: 第一个单词首字母小写,其余单词首字母大写
常量名: XXX_YYY_ZZZ 所有字母都大写.多单词每个单词用"_" 连接
3.注释 : 单行, 多行, 文档 , 不能嵌套注释
4.常量和变量:
5.运算符
6.语句
7.函数
8.数组
常量
整数的表示方式
十进制:0-9,
八进制 0-7 用0 开头,
十六进制:0-9 A-F 用0x开头,
二进制 1 和0
小数点
布尔类型常量
字符常量
字符串常量
null常量
1. 一个字节用 8个二进制位 表示 可以用 8个开关 表示
2. 8进制是 3个二进制表示一位 (3个二进制的最大数是 7)
3. 16进制是 4个二进制表示一位 (4个二进制的最大数是 15)
4. 8位的二进制的最大值 就是 255 ,可以想到 IP地址中 最大数就是 255,说明ip使用字节表示的 .
Interge.toBinaryString(-6); \\java中将二进制 转换成 十进制的方法
Interge.toBinaryString(6);
[img]http://dl.iteye.com/upload/attachment/0081/8016/4a60b523-3f69-327e-800d-f01269c312d3.jpg[/img]
[img]http://dl.iteye.com/upload/attachment/0081/8018/8c31293e-cdea-3a8b-a90d-9c7480fd055a.jpg[/img]
变量
变量:就是将不确定数据进行存储,也就在内存中开辟一个存储空间.
有明确的数据类型, 变量名, 数据 来完成
数据类型
数据类型: 基本数据类型 引用数据类型
基本数据类型 : 数值型 整数类型byte(8位二进制-128~127) short(16二进制32767) int(32位二进制65535) long(64位二进制) 浮点类型(float(32位进制),double (64二进制)
字符型 char (0-32767) 16位
布尔型 boolean
引用数据类型 : 类 class
接口 interface
数组 []
类型转换
1.自动类型提升,将两个不同类型数值运算 提升为同一种类型 然后再进行运算.
2.强制类型转换,有风险,可能会损失精度. 一般用于保留整数部分
3.float和int进行运算的时候 结果为 float 类型
[img]http://dl.iteye.com/upload/attachment/0081/8157/ed93d4fa-3411-3f06-8312-13abe6dc45eb.jpg[/img]
运算符
1.算术运算符 ： + - * / % ++ --
2.赋值运算符
3.比较运算符
4.逻辑运算符
5.位运算符
6.三元运算符
代码1
//注意整型元算时候 小数点后面的都会舍弃
public static void main(String [] args){
int x=4272;
x=x/1000*1000; //4270/1000=4.27-->int x=4 -->*1000--->int x=4000
System.out.println(x); // 4000
}
取模
左边小于右边 结果 为左边
左边=右边 结果 为 0
右边为 1 结果 为 0
出现 负数 只看 左边
1 % -5 结果 为 1
-1 % 5 结果 为 -1
public static void main(String[] args){
int a=3,b;
b=a++; ---> b=3 a=4
b=++a; ---> b=a=4
// ++ 在前 先加
// ++ 在后 后加
System.out.println("5+5="+5+5); // 5+5=55 (不是五十五) 是 五五
System.out.println("5+5="+(5+5)); // 5+5=10
}
转义字符 \
转移字符:通过 \ 来转变后面字符或者符号的意义
\n: 换行
\b:退格 相当于 backspace
\r:按下回车键.window系统中回车符是由连个字符来表示\r\n 在linux DOS下面是使用 \r 表示
\t: 制表符.相当于tab键
System.out.println("hello \n world");
System.out.println("\"hello\"");
System.out.println("\\hello\\");
赋值运算符
public static void main(String[] args) {
// += -= *= /= %= 前面都是一个运算符 不是两个运算符
int x=3;
x+=4; ==> x=x+4;
short s=4;
s=s+5; // 先将 x自动类型提升 为 int 然后 =5 等于 9 然后 int 9 赋值给 short s 丢失精度 编译失败 ,需要强制类型转换
s+=5; //编译通过 会自动完成强制类型转换 所以就通过了.
int a,b,c;
a=b=c=5; //编译通过
}
比较运算符 只可能是 true 和false
// != > < >= <= == instanceof
public static void main(String[] args) {
System.out.println("hello" instanceof String);
}
逻辑运算符
& and
| or
^ 异或
! not 非
&& and (短路)
|| or (短路)
public static void main(String[] args) {
//短路 案例
int x=4;
System.out.println(x>4 && x++<5);
System.out.println(x); // 4
System.out.println(x>4 & x++<5);
System.out.println(x); //5
/* & && 和 | ||
& : 无论左边 是true 还是 false 右边都运算
&& : 当左边为false时, 右边不运算
| : 两边都运算
|| : 左边为false 的时候 , 右边不运算
*/
/* & 与
true & true =true;
true & false = false
false & true = false
false & false =false
只要有一个false 结果就是false
两边都为 true 的时候 才为 true
*/
/* | 或
true | true =true
true | false =true
false | true =true
false | false =false
只要有个 true 结果为 true
都为 false 的时候就为 false
*/
/* ^ 异或
true ^ true =false
true ^ false =true
false ^ true =true
false ^ false= false
两边结果相同 为 false
两边结果不同 为 true
*/
/* !
!true =false;
!!true=true;
!!!true=false;
*/
}
位运算符号
// <<左移动 >>右移 >>>无符号右移 &与 |或 ^异或 ~反码
3<<2
二进制 11
1100 ==> 12
6>>2 ==> 6/ 2*2=1
110
1 = 1
6>>1=3 ==> 6/ 2=3
3<<2 =12 3<<3=24
3*2*2=12 3*2*2*2 =24
左移动 << 就是 * 2的n位次幂 右边 补 0
右移动 >> 就是 / 2 的n位次幂 移动后 高位 补什么由原高位值定
>> 移动后 高位 补什么由原高位值定
>>> 不管 是负数还是正数 高位 都用 0 补
// &: 与
6 & 3= 2
110 0 是假 1 是真
& 011
-----
010 ==> 假真假 ==>2
一个数 与 自己 等于自己
6 & 6 = 6
// |: 或
6 | 5 =7
110
| 101
-------
111 ==>真真真 ==> 7
一个数 或 自己 等于 自己
6 | 6 = 6
[img]http://dl.iteye.com/upload/attachment/0081/8281/340a0faa-0dcc-3a3e-b3a2-285476984f08.jpg[/img]
//异或 ^
// ^ 异或
6 ^ 5 == 3
110 0 假 1 真
^ 101
-------
011 ==> 假真真 ==> 3
异或: 一个数 异或一个数两次 结果还是 那个数.
一个数 异或 自己 = 0
6^6=0
// ~ 取反
// ~ 反码 规律 N = -N-1
一个数取反 = 这个数的相反数 -1
~6 = -7
0000... 0110
~ 1111... 1001 -->取反 -7
0000.....0001 -->减1
1111.....1000
0000.....0111 --> 取反 ==>7
-6 == 6的二进制取反 + 1 ==> 6的取反 = -6 -1 =-7
A = B + C ==> B = A-C
~ 9 来试试 是不是 = -9 -1 =-10
0000 .... 1001
取反 1111 .....0110 A:一个负数不好算 就算他的正数取反数B 所以减一
- 0000 .... 0001
-------------------
1111 .... 0101 B的取反 去掉反 ==> B
0000 .....1010 B=10 ===> A=-10 =10取反+1
//求负数的 二进制
-6= 6的取反+1;
6取反= -6-1;
问题1. 2 乘以 8 的最有效运算 就是 2<<3 =2*2(3)= 2*8=16
问题2: 两个数的 互换
public static void main(String [] args){
int n=3,m=8;
方法一: 使用中间变量 temp
方法二: 两个数比较大的时候 容易丢失精度
n=n+m;
m=n-m;
n=n-m;
方法三: 技巧性方式没有丢失精度
n=n^m;
m=n^m; // (n^m)^m = n
n=n^m; // (n^m)(n^m)^m = m
}
位移运算的巧用 求一个数的16进制位数
注意下使用 >>> 才对 不是 >>
[img]http://dl.iteye.com/upload/attachment/0081/8437/32ce4305-73e4-3b0c-8875-42334e4ce555.jpg[/img]
流程控制语句
1.判断结构
2.选择结构
3.循环结构
if 和三元运算符 的比较
public static void main(String [] args0){
int a=3;
if(a>2)
System.out.println("a");
if(a>3)
System.out.println("b");
int x=2,b;
b=(x>3)? 100:200;
b=(x>1)? System.out.println("a"):200; 这样就不行
/*
if esle 的简写格式为: 变量= (条件表达式) ? 表达式1: 表达式2;
三元运算符:
好处: 可以简化if else 代码
qu 弊端: 因为是一个运算符,所以运算完后必须有一个结果.
*/
}
switch的使用
switch 在 5.0 的时候 增加了对枚举类型的判断
在 7.0 的时候增加了对字符串类型的判断
public static void main(String[] args){
int x=3;
switch(x){ //byte short int char
default:
System.out.println("d"); // 4
case 2:
System.out.println("a"); // 1 判断 5 不判断
case 4:
System.out.println("b"); // 2 判断 6 不判断 --> 跳出
break;
case 6:
System.out.println("c"); // 3 判断
break;
//结果 d a b
//当某一次匹配成功,而没有遇到"break" 的时候,接下来,程序 不会判断剩下的case 而是直接运行下面的可以执行语句,直到遇到 break 或者 switch 结尾 "}"
//default 总是最后执行的,提前是没有遇到break;
//如果运行到default后,但是 default里没有break,那么程序还会一直往下运行,知道遇到break; 或者 "}" 结束判断
}
switch(x){
case 3:
case 4:
case 5:
System.out.println("春季");
case 6:
case 7:
case 8:
System.out.println("夏季");
case 9:
case 10
case 11:
System.out.println("秋季");
case 12:
case 1:
case 2:
System.out.println("冬季");
default:
System.out.println("you are so best!");
}
/*
if 和switch 很像
具体什么场景下,应用那个语句呢?
如果判断的具体数值不多,而是符合 byte short int char 这四种类型
虽然 两个语句都可以使用, 建议使用switch 语句 ,因为 效率稍高
其他情况,对区间判断,对结果为 boolean 类型判断 ,使用 if ,if使用范围更广
*/
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
