Java基础（移位，函数）

回顾：
Java ：虚拟机 sandbox
jre ：jvm +核心类库
jdk ：jre + 工具 ，javac java

设置变量： java_home
path=搜索顺序。例如（notepad calc mapaint binary)

classpath=java搜索类的顺序。
Java -classpa 目录（d:\java;d:\;.)

关键字
------------
被Java语言赋予特殊含义的单词。（所有字母为小写）
如：class interface byte return.....

byte //字节
short //短整型 2 bytes
int //整型 4 bytes
long //长整型 8 bytes
float //浮点型
double //双精度浮点型
[访问权控制]
private //私有的
protected //受保护的
public //公共的

｛class function modifier｝尝试
abstract //抽象
final //最终的
static //静态的
synchronized //同步
extends //扩展（应用于class中）
implements //实现（实现于class中）
new //创建
this //当前
super //超类，父类
instanceof //是否是xxx实例（对象）
try //尝试
catch //捕获
finally //最终
throw //抛出
throws //定义类声明时，抛出异常。
package //包
import //导入 <--> export
native //本地的
transient //暂时的，瞬时，临时 <--> persistent
assert //断言

标识符（名称)
----------------
英文字母
数字
_ $

严格区分大小写

命名格式：

包名： aaa.bbb.ccc.ddd(文件层级关系)
类名和借口名 ：首字母大写（驼峰命名法）XxxYyyZzz
变量和函数 ：convertStr2Int(第一个单词首字母小写，以后的单词首字母大写)
常量： final String BRAND ="benz" XXX_YYY_ZZZ(全部大写)
注释： 单行 // (sql 注释 --)
多行 /* */
文档注释(javadoc 提取所有文档注释)
/**
*
*/

常量：Java中的常量的分类
1.所有整数
byte short int long 默认是int
2.所有小数
float double 默认 double
3.布尔(boolean)型常量，
4.字符常量 ( '')
char
5.字符串常量 ( "")
6.null 常量：只有一个数值 ： null

整数的四种表现形式：
二进制： 0 1 满2进1
八进制： 0-7 满8进1 用0开头（一般不用，表示方法容易混淆)
十进制： 0-9 满10进1.
十六进制：0-9，a-f 满16进1 用0X开头表示

2^10=1024(byte)=1K
2^20=1024k=1M
2^30=1024M=1G
2^40=1024G=1T

负数采用补码方式存储：正数取反+1；
原理：正负数相加等于0 。把第9位的1 溢出
例如：
0000 0101
1111 1011

例如 -6 一个字节的表现形式：
0000 0110 （6）
^
1111 1001
+ 1
1111 1010(-6)

-1 取反 求+6(验证正数：利用负数 -1 取反)
1111 1010（-6）
-1
1111 1001
^
0000 0110(6)

-1 的表现形式：
0000 0001 （1）
^
1111 1110
+ 1
1111 1111(-1)

-128 表现形式

1000 0000 （128）
^
0111 1111
+1
1000 0000 (-128)
Java中基本数据类型（primitive)
默认的整数int 默认浮点数 double
升格 自动转换 隐士转换
降格 强制转换 显示转换

表达式的数据类型自动提升
所有byte 型，short 型和char型的值将被提升到int型
如果一个操作数是long型，计算结果就是long型
如果一个操作数是float型，计算结果就是float型
如果一个操作数是double型，计算结果就是double型

例子：
class TypeDemo{
public static void main(String [] args){
int i = 128;
byte b3 = (byte)i;//这里不强制转换。编译提示缺失精度。
//结果是-128？？？
System.out.println(b3);
}

}
以上用到2个知识点：
1：b3的类型是byte 是1个字节。 i 的类型是int 是4个字节。
将i 赋值给 b3 需要强制转换。
2：强转后的精度缺失。
int i ： 0000 0000 0000 0000 0000 0000 1000 0000 （整型128）
byte b3: 1000 0000 （-128）

截取了剩下： 1个字节即 1000 0000
1000 0000 数值=？
1000 0000
^
0111 1111
+1
1000 0000 (-128)
算术运算符：注意问题。
1.取模： % 5%-2 = 1；（对负数取模，模数负号忽略不计)
2."/"除号,它的整数除和小数除是有区别的：整数间做除法：保留整数部分舍弃小数部分。
例如：int x = 3510; x = x/1000*1000; x 结果：3000；
3."+"除字符串想加功能外，还能把非字符串转换成字符串。
System.out.println("5+5="+5+5)//打印结果是？
5+5=55
short s = 3;
s = s +3;//编译通不过，需类型转换
s+=3; //可以通过，有内置的类型机制

&& || 存在短路现象 。boolean1 &&(||) boolean2 如果boolean1 满足条件，boolean2 不参与运算

^ :boolean1 ^ boolean2 true ^ false true
! : !boolean 取反操作。
~ ： 按位取反。

注意：Java中不可以 写成 3<x<6 ,应该写成 x>3 & x<6;

"&" 和 "&&" 的区别：
单& 时，左边无论真假，右边都进行运算。
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
"|"和"||"的区别同理，双或时，左边为真，右边不参与运算。
异或(^)与或(|)的不同之处是：当左右都为true时，结果为false。

&运算 权限的分配： 1111 & 0100 1111 & 1000 1111 & 0010 1111 & 0001

逻辑运算不存在短路的理由：
一般用于权限中：用最大权限(是(|)或运算而不是简单相加：避免重复。) & 单个权限。如果为true（真）则有权限。如果为false（假）没有权限。
无论。有没有权限，两边都参与运算。
位运算 对二进制的操作。

判断结构：if else
switch
支持的类型 byte short int char
结束：遇到break; 或者 程序运行到switch结尾。
简写案例：（需求判断 月份属于那个季节）

class SeasonDemo
{
public static void main(String[] args)
{
int x = 7;
switch (x)
{
case 12://System.out.println("冬季");可以省略
case 1://System.out.println("冬季");可以省略
case 2:
System.out.println("冬季");
break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
default:
System.out.println("不存在的月份");

}
}
}
这里使用一个简单的算法进一步简化算法：如下
int x = 12;
if(x <1 | x>12){
System.out.println("不存在的月份");
return;
}
int y = (x+2) /3;//精华部分算法。
System.out.println(y);
switch(y){
case 1:
System.out.println("1季度");
break;
case 2:
System.out.println("2季度");
break;
case 3:
System.out.println("3季度");
break;
case 4:
System.out.println("4季度");
break;
default:
System.out.println("计算不到值");
}
//int y = (x+2) /3;//精华算法?

循环
while(){} VS do{}while();(先执行一次在判断条件)

for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句; (循环体)
}

while 和for 可以互换，区别在于for 为了循环而定义的变量在for循环结束时就在内存中释放，
while 循环使用的变量结束后还可以继续使用。
练习用2中循环打印99

class SeasonDemo
{
public static void main(String[] args)
{
for(int i = 1;i<10;i++){
for(int j =1;j<=i;j++){
System.out.print(j+"x"+i+"="+j*i+"\t");
}
System.out.println();
}
int a=1;
while(a<10){
int b =1;//位置很重要，第一次和int a= 1 写到了一起。结果：每次都是b ==a 没有循环。
//为了循环每次都需要初始化b 的值，才可以从1开始循环，不然永远都是 b ==a ;
while(b<=a){

System.out.print(a+"x"+b+"="+a*b+"\t");
b++;
}

System.out.println();
a++;
}
}
}

函数：（function）
1.一段独立的程序
2.修饰符 返回值 函数名(参数类型1 参数名称1,参数类型2 参数名称2,.....){
函数body;
return ; //只有void 类型 的返回值才可以不写 return
}
3.形参只是在函数内有效（类似 for）
注意：函数中只能调用函数，不可以在函数内部定义函数。（ 不可以嵌套）
定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的重载（overload）
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
返回值类型无要求，只看类型。