java基础01

java关键字
class public static void (规范：关键字要小写)
标识符
在程序中自定义的一些名称由26个英文字母大小写，数字0-9，符号$和_组成。
数字不能开头，不能使用关键字，java严格区分大小写
规范： 类名接口名，所有单词首字母大写
方法变量名，第一个单词首字母西小写，其余单词首字母大写
常量名，所有单词大写，但词之间用下划线连接
包名，所有单词小写
注释
//  单行注释
/....../ 多行注释
/*....../ 文档注释  文档注释可被javadoc程序提取
常量
×××常量，所有整数
小数常量，所有小数
布尔型常量，true，false
字符型常量，将一个数字，字母或者符号用单引号标识
字符串常量，将一个或多个字符用双引号标识
null常量，null
变量
用来（不断的）存放同一类型的常量，并可重复使用
变量的作用范围，一对大括号中有效，初始化值，不能重复定义
数据类型
基本数据类型
数值型 整数默认 int    小数默认 double
整数类型
byte    一个字节    -2^7—(2^7-1)     默认为0
short   两个字节    -2^15—(2^15-1)   默认为0
int 四个字节    -2^31—(2^31-1)   默认为0  整数运算可能会超过整数范围而产生溢出，正数过大而产生的溢出结果为负值，复数过小而产生的溢出结果为正值
long    八个字节    -2^63—(2^63-1)  默认为0L   如果要使用long类型，则需要以L或l结尾
浮点类型
float   单精度 四个字节    默认为0.0f
double 双精度 八个字节 默认为零0.0d

字符型char 两个字节 0-65535（一个汉字两个字节） 默认为'\u0000'  null布尔型 doolean 内存不确定   默认为false引用数据类型类 class，接口 interface，数组 [ ]

自动类型转换（向上转换），强制类型转换（向下转换）
向上转换
byte->short->char->int->long->float->double
所有byte，short，char值将被提升为int
如果有一个操作数为long，结果就是long
如果有一个操作数是float，结果就是float
如果有一个操作数是double，结果就是double
向下转换
高类型向低类型转换
可能会产生溢出
long a=5555555555L;
int b=(int)a;//产生溢出 结果为0
也可能会造成精度的损失
double c=5.5555555555;
float d=(float)c;//产生精度损失 结果为5.5555555
运算符
算术运算符   + - / % ++ --
i++；    先使用i，后进行自增
++i；    先自增，后使用i
赋值运算符   = += -= = /+ %=
比较运算符   > < >= <= == !=
逻辑运算符   && || ！
三元运算符   ？：
判断结构
if else
选择结构
switch case
switch 条件   整数表达式（byte，int，short，char），枚举类型和String类型
循环结构
while for（开始；结束；过程） foreach（类型：变量）
函数
形参： 用于存储调用函数时传递给函数的实参，
实参：传递给形参的具体数值
函数和宗只能调用函数，不能定义函数
定义函数时，函数的结果应返回给调用者
函数重载    参数个数和参数类型不同
数组
存放数据的容器     下标从零开始
格式：
动态
类型[]  数组名=new 类型[长度]；
eg:int[] array=new int[10];
for(int i=0;i<array.length;i++)
array[i]=(int)Math.random100;
静态
类型[]  数组名=new 类型[]{值，...}；
类型[]  数组名={值，...}；
java程序具体执行过程
java源代码文件（.java）会被java编译器编译为字节码文件（*.class）
然后由JVM中的类加载器加载各个类的字节码文件，加载完毕之后，交由JVM
执行引擎执行。在整个程序执行过程中，JVM会用一度段空间来存储程序执行
期间需要用到的数据和相关信息，这段空间是运行时数据区（Runtime Data Area），
这就是JVM内存
java代码块的执行顺序
在java类被new的过程中执行顺序，
1.实现自身的静态属性和静态代码块（根据代码出现的顺序决定谁先执行）
2.实现自身的非静态属性和非静态代码块
3.执行自身的的构造函数
实现继承的类被new的过程中，初始化顺序，
1.实现父类的公共静态属性和静态代码块级代码
2.实现自身的静态属性和静态块级别代码
3.实现父类的非静态属性和非静态代码块
4.执行父类构造函数
5.实现自身的非静态属性和非静态代码块
6.执行自身的构造函数

内存划分（JVM内存划分）
寄存器（程序计数器） 功能如同CPU中的PC寄存器，指示要执行的字节码指令
本地方法栈  执行引擎调用本地方法时的运行时内存区
方法区 用于存放类，接口的元数据信息，加载进来的字节码数据都存储在方法区
栈内存（虚拟机栈） 执行引擎运行字节码时的运行时内存区，采用栈帧的形式保存每个方法的调用运行数据，变量所属域一旦结束，变量自动释放
堆内存（堆） 运行时数据区，各种对象一般都存储在堆上；存储数组和对象在堆里，有默认初始值，有地址值，由垃圾回收机制
操作数组
查找数组最大最小值
int [] arr =new int[]{-5,-4,-3,-2,-1,5,4,3,2,1};
findMax(arr);
findMin(arr);
findMax(int[] arr){
int max=arr[0];
for(int i=1;i<arr.length;i++)
if(arr[i]>max)
max=arr[i];
}
findMin(int[] arr){
int minIndex=0;
for(int i=1;i<arr.length;i++)
if(arr[i]<arr[minIndex])
minIndex=i;
}
排序（从小到大）
选择排序：（i=0 将arr[0]和数组中下表大于0的值进行比较；i=1 将arr[1]和数组中下标大于1的值进行比较...）
for(int i=0;i<arr.length;i++)
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}          
}
冒泡排序：（外层循环控制趟数，内层循环控制比较次数，将较大的值向数组的尾部输送；如此循环，进行排序）
for(int i=0;i<arr.length-1;i++)
for(int j=0;j<arr.length-i-1;i++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j]=temp;
}                  
}
折半查找：（二分查找，根据所给的key值查找值所在数组下标）
int max,min,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;
while(arr[mid]!=key){
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if(max<min)
return -1;
mid=(max+min)/2;    
}
return mid;