------- android培训、java培训、期待与您交流！ ----------
Java语言基本组成：
1，关键字：被Java语言赋予了特殊含义的单词，关键字中所有字母都小写；2，标示符：在程序中自定义的一些名称，如类名，变量名等；由26个英文字母大小写，数字，_$组成；
定义规则：1),不能以数字开头；2),不可以使用关键字；Java中严格区分大小写。Java中的命名规范：
包名：多单词组成时所有字母都小写；类名接口名：多单词组成时，所有单词的首字母大写；
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个以后每个单词首字母大写；
常亮名：所有字母都大写，多单词时每个单词用下划线链接。
3，注释：注释分为单行注释(//)和多行注释(/*注释文字*/)，被注释的文字不会被jvm解释执行；
4，常量和变量：常量表示不能改变的数值，数字常量，布尔型常量，字符、字符串常量，null常量；
变量：就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间，通过数据类型、变量名、变量值来明确一个变量；5，运算符：算术运算符，赋值运算符，比较运算符，
逻辑运算符：
&(与):只要两边的Boolean表达式结果有一个false，那么结果为false，只有都是true时结果才是true
|(或):只要两边的布尔表达式有一个true结果就为true；
^(异或)：当符号两边布尔表达式分别为true和false时结果才为真；
！(非):！true结果为false，!false结果为true；&&(短路与)：当&&符号前面的布尔表达式是true是结果就是true，只有符号前面的表达式为false是才会运算符号后面的表达式；
||(短路或)：与&&运算方式相同，
位运算符(位运算是针对二进制进行运算的)：对于非二进制的数据运算时先转换成二进制再进行计算
<<左移：左移n位时，二进制左端高位删去n位，在右端低位补上n个0,
>>右移：右移n为时，二进制形式左端高位补n位左端最高位的数，即1补1,0补0，右端删去n位个数,
>>>无符号右移：跟>>相似，只是右移后无论最高位是什么，都用0补,&与运算：按位与，即1&0=0,0&0=0,1&1=1,
|或运算：按位或，即1|0=1,0|0=0,1|1=1,^异或运算:按位异或，一个数i连续两次异或运算结果还是i不变，即1^0=1,0^0=0,1^1=0，,
~反码,按位取反，即~1=0，~0=1，三元运算符：布尔表达式？表达式1：表达式2, 当布尔表达式为真实返回表达式1否则返回表达式2
可以简化if else代码，但是三元运算符必须有一个结果返回转义字符：通过\来转变后面的字母或符号的含义,\n(换行)，\b(退格),\r(回车),\t(制表符)等。
6，语句:程序流程控制
判断结构：if语句：if,if else，if elseif elseif ...;
选择结构：
switch(表达式){case 值1：执行语句;break;...default:执行语句;break;},值1选择的类型有byte,short,int,char，
switch执行顺序，表达式的值会与case后面的值进行匹配，从匹配的位置开始执行执行语句，如果没有找到可以匹配的值就会
从default处开始执行，直至遇到结束标志；switch结束志有两种情况，遇到break，或是到switch结尾；
循环结构：for(表达式1;表达式2;表达式3){执行语句}
表达式1：第一次进入循环是执行；表达式2：是一个逻辑表达式，对是否继续进行循环的判断，true是继续执行，false结束循环；
表达式3：每次执行完表达式2后执行循环体,结束一次循环后再执行表达式3，一般表达式3是控制表达式2什么时候为false退出循环的;表达式1-->表达式2-->循环体-->表达式3-->表达式2-->循环体-->表达式3-->...
三个表达式都可为空,写成这样for(;;)这个时候表达式2的默认值为true，如果执行语句不进行退出循环控制，将死循环；
while(条件表达式){循环体}：条件表达式判断是否执行循环体，true执行false跳出循环，一般在循环体内写控制条件表示真假的语句；
do{}while(条件表达式)：与while循环相似，但是do while会先执行一次循环体然后在根据while子句里面的条件判断是否执行下一次循环，
也就是说do while只要要执行一次循环体，而while可能一次也不执行循环体；
其他流程控制语句：
break(跳出)：应用范围选择结构和循环结构,作用结束循环，即使循环条件为真也不会再执行循环体，
因为执行break后是不会再执行条件语句了；
continue(继续)：应用于循环结构，作用结束本次循环继续下次循环；
这两个语句俩开应用范围，存在是没有意义的，这两个语句在应用范围内后面不可以有语句，因为执行不到；
标号(给循环起的别名)：可以让这两个语句作用于指定的范围；
w:for(int i=1;i<10;i++){System.out.print(1);
for(int j=1;j<=i;j++){System.out.print(2);
break w;//执行这句后会跳出w：后面的for循环所以是执行不到打印3的语句的}
System.out.println(3);
}//12
7，函数：函数是定义在类中具有特定功能的一段独立程序，也称方法；
格式：修饰符 返回值类型 函数名(参数类型 参数1,...){执行语句;return 返回值}
特点：定义函数可以将功能代码进行封装，便于对该功能复用，函数只有被调用才会执行；注意：函数只能调用函数，不可以在函数内部定义函数；函数的返回值会返回给调用者，交给调用者处理；
函数的重载(overload):在同一个类中，允许存在一个以上同名函数，只要它们的参数个数或参数类型不同即可，与返回值类型无关，只看参数列表；重载方便阅读，优化了程序设计；
什么时候用重载：当定义的功能相同，但参与运算的未知内容(参数)不同；
8，数组：同一种类型数据的集合，其实数组就是一个容器；数组中的元素从0开始标号，方便操作这些元素；
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配不同大小的内存空间,这样可以节约内存格式：元素类型[] 数组名 = new 元素类型[数组长度];int[] i = new int[3];元素类型[] 数组名 = new 元素类型[]{元素,元素,...};int[] i = new int[]{1,2,3,4};
数组元素未被初始化前都有默认值：int byte long 0;float double 0.0;String null;boolean false;char '';数组操作：数组名.length获取数组长度，一般使用循环结构遍历数组中元素；
for(int x=0;x<i.length;x++){System.out.println(i[x]);
}注：int[] i={1,2,3,4}和int[] j={1,2,3,4}中，i和j指向同一个内存地址；
而int[] i=new int[]{1,2,3,4}和int[] j=new int[]{1,2,3,4}中的i和j指向的是不同的内存地址。二维数组：格式：int[][] arr = new int[m][n]; int[][] arr = new int[m][];
基本数据类型：
对于整数，Java中的三种表现形式：数值型：byte(8),short(16),int(32),long(64),float(32),double(64);
字符:char(0-6535);
布尔型：boolean(true，false）
类型转换：当不同类型的数据进行运算时，结果会向位数多的类型转换，也可以在结果前面加"(数据类型)"进行强制类型转换，但是这样转换会丢失数据的精度，
例如float和int数据进行运算赋值给int型变量，那么结果会丢失小数点后面的数据；
进制的基本转换：十进制：0-9
八进制：0-7用0开头表示十六进制：0-9、A-F用0x开头表示
十进制 二进制 互转：
十进制转成二进制 除以2取余数，最后取余数的倒序数列；
二进制转成十进制 乘以2的幂数，最后进行相加得到和；
十进制转成二进制 除以2取余数，最后取余数的倒序数列；
二进制转成十进制 乘以2的幂数，最后进行相加得到和；负数的二进制表现形式：对应的整数二进制取反加1；
java分了5片内存：
1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
java程序在运行时，需要在内存中分配空间，为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和管理方式；
栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放
for(int i=0;i<8;i++){i在这里可用}，当循环结束后i就不能在被使用了，因为它所占的资源已经被释放，也就是内存中不存在i这个值了
堆内存：数组和对象(应用类型)，通过new建立的实例对象都存放在堆内存中；
每一个实体都有内存地址值，实体中的变量都有默认初始值；
实体不再被使用时，会在不确定时间内被垃圾回收器回收；
例子：int[] array = new int[9];array变量会被存放在栈中，new出来的对象会被存到堆内存中；
练习1，调换两个数的值：
int n = 4;
int m=6;
System.out.println("N="+n+"M="+m);
//1，通过第三方实现
int tmp = 0;
tmp = n;
n = m;
m = tmp;
//2，如果n m值较大时，容易超出数据类型的范围
n = n+m;
m = n-m;
n = n-m;
System.out.println("N="+n+"M="+m);
//3,异或实现
n = n^m;
m = n^m;//(n^m)^m
n = n^m;//n^(n^m)
System.out.println("N="+n+"M="+m);
int num = 60;
int temp1 = num&15;//通过&15获取60最低4位
char lastPosition;
lastPosition = (char)(temp1-10+'A');
temp1 = num>>>4;//将60右移4位，要获取下一组四位
temp1 = temp1&15;
System.out.println(lastPosition+""+temp1);
练习3，获取数组中最大值，以及最小值
class ArrayTest{
/*
思路：
1，获取最值需要进行比较，每一次比较都会有一个较大值，因为该值不确定，通过一个变量进行临时存储；
2，让数组中的每一个元素都和这个变量中值进行比较，如果大于了变量中的值，就用该变量记录下来；
3，当所有的元素都比较完成，那么该变量中存储的就是数组中最大值了；
步骤：
1，第一变量，初始化为数组中任意一个元素即可，一般为第一个元素；
2，通过循环语句对数组进行遍历；
3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
*/
public static void main(String[] args){
int[] arr = {2,3,5,6,1,9};System.out.println("Max:"+getMax(arr));System.out.println("Min:"+getMin(arr));
}
public static int getMax(int[] arr){
int temp = arr[0];//定义临时变量为数组的任意一个元素for(int i=1;i<arr.length;i++){
if(temp<arr[i])temp = arr[i];
}return temp;
}
public static int getMin(int[] arr){
int index = 0;//可以将临时变量定义为数组中任意一个元素的角标
for(int i=1;i<arr.length;i++){if(arr[index]>arr[i])index = i;
}return arr[index];
}
//冒泡排序：相邻的两个元素进行比较，如果符合条件换位；
//从大到小
public static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
//-x让每一次比较的元素减少，内循环结束一次最值会出现在数组末尾不需要在做比较了，-1避免角标越界for(int j=0;j<arr.length-i-1;j++){
if(arr[j]<arr[j+1]){
int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;
}
}
}
}
//选择排序，内循环结束一次最值出现在数组头
public static void selectSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i;j<arr.length;j++){
if(arr[i]<arr[j]){
int temp = arr[i];arr[i] = arr[j];arr[j] = temp;
}
}
}
}
//折半查找，提高效率，但是必须保证该数组是有序的
public static int halfSearch_2(int[] arr,int value){
int min = 0,max = arr.length-1,mid;while(min<=max){//根据角标判断折半，只要下界限小于等于上界限就折半
mid = (max+min)>>1;if(value>arr[mid])
min = mid+1;
else if(value<arr[mid])
max = mid-1;
else
return mid;
}return -1;
}
public static int halfSearch(int[] arr,int value){
int min,max,mid;min = 0;max = arr.length-1;mid = (min+max)/2;
while(arr[mid]!=value){//根据数组元素判断折半
if(arr[mid]>value)
max = mid-1;
else if(arr[mid]<value)
min = mid+1;
if(min>max)//数组中不存在要找的元素
return -1;
mid = (max+min)/2;
}return mid;
}
//利用查表法将十进制整数转换成十六进制
public static void toHex(int num){
char[] chs = {'0','1','2','3'
,'4','5','6','7','8','9','A','B','C','D','E','F'};
//while(num != 0){//只取有效位
for(int i = 0;i<8;i++){
int temp = num&15;System.out.println(chs[temp]);num = num>>>4;
}
}
}}
483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
