0x00
一个源文件中有多少个类，在用javac编译后，在同一目录下将产生多少个对应的字节码文件（.class ）。类里面不一定要有public static void main(String[] args){}.但是只有存在main方法的类才能够被独立运行，而且一个类里最多只能有一个main方法。
0x01
配置环境变量的用意就是方便在任意路径下执行特定的可执行文件。path中的值，系统会从前往后来遍历它们中的可执行文件。在classpath中的值：classpath=.;c:;d:中，点表示当前路径，而且在最后一个路径后面没有分号。那么JVM在找类时，按照当前目录-->C盘-->D盘的顺序遍历。如果classpath=c:;d:;，即在最后加了分号则在遍历完了D盘后如果还没有找到要执行的类文件，则检索当前路径。
0x02
关键字均小写，类名每个单词首字母大写.
0x03 文档注释
/**
。。。
*/
一般放在开头
0x04
多行注释别嵌套多行注释
0x05 标识符
标识符使用26个字母（严格区分大小写），下划线_和美元符号$，不可以以数字开头。main虽然不是关键字，但是却被虚拟机视为程序入口。
0x06 Java中的名称规则
-
包名：多单词组成时所有字母都小写 xxxyyyzzz
-
类名接口名：所有单词首字母大写
-
变量名和函数名：第一个单词首字母小写，第二个单词开始每个单词首字母大写
-
常量名：所有字母都大写，每个单词间用下划线连接。如XXX_YYY_ZZZ
0X07 常量
-
单字符要使用单引号包起来‘’；
-
字符串要使用双引号包起来“”；
-
null常量，只有一个数值就是null；
-
布尔常量：true，false；
-
八进制整数用0（零）开头；
-
十六进制用0x开头
-
十进制转二进制：Interger.toBinaryString(60)
-
二进制负数为二进制绝对值取反+1；二进制负数最高位为1。
0x08 变量
-
整数型：byte(一个字节）,short（两个字节）,int（四个字节）,long（八个字节） 【默认情况下是int】
-
浮点型：float（四个字节）,double（八个字节） 【默认情况下是double】
-
字符型：char（0~65355 两个字节）
-
布尔型：boolean
以下为引用数据类型
-
类：class
-
接口：interface
-
数组：[]
0x09 定义变量的格式
数据类型 变量名 = 初始值；
float f = 2.1f;//因为默认情况下小数为double型，所以初始化float时要在小数后面加上f否则会报错损失精度。
double d = 12.34;
注意：同一域内不能定义相同标识符的变量，即使他们数据类型不同。
0x0A 类型转换
不同类型的变量（常量）不能直接运算。
如
byte b = 3;
b = b+2;
会报错。在第二句，第一个大小小的操作数会被提升类型为大小大的操作数类型，即byte转为int,但运算结果无法精确地赋值给赋值符号左边的b。但是如果用b+=2;则不会报错。因为上面是运算和赋值，而这里是赋值。
0x0B 运算符
如果用b = (byte)(b+2);就可以编译通过。
+号也用来连接两个字符串。字符串数据和任何数据使用+连接，最终都会变成字符串。
如 System.out.println("5+5="+5+5);打印5+5=55；
如 System.out.println("5+5="+(5+5));打印5+5=10；
0x0C
println这个ln就是用来换行的，如果用print则输出后不换行。
0x0D 转义字符
-
换行
-
回车 win中回车符用 表示
-
制表符
-
退格
0x0E 逻辑运算符（用于连接布尔类型的表达式）
-
& AND
-
| OR
-
^ XOR
-
! NOT
-
&& AND(短路) 区别是左操作数为假时不再看右操作数，直接判定为假
-
|| OR (短路)
0x10 位运算符
-
>>n 右移n位
右移后最高位补什么由原数据的最高位决定。如果原数据最高位是1，则用1补空位，如果最高位是0，则用0补空位。 -
<<n 左移n位
-
>>>n 无符号右移n位，无论最高位是什么，右移后都用0补空位。
-
& 与运算
-
| 或运算
-
^ 异或运算 一个数异或同一个数两次，结果还是原来的数。常用于异或加密。
-
~ 反码
0x11 练习
需求：不使用第三个空间的情况下，交换两个变量值
思路：使用异或（技巧性方式）
class Swap
{
public static void main(String[] args)
{
int a=13,b=31;
System.out.println("a="+a+",b="+b);
a = a^b;
b = a^b;
a = a^b;//这种方法发现赋值号右边都一样。
System.out.println("a="+a+",b="+b);
}
}
0x12 三元运算符
m=（条件表达式）？表达式1：表达式2；
简化了if-else结构
0x13 switch语句
switch（）{} 小括号里面的类型可以是byte,short,int,char.
在花括号中，不管default：放在什么位置，都不先执行default，而从上到下从第一个case开始。所有case都不满足才执行default。如果default后面没有马上遇到break或者}且后面还有case，则不管后面的case是否匹配，都将被依次执行，直到碰到break或}.如：
class Demo
{
public static void main(String[] args)
{
int a=13;
switch(a)
{
case 1:System.out.println(1);
default : System.out.println("default");
case 12:System.out.println(13);
}
}
}
output：
default
13
注：如果有多个选项的执行语句相同，可以把这些case写在一块，如
case 1：
case 2：
System.out.println("hello world");
0x14 循环结构
while（判断条件）
{
循环体
}
do
{
循环体
}
while（判断条件）
for(初始化表达式1,初始化表达式2,...；循环条件；循环后的操作表达式1，循环后的操作表达式2，...)
{
循环体
}//循环条件为空语句是，默认结果为true.
/*
for(;;){}是最简单的for循环
*/
0x15 foreach循环
无需获得数组或集合的长度，无需循环条件，无需根据索引（下标）就能遍历每一个元素。语法格式如下：
for(type variableName:array){}
variableName自动迭代访问每一个元素,这个variableName是用户为了用这种类型的循环自己起的临时变量。每个元素在访问到时值被赋给这个变量，因此这种循环体里的操作不能改变数组或集合的值。这个临时变量的作用域就在这个循环体内，出了循环体这个变量就用不了了。如果希望改变数组元素的值，则不能使用这种foreach循环。如果要打印每一个元素，还是可以用一用的。
0x16 练习
需求：九九乘法表
思路：使用for循环嵌套
class Demo
{
public static void main(String[] args)
{
for(int i=1;i<10;i++)
{
for(int j=1;j<=i;j++)
{
System.out.print(j+"*"+i+"="+(i*j)+" ");
}
System.out.println();
}
}
}
0x17 方法的定义
格式：
修饰符 返回值类型 方法名（参数类型 形参1，参数类型，形参2，...）//可以没有形参
{
方法执行语句；
return 返回值；//当然，当定义时返回值类型是void，则return可以不写。
}
如：
public static int getResult(int n)
{
return n*n;
}
//注意：方法中只能调用方法，不能再方法中定义方法。
0x18 方法的重载overload
在同一个类中，允许存在一个以上的同名函数，只要参数列表不同（特指形参个数或形参数据类型不同）就行。重载和返回值类型无关。也就是说返回值类型不同也可能重载。
当定义的功能相同但参与运算的参数不同，那么这时就定义一个函数名称以表示其功能方便阅读。
0x19 数组的定义
格式1： 元素类型[] 数组名 = new 元素类型[数组长度]；
如：
int[] array = new int[100];
格式2： 元素类型[] 数组名 = new 元素类型[]{元素0，元素1，...};
如：
int[] array = new int[]{1,2,3};
int[] array = {1，2，0}；
0x1A 内存结构
Java程序运行时，虚拟机在内存开辟五个区域，分别时栈区、堆区、方法区、本地方法区和寄存器。
栈区：用于存储局部变量，当数据使用完，所占空间会自动释放。也存放实体的引用。如数组名（数组基地址）【引用类型：如int[] array】
堆区：数组和对象（都是实体），通过new建立的实例都放在堆区；每一个实体都有内存地址值；实体中的变量都有默认的初始化值（0）；实体不在被使用时，会在不确定的时间内被垃圾回收器回收（垃圾回收机制）。
0x1B
如果实参是一个实体，则在定义调用方法时，定义的形参应该是引用类型，如一个求数组中元素最大值的方法定义如下：
public static int getMax(int[] array){}
0x1C
对数组的排序等操作，由于传参使用的是引用类型，所以定义方法时，返回类型用void即可。因为引用始终指向堆区中的那个数组首地址。
0x1D 练习
需求：排序
思路：选择排序
源码：
class Demo
{
public static void main(String[] args)
{
int[] arr = {3,5,27,33,2,4,9,22,1,4,0,11};
printArr(arr);//打印数组
selectSort(arr);
printArr(arr);
}
public static void selectSort(int[] array)//选择排序
{
for(int x=0;x<array.length-1;x++)
for(int y=x+1;y<array.length;y++)
{
if(array[x]>array[y])
{
int temp = array[x];
array[x] = array[y];
array[y] = temp;
}
}
}
public static void printArr(int[] array)//打印数组
{
System.out.print("[ ");
for(int i=0;i<array.length;i++)
{
System.out.print(array[i]);
if(i!=array.length-1)
System.out.print(", ");
else
System.out.print(" ");
}
System.out.println("]");
}
}
0x1E 练习
需求：数组排序
思路：冒牌排序
步骤：大的往后放
源码：
class Demo
{
public static void main(String[] args)
{
int[] arr = {3,5,27,33,2,4,9,22,1,4,0,11};
printArr(arr);
//selectSort(arr);
bubbleSort(arr);
printArr(arr);
}
/*冒泡排序*/
public static void bubbleSort(int[] array)
{
for(int x=0;x<array.length-1;x++)
{
for(int y=0;y<array.length-x-1;y++)
if(array[y]>array[y+1])
{
int temp = array[y];
array[y] = array[y+1];
array[y+1] = temp;
}
}
}
/*打印数组方法*/
public static void printArr(int[] array)
{
System.out.print("[ ");
for(int i=0;i<array.length;i++)
{
System.out.print(array[i]);
if(i!=array.length-1)
System.out.print(", ");
else
System.out.print(" ");
}
System.out.println("]");
}
}
0x20
希尔排序是效率最高的排序算法
0x21
用系统提供的排序，实际开发中要使用这个方法。需要import java.util.*;然后函数里面用 Arrays.sort(数组名)；
0x22 如何用一个方法来互换一个数组中的两个元素呢？
public static void swap(int[] arr,int a ,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/*
注意，如果定义成public static void swap(int a ,int b){} 数组是不会被这个方法影响的，因为这个方法执行后，只是在栈区当中的swap下的a和b的值互换了一下，而跟堆区中的数组没有关系。因此在用方法置换数组元素值时，还要把数组引用作为参数进行传递。
*/
0x23 练习
需求：十进制转二进制
思路：使用对象
class Dec2Bin
{
public static void toBinary(int n)
{
StringBuffer sb = new StringBuffer();//创建一个对象
while(n>0)
{
sb.append(n%2); 用append添加到对象中
n/=2;
}
System.out.println(sb.reverse());
}
public static void main (String[] args)
{
toBinary(6);
}
}
0x24
当定义了一个字符数组，默认填充u0000,打印出来是空格。
0x25 练习
需求：十进制转十六进制
class toHex
{
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
while(num!=0)
{
int temp = num & 15;
if(temp>9)
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num >>>4;//相当于除以16
}
System.out.println(sb.reverse());
}
public static void main(String[] args)
{
toHex(60);
}
}
0x26 练习
需求：优化进制转换
思路：调用同一的进制转换函数
class trans
{
public static void trans(int num, int base, int offset)
{
if(num==0)
{ System.out.println(0);
return ;
}
char[] index = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] array = new char[32];
int pos = array.length;
while(num!=0)
{
array[--pos] = index[num & base];
num=num>>>offset;
}
for(;pos<array.length;pos++)
System.out.print(array[pos]);
}
public static void toBin(int num)
{
trans(num,1,1);
}
public static void toHex(int num)
{
trans(num,15,4);
}
public static void toOctonary(int num)
{
trans(num,7,3);
}
public static void main(String[] args)
{
toBin(10);
toHex(10);
toOctonary(10);
}
}
0x27 二维数组
-
定义格式一：
int[][] 数组名 = new int[n][m]; -
定义格式二：
int[][] 数组名 = new int[n]][];
每一个一维数组都是默认初始化值null;可以对这三个一维数组分别进行初始化:数组名[0]= new int[3];数组名[n-1]= new int[102]...
二维数组也可以使用 数组名.length返回长度。
-
定义格式三：
int[]][] 数组名 = {{1,2,3}，{4,5}}；
*定义也可以是这样的：int y[][];int[] y[]；