------- android培训、java培训、期待与您交流！ ----------
>>软件：一系列按照特定顺序组织的计算机数据和指令的集合
>>交互方式：图形化界面、命令行方式
——————DOS命令行：——————
dir:列出当前目录下的文件以及文件夹
md:创建目录
rd:删除目录 （dos下删除文件夹，目录下必须是空的，如果不是，可以用/q /s）
cd:进入指定目录
cd..:退回到上一级目录
cd/:退回到根目录
del:删除文件 （比如“del op”命令，可以删除op文件夹下所有文件）
exit:退出DOS命令行
echo:创建文件
——————————————————
>>JAVA:
1.Sun公司1995推出
2.面向INTERNET
3.与平台无关的完全面向对象语言（跨平台性：java虚拟机（JVM Java Virtual Machine）负责JAVA程序在该系统中的运行）
4. J2EE:企业版、J2SE:标准版、J2ME:小型版（5.0版本后，更名为JAVAEE、JAVASE与JAVAME）
>>环境搭建：
JRE（java runtimeenvironment JAVA运行环境）包括JAVA虚拟机和JAVA程序所需的核心类库等。
JDK（javadevelopment kit JAVA开发工具包）包括JRE、编译工具（javac.exe）和打包工具(jar.exe)
安装完毕后，开发工具均在bin目录下。
配置系统变量：我的电脑——高级——环境变量。将bin文件夹所在路径加入path，注意后面跟分号“；”。注意，配置后重新打开DOS命令行后方可执行。
配置变量技巧：
1.path中，系统按先后顺序查找。
2.如果需要经常变更路径值，但是bin不变，可以如此
定义：java_home=d:\jdk1.6
path中：%java_home%\bin;%SystemRoot%\system32…（%%称为动态获取，取jdk的值）
临时配置方式：
Set命令：可以查看、配置环境变量的值。Eg: set path。
DOS命令行的配置环境变量方式只在当前窗口有效。Eg: set path-haha。
如临时在DOS中配置：setpath-D:\jkd1.6\bin（现在path中只有这个值）。
Set path-haha；%path%（动态获取原有path值并加上haha）
>>从hello world开始，JAVA代码都是通过类的形式来体现的。
Class：是java中的关键字（java中赋予特殊含义单词），用于定义类，java的程序代码都需要定义在类中。
>>保存编写完的代码文件后缀为“***.java”，此时称为源文件。需要用“javac.exe”翻译成虚拟机可执行文件。生成的后缀为“.class”的文件称为中间码文件或字节码文件。
运行“java.exe”它会调用jre中的虚拟机。
编译后发现没有main的程序是不能独立运行的。
public static void main（String []args）
打印内容：System.out.println(“hello java”);
>>如果class前加上 public：public classDemo，那么要保证文件名和类名相同，即Demo.java。
>>set classpa-，后面没有值为清空。
>>先后顺序：虚拟机在启动时先找环境变量，再找当前目录。
设定中：“classpath-c:\;”与“classpath-c:\”有区别。前者如果在当前设定中没有找到相关文件，就到当前目录中寻找，不加分号，就只在当前设定中寻找。注意：最好不要加分号，以起到警示作用。
设定中：“set classpath-c:\;d:\”起到查找多路径作用。
设定中：“set classpath-.;c:\;d:\”一开始的点代表当前目录。
>>java的文档注释使用“javadoc.exe”生成网页。
/**
Author:
Version:
Thisclass ……
*/
多行注释中不要有多行注释
第二天
>>标示符由26个字母大小写、数字（0-9）、符号（两个：_$）组成，数字不能开头，不能取关键字。
>>JAVA严格区分大小写
>>main不是关键字，比较特殊。
>>包名，全部小写。
类名接口名，所有单词首字母大写。
变量名和函数名，第一个单词首字母小写，包括第二个单词后首字母大写。
常量名，所有字母大写，单词之间下划线连接。
>>特殊常量-布尔型只有两个值：true和false，空常量-null常量，只有一个值null。
>>对于整数，八进制0开头表示，十六进制0x开头表示。
加上单引号eg：’a’为字符常量，单引号中只能有一个字符。
加上双引号eg：”aa”为字符串。
>>8位一个字节
>>十进制与二进制：
Eg:十进制的6转二进制
对十进制数进行除2运算
6/2=3 能整除得0
3/2=1余0.5不能整除得1
1/2 不能除了得1
所以6的二进制数为110
Integer.toBinaryString(6)：此语句显示6的二进制。
Eg:二进制的110转十进制
即（0*2^0）+（1*2）+（1*2*2）=6
二进制对应的位128-64-32-16-8-4-2-1
Eg：5+4=9
101+100=1001
>>八进制与十六进制：
Eg：0101-1010
四个二进制位就是一个十六进制位
0x5A
Eg:三个二进制位代表一个八进制位
01-011-010，首位补零构成3位
0132
>>负数二进制：
Eg：内存中表示：
6 = 0000-0000 0000-0000 0000-0000 0000-0110
-6 = 1111-1111 1111-1111 1111-1111 1111-1010
负数即正数二进制取反加一，负数最高位为1。
>>变量是内存中的一个存储区域，名字为变量名。当数据不确定的时候，需要对数据进行存储时定义变量。
>>数据类型：
1基本数据类型
1.1数值型
1.1.1整数类型(byte(7)\short(15)\默认int(31)\long())
1.1.2浮点类型(float\默认double)
1.2字符型(char)
1.3布尔型(boolean)
2引用数据类型
1.1类(class)
1.2接口(interface)
1.3数组(array[])
>>注意细节
long = 4l；（“l”标示表示long类型）
float = 4.5f；（小数默认double，要用“f”标示）
char = ‘4’；（注意引号）
>>eg：
byte b = 3;b = b + 2;不能通过编译。
原因为“2”是整数，占4个八位，byte型占1个8位故不能装下。
解决方案：b = （byte）（b + 2），将（b + 2）强制转换成byte型，前提是结果的前24为均为0，否则丢失精度。另外（byte）b + 2不能达到目的。
>>eg：System.out.println(‘a’+1);结果是98。参照ASCII表：a对应97，A对应65,0对应48。
>>取模：x%y
x < y x%y = x ;
x =y x%y = 0 ;
y = 1 x%y = 0
eg:1%(-5) = 1 ; (-1)%5 = -1 出现负数看被模数。
>>b = a++;
System.out.println(b);
System.out.println(a);
a=4,b=3
b = ++a;
System.out.println(b);
System.out.println(a);
a=4,b=4
>>字符串数据和任何数据使用加号都是相连接，最终都是字符串数据。
System.out.println(“ab=”+5+5);结果为ab=55；注意：”ab=”+5先运算，成为字符串ab=5。
>>System.out.print();无换行
System.out.println();有换行
\n：换行
\t：制表符，相当于tab
\r：按下回车键，windows系统中，回车符是由两个字符（\r\n）表示的
\b：退格，相当于backspace
>>注意赋值运算符的区别
short s = 4；
s = s + 4；编译失败，两次运算s +4结果为int。
s += 4；编译通过，一次赋值，内部有转换动作。
>>短路：“&&”与“||”。
int a = 2;
a>3 && a<6
a>3为false，所以a<6不判断；同理，如果“||”符号左边为true，则右边不运算。
>>“<<”：其实就是乘以2的移动的位数的次幂。
“>>”：就是除以2的移动的位数的次幂。
移动后高位补位以原最高位的数字为准。
“>>>”：移动后最高位补零。
>>反码
Eg：~6 = -7
6:0000-0000 0000-00000000-0000 0000-0110
~6:1111-1111 1111-11111111-1111 1111-1001
注意，~6减一取反，得0000-0111，为-7。
>>一个数异或同一个数两次，结果还是那个数：7 ^ 4 ^ 4 = 7。可用于加密。
>>两个值互换的三种方法
int m,n,temp;
temp = n;
n = m;
m = temp;（此方法首选）
n = n + m; （不适合太大数据）
m = n - m;
n = n - m;
n = n ^ m;
m = n ^ m;
n = n ^ m;（技术型）
>>if……else……与三元运算符
eg：int a = 9,b;
b = (a>1)?100:200;
等同于
if(a>1)
b = 100;
else
b = 200;
注意：b =(a>1)?System.out.println(“haha”):200;不可以！
三元运算符：
好处：可以简化ifelse代码。
弊端：因为是一个运算符，所以运算完必须要有一个结果。“System.out.println(“haha”)；”没有结果，只是打印到屏幕上。
>>switch(表达式)
{
case 取值1：
执行语句；
break;
case 取值2：
执行语句；
break;
……
default：
执行语句；
break;
}
Switch特点：
1） switch语句选择的类型和只有四种：byte，short，int，char。
2） case之间与default没有顺序，但是注意，即使default放在第一个也先执行第一个case，没有匹配的case执行default。
3） 结束switch语句的两种情况：遇到break，执行到switch结束。
4） 如果匹配的case或者default没有对应的break，那么程序会继续执行下去直到遇到break或switch结尾。
>> case的多种格式：
case 3：
system.out.println(“cun”);
break;
case 4:
system.out.println(“cun”);
break;
等价于：
case 3：
case 4：
system.out.println(“cun”);
break;
>>switch与if
如果判断的具体数值不多，而是符合byte，short，int，char这四种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率较高。
其它情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
第三天
>>do which的特点是条件无论是否满足，都先执行一次。
>>for（初始化表达式；循环条件表达式；循环后的操作表达式）
{
执行语句；
}
初始化表达式开始才在内存中开辟空间。紧接条件表达式。循环条件表达式后执行循环体，后执行操作表达式。初始化表达式只执行一次。
如果如此定义for(intx=0;x<3;x++){}。循环执行完后（for语句结束后）,x于内存中消失。
变量有自己的作用域。对于for来讲：如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效。
For与while语句可以互换。
>>特殊eg：
int x = 1；
for（System.out.println(“a”);System.out.println(“b”);system.outprintln(“c”)）
{
System.out.println(“d”);
}
//编译失败：“System.out.println(“b”)”没有真假！
for（System.out.println(“a”);x< 3;system.outprintln(“c”)）
{
System.out.println(“d”);
x++；
}
//结果：adcdc
>>无限循环的最简单表现形式
for（；；）{}//不写条件表达式默认为true
while（true）{}
>>eg：九九乘法表
For(intx = 1 ; x <= 9 ; x++)
{
For(int y=1;y<=x;y++)
{
System.out.print(y+ ”*” + “=” + y*x +”\t”);
}
System.out.println();
}
>>break（跳出），continue（继续）
break语句：选择结构和循环结构。
continue语句：循环结构。
注意：
1） 两个语句离开应用范围，存在是没有意义的。
2） 这两个语句单独存在下面都不可以有语句，因为执行不到。
3） Continue语句是结束本次循环继续下次循环。
4） 标号的出现，可以让这两个语句作用与指定的范围。
>>给for取名字,以应用到break上
w:for(int x=0;x<3;x++)
{
q:for(int y=0;y<4;y++)
{
System.out.println(“x=”+x);
break w;
}
}
结果：输出x=0后跳出循环。
>>如果在代码中或是循环外部单独出现：
break；//编译错误。
如果有这样的语句：
for(int y=0;y<4;y++)
{
break ;
System.out.println(“x=”+x);
}//编译错误,“System.out.println(“x=”+x);”无法访问！
“Continue；”语句结果相同。
>>函数就是定义在类中的具有特定功能的一段独立小程序。
函数的格式：
修饰符返回值类型函数名（参数类型形式参数1，参数类型形式参数2）
{
执行语句；
return返回值；（谁调用返回给谁）
}
>>如何定义一个函数？
1） 既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。目的是明确返回值类型。
2） 再明确在定义该功能的过程中是否需要未知的内容参与运算。目的是明确函数参数列表。
>>技巧：在一个判断两数是否相等的函数中：
If(a==b)
returntrue;
else
return false;
功能上等价于
If(a==b)
returntrue; //return语句后，函数结束。
return false;
功能上等价于
return (a==b)?true:false;
功能上等价于
return a==b；//“a==b”本身就返回真假值。
>>返回值类型定义为void的函数不能出现在输出函数中。
>>定义函数功能中
public static void get(int a,int b)
{
System.out.println(a+b);
Return;
}//可以通过编译，但是思想有问题，完成的主要功能是计算a+b，不要输出，输出的工作由调用者来决定。
>>函数重载：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
>>数组概念：同一种类型数据的集合，其实数组就是一个容器。
注意：从零开始编号。
元素类型[]数组名=new元素类型[元素个数或数组长度]；
int[] x = new int[3];（注意，这里的X是数组类型，不是int型）
int[] x = new int[]{3,1,6,5,4};相当于int [] x = {3,1,6,5,4};
>>JAVA运行时，对内存进行不同区域划分
栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：数组和对象，通过new建立的实例都存放在此。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值
实体不再被使用，会在不确定的时间内被垃圾回收器回收
方法区：
本地方法区：
寄存器：
栈自动释放，堆垃圾回收。
>>获取数组元素个数。Length
数组名称.length =；
>>int [] arr = new int[3]
System.out.println(arr);
输出:[I@ajpsofds
注意，输出的是：数组类型的引用类型 @哈希值的地址
>>数组排序：
class ArratTest2
{
publicstaticvoid selectSort(int[]arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
}
publicstaticvoid printArray (int[]arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.println(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
publicstaticvoid main(String[] args)
{
int[] arr={5,1,6,4,2,8,9};
printArray(arr);
selectSort(arr);
printArray (arr);
}
>>冒泡排序
publicstaticvoidbubbleSort(int[] arr)
{
for(intx=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
//-x让每一次比较的元素减少，-1让下面的“[y+1]”角标不越界
{
if(arr[y]>arr[y+1])//改成小于号从大到小
{
int temp =arr[y];
arr[y] = arr[y+1];
arr[y+1]= temp;
}
}
}
}
注意：最初一圈最值出现在最后位
排序中最快的希尔排序。
java提供的排序Arrays.sort(array);开发中使用。
>>排序中的置换功能
publicstaticvoidswap（int[] arr,inta,int b）//注意数组传入
{
int temp = arr[a];
arr[a] = arr [b];
arr[b] = temp;
}
>>数组中的查找
publicstaticvoidgetIndex（int[] arr,int key）
{
for(int x=0,x<arr.length;x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
提高效率，折半查找。但是必须保证数组是有序（从大到小或从小到大）的数组。
publicstatic inthalfSearch(int[] arr,int key)
{
int min,max,mid
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[min]!=key)
{
if(key>arr[arr])
min = mid + 1;
elseif(key<arr[mid])
max = mid - 1;
if(min>max)
return -1;
mid = (max+min)/2;
}
}
//第二折半种方法
publicstatic inthalfSearch_2(int[] arr,int key)
{
int min,max,mid
min = 0;
max = arr.length-1;
while(min<max)
{
mid = (max+min)/2;
if(key>arr[mid])
min=mid+1;
elseif(key<arr[mid])
max=mid-1;
else
return mid;
}
return-1;
}
>>十进制到二进制
public staticvoid toBin(int num)
{
stringBuffer sb = new StringBuffer();//一个存储容器
while(num>0)
{
sb.append(num%2);
num=num/2;
}
Systme.out.println(sb.reverse());反向输出
}
查表法
public staticvoid toBin(int num)
{
char[] chs = {'0','1'};
char[] arr = new char[32];
int pos = arr.length;
while(num!=0)
{
int temp = num&1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for(int x=pos;x<arr.length;x++)
{
Systme.out.print(arr[x]);
}
}
>>十进制到十六进制
publicstatic void toHex(int num)
{
for(int x=0;x<8;x++)
{
int temp = num&15;
if(temp>9)
{
System.out.println((char)(temp-10+’A’));
else
System.out.println(temp);
}
num = num>>>4;
}
}
第二种方法，查表法，将十六进制16个数存入char[] chs = {‘0’,’1’,’2’,’3’,’4’,……’E’,’F’},结果查表输出。
publicstatic void toHex(int num)
{
char[] chs = {'0',1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr = new char[8];
int pos = arr.length - 1;
while(num!=0)
{
int temp = num&15;
arr[--pos] = chs[temp];
num = num >>> 4;
}
Systme.out.println("pos="+pos);
for(int x=pos;x<arr.length;x++)
{
Systme.out.print(arr[x]+',');
}
}
>>转换优化,封装使得可以转换二进制、八进制、十六进制。
class ArrayTest7
{
publicstatic void main(String[] args)
{
toBin(-6);
toHex(-60);
toBa(60);
// System.out.println(Integer.toBinaryString(6));
// System.out.println(Integer.toHexString(6));
}
/*
十进制-->二进制
*/
publicstatic void toBin(int num)
{
trans(num,1,1);
}
/*
十进制-->八进制
*/
publicstatic void toBa(int num)
{
trans(num,7,3);
}
/*
十进制-->十六进制
*/
publicstatic void toHex(int num)
{
trans(num,15,4);
}
publicstatic void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(0);
return;
}
char[]chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[]arr = new char[32];
intpos = arr.length;
while(num!=0)
{
inttemp = num & base;
arr[--pos]= chs[temp];
num= num >>> offset;
}
for(intx=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
return;
}
}
>>二维数组
int[][] arr=new int[2][4];//定义了一个二维数组，二维数组中有2个一维数组，每一个一维数组长为4。
System.out.print(arr);//打印二维数组地址。
System.out.print(arr[0]);//打印其中第一个一维数组的地址。
eg：int[] arr = newint[3][];
System.out.print(arr[0])；//注意：结果为NULL
//初始化
arr[0] = new int[3];
arr[1] = new int[3];
arr[2] = new int[3];//在内存中产生三个小数组，小数组的地址替换NULL。
System.out.println(arr.length)；打印二维数组长度3。
System.out.println(arr[0].length)；打印二维数组中第一个一维数组长度。
>>eg：int[] x,y[];//x是一维数组，y是二维数组，但是实际中不要这样定义。
x[0] = y;//错误
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
