JavaSE(1):java基础知识及基础语法

一、java基础知识及基础语法

 

1、人机交互方式： 

a) 图形化界面：GUI ，Graphical User Interface

b) 命令行方式：CLI ，Command Line Interface

 

2、dos常用命令： 

   dir ：列出当前目录下内容     md：创建目录，make dir

   rd ：删除目录，remove dir    cd： 进入指定目录，change dir

   cd.. ：退回上一级目录   cd/ ：退回根目录

   del：删除文件（直接删除，没有回收站）      exit：退出命令行

 

3、java跨平台：

含义：是指java 语言编写的程序，一次编译后，可以在多个系统平台上运行。

原理：java程序是通过java虚拟机在系统平台上运行的，只要系统中安装了相应的jvm，该系统就能运行java程序。Java程序编译后成为二进制的字节码（bytecode），这是虚拟机的指令，与平台无关，字节码具有统一格式，不依赖具体的硬件环境，所以只要安装了jre，就能执行这些代码。

 

4、JDK 、JRE的区别

JDK：Java Development Kit，java开发工具包，JDK是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。

JRE：Java Runtime Environment，java运行坏境。包括Java虚拟机(JVM：Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

简单说就是JDK开发完的java程序，交给JRE去执行。

 

5、path、classpath的作用及配置方法

Path环境变量时告诉操作系统到哪里去查找JDK工具，而classPath则是告诉JDK工具在哪里去查找类文（.class）。JDK默认情况下回哎当前工作目录下（变量值用“.”表示）以及JDK的lib目录下寻找所需要的class文件，因此java程序放在这两个文件夹下，不设置classpath变量执行环境也可以找得到，但其他文件夹就不行。

Path配置：1）我的电脑--属性--高级系统设置--环境变量。2）编辑 path 环境变量，在变量值开始处加上 java 工具所在目录（JDK 安装根目录的 bin 目录），后面用 “ ; ”和其他值分隔开即可。3）打开DOS命令行，任意目录下敲入javac。如果出现javac 的参数信息，配置成功。

ClassPath配置：同path配置方法相同，不过变量值应该为class文件的目录地址。

 

6、Hello World程序初探：

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

1) 储存文件时，源文件扩展名必须是java，且源文件名必须和程序中申明的为public class的类的名字完全一致，包括大小写。一个源文件最多只能有一个类可以被定义成public的，若不包含public类，则源文件的保存名字可任意。

2) 程序中可以有若干个类，每个类可以有若干个方法，但是其中必须有一个类中包含一个且只能有一个public static void main(String [] args)方法，main方法是所有java应用程序的入口点。

3) 编译：javac HelloWorld.java，若无错误，会在当前目录生成class字节码文件。

4) 运行：java HelloWorld。

5) 整个流程：编写代码（.java文件） --  编译（javac.exe）生成（类名.class）文件 -- 运行（java.exe，JVM会先加载，运行的是类名） --   得出运行结果。

6) Java是对大小写敏感的，也就是说是区分大小写的，不能混用。

7) main方法的作用：程序的入口，保证程序的独立运行（因为只能有一个static void main），被JVM调用。

 

7、注释：

Java中的注释类型：

单行注释：//注释文字

多行注释：/*  注释文字 */，

文档注释：（java 特有）/**注释文字*/，注释内容可以被JDK工具javadoc解析，生   成一条文件形式的程序说明文档。

注意：被注释的文字，不会被JVM（java虚拟机）解释执行。多行注释和文档注释不允许有注释嵌套。

 

8、标示符与关键字

标示符意义：标明类名、变量名、方法名、数组名、文件名等程序中各元素的字符序列。

标示符命名规则：

1）由26个英文字母大小写，数字：0-9 ，_或 $ 组成，此处的字母    可以是中文、日文 。

2）数字不可以开头。

3）不可以使用关键字和保留字，但能包含关键字和保留字。

4）Java中严格区分大小写，长度无限制。

5）标识符不能包含空格。

命名规范：

 a）包名：多单词组成时所有字母都小写：xxxyyyzzz，可以用.连接

b）类名接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz，别用java api 中的类名作为自己的类名。

c）变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

d）常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

关键字：被Java语言赋予了特殊含义，用做专门用途的字符串（单词），关键字中所有 字母都为小写。主要有以下5类。

类类型：（Class Type） package，class，abstract，interface，implements，native，  this，super，extends，new，import，instanceof，public，private，protected

数据类型：（Data Type） char，double，enum，float，int，long，short，boolean， void，byte，true，false，null

控制类型（Control Type） break，case，continue，default，do，else，for，goto， if，return，switch，while，throw，throws，try，catch，synchronized， final，finally，transient，strictfp。

存储类型：（Storage Type） register，static

其他类型：（Other Type） const,volatile

注意：1、关键字都是小写。2、无sizeof运算符，因为数据类型长度和表示是固定的。   3、goto和const虽然从未使用，但是也作为java关键字保留下来。

 

 

9、常量和变量

常量：常量表示不能改变的数值。定义：final dataType  CONST_NAME = VALUE;

变量：内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），   每个变量必须先声明，后使用；该区域的数据可以在同一类型范围内不断变化。

定义变量的格式：  数据类型  变量名 = 初始化值。变量的作用域：一对{ }之间有效。

成员变量和局部变量：局部变量不是直接定义在类体中的，比如说定义在方法中，局部 变量使用前必须初始化，作用域从定义处到代码块结束；成员变量，定义在类 中，而不是方法中，又称为字段Field或者全局变量，作用于整个类中。成员变量会在类创建时默认初始化，局部变量不会。

变量类型：基本数据类型——布尔型，字符型，数值型（整数、浮点），存放在栈中

  引用数据类型——接口，数组，类（字符串是类），存放在堆中，栈放地址

 

整数类型：整型常量默认为 int 型，声明 long 型常量须后加 ‘l’ 或 ‘L’。

    浮点类型：浮点型常量默认为 double 型，声明 float 型常量，须后加 ‘f’ 或 ‘F’。 十进制数形式：如：5.12 ；512.0f ；.512   (必须有小数点）

科学计数法形式:如：5.12e2  ； 512E2  ； 100E-2

字符类型：char 型数据用来表示通常意义上"字符"。字符型有三种表现形式，

  char c1 = 'a' ； char c3 = '\n'  ； char c2 = ‘\uXXXX’；

   XXXX代表一个十六进制整数，char 类型是可以进行运算的。

布尔型：  boolean类型数据只允许取值true和false。

 

类型装换：

自动类型转换（隐式）：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为： 1）有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。2）byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。3）当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。 

强制类型转换（显式）：自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出,格外要注意。通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如： String a = “43”; int i = Integer.parseInt(a);boolean类型不可以转换为其它的数据类型。

 

10、进制

对于整数，有四种表示方式：

二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。

十进制：0-9 ，满 10 进 1.

八进制：0-7 ，满 8 进1. 以数字 0 开头表示。

十六进制：0-9 及 A-F，满 16 进1. 以 0x 或 0X开头表示。此处的A-F不区分大小写。

所有数字在计算机底层都以二进制形式存在。计算机以补码的形式保存所有的整数。正数的补码与其原码相同；负数的补码是在其反码的末位加1。原码：直接将一个数值换成二进制数。反码：是对原码按位取反，只是最高位（符号位）保持不变。

进制转换功能函数：

/**
 * 数字进制转换的原理（int）： 数据以二进制在电脑中存储，有一下推论： （0B）1011 = 1*2^3 + 0*2^2 + 1*2^1 + 1*2^0
 * = 8+2+1 = 11 = 0xB; 所以十进制的数字先转换成二进制（计算机自动完成），每4位就是它对应的一个16进制的位值。
 * 则任务就变成了，如何获取4为数据，从第4位到高四位，依次采取，屏蔽高位，保留低位 0000 1111 0110 1010 & 0000 0000 0000
 * 1111，则高位全部被屏蔽成0，低4位保留1010； 故 （int）a & 15 = 高四位被屏蔽，低四位保留的数字
 * 
 * 8进制同理，不过八进制是3位数据依次处理
 * 
 */
public class ConveresionNumber {
	// 10->16
	public static void conversionToHex(int num) {
		conversion(num, 15, 4);
	}

	// 10->2
	public static void conversionToBin(int num) {
		conversion(num, 1, 1);
	}

	// 10->8
	public static void conversionToB(int num) {
		conversion(num, 7, 3);
	}

	// 采用查表法,参数依次为：需要转换的数字，权，移动的位数
	private static void conversion(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]; // int型数据的32位，每一位以字符形式打印出来
		int pos = arr.length - 1;

		while (num != 0) {
			int temp = num & base; // 获取到num的offset位数据,存放在temp中（低位中）
			arr[pos--] = chs[temp];// 查表获取temp对应的数字字符
			// >>> 被移位二进制最高位无论是0或者是1，空缺位都用0补。
			num = num >>> offset;
		}

		// 一次输出chs，即为num的各位的数据
		for (int i = pos + 1; i < arr.length; i++) {
			System.out.print(arr[i]);
		}
		System.out.println();
	}

	// 测试
	public static void main(String[] args) {
		conversionToHex(15);  //F
		conversionToBin(3);	  //11
		conversionToB(8);	  //10
	}

}

 

11、运算符与表达式

算术.算符（+ 、— 、* 、/ 、%）

赋值运算符（= 、+=、-=、*=、/=,、%=）

关系运算符（>、>=、<、<=、!=）

条件运算符（&&、||、！&、|、^）

位运算符（&、|、^、~、>>、<<、<<<、>>>）

 

1）如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数就另当别论。

2）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

3）“+”除字符串相加功能外，还能把非字符串转换成 字符串.例如：System.out.println("5+5="+5+5)  ：结果5+5=55

4）instanceof是运算符，检查是否是类的对象

5）逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 && x<6 

6）“&”和“&&”（短路与）的区别：单&时，左边无论真假，右边都进行运算；双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。或、短路或同理

7）位运算符：a）<< 被移除的高位丢弃，空缺位补0；b）>> 被移位的二进制最高位是0，右移后，空缺位补0，最高位是1，空缺位补1；c）>>> 被移位二进制最高位无论是0或者是1，空缺位都用0补。

8）三元运算符：(条件表达式)?表达式1：表达式2；如果条件为true，运算后的结果是表达式1；如果条件为false，运算后的结果是表达式2

public class Demo2 {
	public static void main(String[] args) {
		String s = "lz";
		s = (s == "lz" ? "正确" : "错误");
		System.out.println(s);
	}
}

结果：正确

 

 

12、程序流程控制

1）选择结构：if-else 语句；switch 语句。switch(表达式)中表达式的返回值必须是下述几种类型之一：int, byte, char, short, 枚举, 字符串（java7）；case子句中的值必须是常量，且所有case子句中的值应是不同的；default子句是任选的；break语句用来在执行完一个case分支后使程序跳出switch语句块；

2）循环结构：for 循环；while 循环；do/while 循环（至少能执行一次）

3）流程控制语句：break，终止（跳出）该循环，continue，跳过本次循环；break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块 ：

label1: 	{   ……        
label2:	         {   ……
label3:	 			{   ……
          	 			break label2;
          	 			……
					}
          		}
 			} 

break只能用于switch语句和循环语句中。continue 只能用于循环语句中。标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。break和continue之后不能有其他的语句，因为程序永远不会执行break 和 continue之后的语句。

 

Java7新增switch中的判断句可以使用字符串，实例如下：

//switch 可以用字符串作为判断表达式
public class test {
	public static void main(String[] args) {
		String s = "hehe";
		switch(s){
		case "a":
			System.out.println(1);
			break;
		case "hehe":
			System.out.println(2);
			break;
		}
	}
}

输出：2

 

13、数组

数组是多个相同类型数据的组合，实现对这些数据的统一管理；数组属引用类型，数组型数据是对象(Object)，数组中的每个元素相当于该对象的成员变量；数组中的元素可以是任何数据类型，包括基本类型和引用类型。

1）一维数组的声明方式： type  var[] 或 type[]  var；Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5];    //非法；数组值存放在堆内存中，栈中存放堆内存首地址。Java中使用关键字 new  创建数组对象；定义并用运算符 new 为之分配空间后，才可以引用数组中的每个元素；数组元素下标从0开始；数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

2）数组的静态初始化与动态初始化：静态初始化：在定义数组的同时就为数组元素分配空间并赋值，如int a[] = { 3, 9, 8};动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行，如a  = new int[3];a[0] = 3;a[1] = 9;a[2] = 8;

3）多维数组：Java中多维数组被做为数组的数组处理；Java中多维数组的声明和初始化应按从高维到低维的顺序进行，如int t [][] = new int [4][];//t有4行，第一个维数不空即可。Java中多维数组不必须是规则矩阵形式，即t[0].length可以不等于t[1].length。

4）内存分析：栈内存，存储局部变量，数据使用完，自动释放空间。堆内存，数组和对象，通过new创建的实例都存放在堆内存中，但是变量名会对应一个栈内存，栈中存放此堆内存的地址

数组应用：二分法查找、四种排序方法：冒泡、快速、插入、选择

//二分法查找（假设数据以升序排列），以int为例
public class BinarySearch {
	
	public static int binarySearch(int [] array,int key){
		if(array.length == 0){
			return -1;
		}
		int first = 0;				//开始位置
		int last = array.length-1;	//结束位置
		int mid;					//中间位置
		while(first<=last){			//查找时必须开始<结束
			mid = (first+last)/2;	//中间位置 = （开始+结束）/2
			if(array[mid]==key){	// 找到，返回数组下标索引
				return mid;
			}else if(array[mid]>key){ //中间值大于key，重设结束位置为当前中间值
				last = mid;
			}else{					  //中间值小于key，重设开始位置为当前中间值
				first = mid;
			}
		}
		return -1; // 没在while中找到
	}
}

/**
 * 冒泡排序：
 * 最经典的排序方法，利用两个for循环语句，遍历比对相邻元素大小
 *
 */
public class BubbleSort {
	
	public static void bubbleSort(int [] array){
		// i：总共需要排序的趟数,也就是已经排好的元素个数
		for(int i=0;i<array.length;i++){
			// j:从0开始，array[j]当前比较的元素，也就是冒泡移动的元素
			for(int j=0;j<array.length-i-1;j++){
				if(array[j]>array[j+1]){
					int temp = array[j+1];
					array[j+1] = array[j];
					array[j] = temp;
				}
			}
		}
	}
	
	//测试
	public static void main(String[] args) {
		int [] array = {5,2,7,3,10,6,8,9,5,4};
		
		System.out.println("排序前：");
		for(int a:array){
			System.out.print(a+"  ");
		}
		System.out.println();
		
		//对最后一个元素插入排序，则会递归到所以元素
		bubbleSort(array); 
		
		System.out.println("排序后：");
		for(int a:array){
			System.out.print(a+"  ");
		}
	
	}
}

/**
 * 插入排序原理：
 * 假设元素i之前的[0，i-1]元素已经排列好，则将i依次与i-1、i-2……向前比较换位，直到找到合适的位置
 * 优点是能利用之前排序的到序列。
 *
 */
public class InsertionSort {
	//递归实现,因为整个过程是一个递归的，每一次都重复同样的操作
	//传入本次插入排序的元素角标,假设之前元素以排好
	public static void insertionSort(int [] array,int index){ 
		if(index>0){
			insertionSort(array,index-1);
			
			for(int i=0;i<index;i++){
				if(array[i]>array[index]){
					//交换两个数据
					int temp = array[index];
					array[index] = array[i];
					array[i] = temp;
				}
			}
		}else{
			return;
		}
		
	}
	
	//测试
		public static void main(String[] args) {
			int [] array = {5,2,7,3,10,6,8,9,5,4};
			
			System.out.println("排序前：");
			for(int a:array){
				System.out.print(a+"  ");
			}
			System.out.println();
			
			//对最后一个元素插入排序，则会递归到所以元素
			insertionSort(array,array.length-1); 
			
			System.out.println("排序后：");
			for(int a:array){
				System.out.print(a+"  ");
			}
		}

}

/**
 *  快速排序。 以上排序方法效率并不高，于是我通过学习理解实现快速算法如下(以int数组为例)。
 *  算法小结：核心两步
 *  step1. 将一个数组按照一个基数分成左右两部分，左边组小于基数，右边组大于基数
 *  step2. 递归调用step1的方法进行循环多次分组，直到最后实现了最终排序。
 */
public class QuickSort {
	
	//产生随机数组用于测试排序
	public static int[] getArray(int length){
		int [] array = new int[length];
		Random random = new Random();
		for(int i=0;i<length;i++){
			array[i] = random.nextInt(100);
		}
		return array;
	}
	
	//1.重组一个数组，指定左端与右端，以及重组成左右的重组依据（即指订排列基数），返回中间值的位置
	//采用数组末尾元素为排列依据。效果：原数组（1,5,4,3,8,9,6） --> 1,5,4,3， 6  ，8,9
	public static int baseStep(int[] array,int left,int right,int point){
		//获取最左端和最右端开始位置，以及排列的基数，注意右端从array.length-2开始，数组尾数作为基数。
		int leftPtr = left-1; 
		int rightPtr = right;
		int pointNum = point;
		//循环执行，直到左右分成两组，基数居中，左小右大
		while(true){
			//leftPtr定位到左端大于基数的数，rightPtr定位到右端大于基数的数
			while(leftPtr<rightPtr && array[++leftPtr]<pointNum);
			while(rightPtr>leftPtr && array[--rightPtr]>pointNum);
			//交换左右两端Ptr定位到的数字
			int temp = array[leftPtr];
			array[leftPtr] = array[rightPtr];
			array[rightPtr] = temp;
			//分组完成，跳出循环
			if(leftPtr>=rightPtr){
				break; 
			}
		}
		//此时将基础插入到左右两组的中间，即此时的leftPtr与基数互换
		int temp = array[leftPtr];
		array[leftPtr] = array[right];
		array[right] = temp;
		//返回此时位于左右两组数中间的基数的位置指针leftPtr
		return leftPtr;
	}

	//2. 递归调用baseStep完成所有排列
	public static void sort(int [] array ,int left,int right){
		//设置递归退出口
		if( left >= right ){
			return;
		}else{
			//每次分组的基数为sort方法的参数array的最后一个元素，角标为right
			int point = array[right];
			//获取每次分组后中间基数的位置
			int mid = baseStep(array, left, right, point);
			//分别开始重新对左边组，和右边组再进行大小分组成两部分(基数居中)
			sort(array, left, mid-1);
			sort(array,mid+1,right);
		}
	}
	
	public static void main(String[] args) {
		int[] array = new int[20];
		array = QuickSort.getArray(20);
		//打印原数组
		for(int a:array){
			System.out.print(a + " ");
		}
		
		//进行快速排序
		sort(array, 0, array.length-1);
		
		//输出排序过后的数组
		System.out.println();
		for(int a:array){
			System.out.print(a + " ");
		}
	}
}

 

/**
 * 选择排序原理：
 * 遍历数组，设当前需要排列的元素序号是i，则在[i+1,length-1](即之后的子数组)中找到最小/大值，
 * 与元素i互换，这样遍历所有元素则实现排序。
 *
 */
public class SelectionSort {
	public static void selectionSort(int [] array){
		for(int i=0;i<array.length-1;i++){ //遍历每一个数组元素,最后一个元素不用遍历
			//从当前遍历的元素后面找到最小值
			int min = array[i+1];		
			//记录后面元素最小值的下标,这两句可以简化成一句，只记录下标即可
			int min_num = i+1;			 
			for(int j=i+1;j<array.length;j++){
				if(array[j]<min){
					min = array[j];
					min_num = j;
				}
			}
			if(min<array[i]){
				int temp = array[i];
				array[i] = min;
				array[min_num] = temp;
			}
		}
	}
	
	//测试
	public static void main(String[] args) {
		int [] array = {5,2,7,3,10,6,8,9,5,4};
		
		System.out.println("排序前：");
		for(int a:array){
			System.out.print(a+"  ");
		}
		System.out.println();
		
		selectionSort(array);
		System.out.println("排序后：");
		for(int a:array){
			System.out.print(a+"  ");
		}
	}
}

6）arrays工具类的使用：arrays工具的使用可以简化对数组的操作。提高效率，具体查看api文档

7）增强型for循环，for-each的使用： for(类型 变量名：数组名){ 代码块 }