Java基本语法知识要点

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 转义字符

• \n 换行

• \r 回车 win中回车符用\r\n表示

• \t 制表符

• \b 退格

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)+"\t");
            }
            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[]；