黑马程序员---java基础

-------http://www.itheima.comjava培训、android培训期待与您交流！------- 

     话说，无论学习什么东西都要从最基础的学起。就像我们学习说话，总要先从简单的字、词学起，然后才能将简单的字词联系起来组成句，从而说我们最博大精深的母语，嘎嘎。。
     所以，java也不例外。首先，我们要先了解java是什么，能做什么，怎么做。只有了解了他的基本知识才能知道在以后的学习中遵照一定的规则和规范来使用他。对于一些java语言的发展史相信大家已经很熟悉了，在这里就不多说了。
      当然，要简单理解一下java语言与C++的联系。java语言与C++联系紧密，而C++又是有C语言派生而来的，所以java语言继承了这两种语言的大部分特性。在充分吸取了C++的优点，并加入了自己的一些新特性后，功能更为强大且具有完备的开发环境和运行环境，且使用java语言编写的程序在不同的平台间具有更高的可移植性(一次编写，到处运行),使java语言成为目前使用最为广泛的网络编程语言之一。

java语言的三种技术架构(应用领域不同)
    J2EE(Java 2 Platform Enterprise Edition) 企业版：是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如Servlet Jsp等，主要针对于Web应用程序开发。
    J2SE(Java 2 Platform Standard Edition)  标准版  ：是为开发普通桌面商务应用程序提供的解决方案。该技术体系时其他两者的基础，可以完成一些桌面应用程序的开发。比如java版的扫雷
    J2ME(Java 2 Platform Micro Edition)  小型版：是为开发电子消费品和嵌入式设备提供的解决方案。该技术体系主要应用与小型电子消费类产品，如手机中的应用程序等。
java5.0版本后更名为   JAVAEE  JAVASE JAVAME
      java的特点：面向对象、简单、健壮性、平台无关性、解释型与高性能、多线程、动态性、安全性、分布式。
在这里不得不说一下java语言的一个显著特点：平台无关性(跨平台性)。顾名思义，跨平台性就是java语言编写的程序可以不受平台的限制，"一次编写，到处运行"。可以在win、linux、mac等系统下运行。那么，java语言是如何实现跨平台的呢？原理就是安装java虚拟机(JVM Java Virtual Machine)。由JVM来负责java程序在该系统中的运行。JVM是一个解析器，用于解析执行java软件，JVM是依赖于平台的，所以，java程序在那个系统上运行就要在那个系统上安装那个版本的JVM.

一、java编程环境
    前面我们已经说到了java程序要想运行就必须要安装JVM。而JVM怎么安装呢？我们先了解一下JRE和JDK。
    JRE(Java Runtime Environment  java运行环境)：包括java虚拟机和java程序所需的核心类库等，如果想要运行一个开发好的java程序，计算机只需要安装JRE即可。
    JDK(Java Development Kit  java 开发工具包)：JDK是提供给开发人员使用的，其中包含了java开发工具，也包括了JRE。因为在开发完成后还要运行测试其功能、性能。
我们要使用的是jdk\bin目录下的编译工具，所以，为了能在任何路径下都能编译运行，就要在计算机的高级系统设置下的环境变量下将jdk的路径加入，并新开dos命令行输入javac命令检测是否配置成功。
     所以，无论学习什么语言，都要先设置编程环境，只有有了环境才能让程序运行起来。

二、java语言的基本要素
1、java数据类型
基本数据类型：是java语言自身所定义的数据类型，不需要包含任何外部的程序。
引用数据类型：引用数据类型的变量值是某个对象的句柄比如电视机和遥控器的关系)，而不是对象本身。包括class interface 数组

2、java基本数据类型
整数类型(数值型数据)，是指没有小树部分的数字。
             byte(字节型)     占8位  
             short(短整型)    占16位
             int(整型)        占32位
             long(长整型)     占64位
浮点类型    float double
字符类型    char
布尔类型    boolean   (true/false)
类型间的转换
      byte b = 3;
      b=(byte)(b+2);//强制类型转换
3、标记
空白分隔符
    字符       含义
    '\n'       换行符
    '\t'       水平制表符
    '\f'       换页符
    '\r'       回车
    ' '        空格
注释(comments)：可以为编写的代码添加文字，用来解释代码的作用。
                          可用于调试。
                          可用于写程序开发过程：需求、思路、步骤等。
关键字
abstract、class、final、case、do、boolean、break、byte、catch、char、import、throw、inner、instanceof 、this、void等。
标识符
由0-9/26个英文大小写/_、$符号组成
数字不能开头，不可用关键字

分隔符
(、 )、{、 }、[、 ]、,、.、;

4、常量和变量
常量：能改变的数据。如整数、小数、boolean、字符('4'、'a'、'+')字符串("abc"、"a"、" ")、null
十进制、二进制、八进制、十六进制
变量：改变的数据

5、运算符和表达式
算数运算符、位运算符、关系运算符、逻辑运算符、条件运算符、赋值运算符、

三、程序控制语句
1、选择语句  if switch
if语句可用于可判断区间和结果为boolean类型的应用
适用类型：byte、short、int、char
数值不多时，case没有顺序

2、循环语句 for while  do-while
for语句：
for(初始化（变量）表达式;循环条件表达式;循环后的操作表达式)
  {
执行语句;
  }
我们知道，变量有他们自己的作用域，
在for循环语句中的变量只在该语句中有效，执行完后变量会被释放。
while语句对某些语句执行很多次。
for和while语句可直接互换。

计数器

/*
需求：获取1~100之间的7的倍数的个数。
思路和步骤：
1、遍历（循环）1~100的数，for
2、在遍历过程中，给出判断和条件，if（i % 7 == 0）  就可以，
3、定义一个变量，用于记录个数。
*/
class  Count
{
	public static void main(String[] args) 
	{
　　//count初始化为0
		int count = 0;
　　//使用for循环遍历1-100的数
		for (int i=1;i<=100 ;i++ )
		{
　　//只要1-100间的数与7取模，等于0，那么就是7的倍数
			if (i%7==0)
			{	
　　//记录遍历到的7的倍数的次数			
				count ++;				
			}			
		}
		System.out.println("count="+count);
	}
}

累加

/*
需求：求1--10的和，并打印。
*/
class  LeiAdd
{
	public static void main(String[] args) 
	{
		//定义一个变量，用于存储不确定的和，sum
		int sum=0;

		//定义一个变量，用于记录逐次增加（不断变化）的被加的数，i
		int i=1;

		//定义 while 循环实现重复加法的循环
		while (i<=10)
		{
			sum = sum + i;
			i++;
		}
		System.out.println("sum="+sum);

		/* for语句
		int sum = 0;
		for (int i=1;i<=10 ;i++ )
		{
			sum += i;
			//sum = sum + i;
			//System.out.println("sum="+sum);每次的和都打印出来
		}
		System.out.println("sum="+sum);
	*/
	}
/*
循环时应注意的地方：要清楚的知道哪些语句可以循环，哪些不可以。
*/
}

    while语句定义初始化表达式
  while（条件表达式）{
     循环体（执行语句）；
  }
    while:先判断是否符合条件，若符合，执行循环体。
do while:先执行循环体，在进行判断
do while无论条件是否符合要求，都会执行一次循环体。


3、跳转语句   break continue  return 异常处理语句
break应用于选择和循环语句
continue只能作用于循环语句中。

4、函数(方法)
    其实函数就是我们通常多说的方法，他与构造函数不同(以后学习构造函数)。以前我们编写的都是一些简单的小程序，就直接把代码写在了主函数中(程序的入口)，只要直接运行就0K。在学习的初期，写的代码比较单一，在以后的实际开发中，要写的代码肯定会更多更多，那么直接写在主函数中就不行了，一旦写的程序多了，若都放在主函数中，会混乱不堪，所以，这时就用到了函数。所谓函数，就是将我们要实现的功能代码写在一个定义好的函数中，最后再在主函数中调用这个函数(方法)就可以了。这个方式就叫做封装。将实现功能的代码写到函数中，封装起来，待到用的时候调用函数，而且可以在多个地方调用，提高了代码的复用性。这样，主函数的作用就只是用于调用函数，以便测试代码结果的正确性。从而使程序简洁、规范。
　　　
(1)、函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,···)
{
　　执行语句;
　　return 返回值;
　　}　
(2)函数的特点：封装、复用。
(3)、函数的应用：
如何定义函数？
明确运算结果(返回值类型)、明确是否有未知内容参与运算(参数列表)
在定义功能时，无非是考虑到函数应该如何写。只要明确了以上两个问题就可以轻松的定义一个函数，以实现所需的功能。
(1)判断两个数是否相同？
分析：判断两个数是否相同，则只有两个结果，相同/不相同，即true和false
且接收两个未知数
public static boolean compare(int a,int b)
{
return a==b;
//return (a==b)?true:false;
}
(2)定义功能，用于打印矩形

//定义函数(方法)，用于打印矩形。返回值类型为void，接受行和列两个参数
	public static void draw( int row,int col){
		for (int x=0;x<row ; x++)
			{
				for (int y=0;y<col ;y++ )
				{
					System.out.print("*");
				}
				System.out.println("");
			}	
	}

(3)定义一个功能，用于打印99乘法表
//构造一个函数，用于实现打印99乘法表  不接收参数
public static void print99(){

　　//外循环控制行
for (int x=1;x<=9 ; x++)
{
　　//内循环控制列数
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
主函数：
public static void main(String[] args)
{
　　//在测试调用时一定要打印，且写清返回值类型
　　boolean b = compare(9,5);
System.out.println(b);
printHr();
draw(5,6);

(4)函数的重载(overload)
下面就是函数的另一个特性：重载
参数列表不同且有顺序、重载和返回类型无关。
上面打印99乘法表的函数就可以使用重载的方式。
    //函数的重载  ，函数的参数类型不同，即接收的参数不同
public static void print99(int num){---}
举几个例子：
void show(int a,char b,double c){}

void show(int x,char y,double z){}//未重载
int show(int a,double c,char b){}//重载，参数类型顺序不同  与返回值类型无关
void show(int a,double c,char b){}//重载，参数类型顺序不同
boolean show(int a,char b){}//重载，参数类型不同
void show(double c){}//重载 参数类型不同
double show(int x,char y,double z){}//未重载，给出的例子中返回值类型为void，

四、数组

数组是一种引用数据类型，是同一种类型数据的集合，相当于一个容器，里面只可以放(存储)一样的东西(数据)。简单的从字面理解就是一组数据，可以存放多个数据。那么，就可以向数组中存储多个相同数据类型的数据。

1、数组的特点：
自动编号，且从0开始
默认初始化值为0
如：x[0]=9;  0角标元素是9
　　 x=null;   在这里，数组是引用数据类型，可以为null。
GC ：垃圾回收机制。当数据使用完时会自动释放内存。

2、静态初始化
定义一个大小为6的数组
int[] arr = new int[6];
静态初始化值为8,9,0,2,4,8
int[] arr = {8,9,0,2,4,8};

3、数组的相关操作
由于数组中存储的是同一类型的数据，且是一个集合，那么，我们就可以将数组中的元素打印出来，还可以获取数组中元素的个数、获取最大值、求和，还可以对数组中的元素进行排序。
数组是从0开始自动编号的，因此，角标的最大值是数组长度减一。
(1)获取数组的元素个数：数组名.length 
应该注意的是，这里的length不是方法(length())，而是数组自身的属性。
　　int[] arr={3,5,8,9,11,23};
System.out.println("arr.length:"+arr.length);
(2)对数组求和：
对数组求和，就是将数组中的所有元素累加起来。那么定义一个for循环，将数组中元素的角标作为变量，只要依次将角标所在的元素依次相加即可。

public static int getSum(int[] arr)
	{
		int sum = 0;
		for (int x = 0;x<arr.length ;x++ )
		{
			sum+=arr[x];
　　//sum = sum +arr[x];
			//System.out.println("sum= "+sum);如果写上这句话，打印的是每次循环所加的和
		}
		return sum;			
	}

(3)打印数组(遍历数组)：
数组是一个集合，里面存储着很多数据，那么就可以将数组中的元素一一取出并打印在控制台上。也就是说定义一个for循环，将数组中元素的角标作为变量，只要依次遍历该角标变量就可以取出该数组的每个元素。
当然，这里只是将打印结果美化了些，使打印结果看起来更舒服。
主函数调用：printArray(arr); [3,5,8,9,11,23]
//定义一个功能，用于打印数组中的元素，并且元素之间用“,”隔开
public static void printArray(int[] arr){
System.out.print("[");
for (int x=0;x<arr.length ;x++ )
{
　　//如果角标不是最后一个，则加上逗号
if (x!=arr.length-1)
{
System.out.print(arr[x]+",");
}else{
System.out.print(arr[x]+"]");
}
}
}
(4)获取最大值、最小值：
其实就是取数组中的任意一个元素作为最大值max与数组中的其他元素arr[x]依次比较，如果arr[x]大于了max，那么，就将arr[x]作为最大值传递给max，否则继续比较。反之，获取最小值类似。
比较的方式有多种，这里只说一下两种比较方式。

public static int getMax(int[] arr){
		//取角标为0的元素作为比较的最大值
		int max=arr[0];
		for (int x=0;x<arr.length ;x++ )
		{
			//如果角标为x的元素大于最大值max
　　//将这里的>改成<就可以按从大到小的顺序排序
			if (arr[x]>max)
			{
				//将arr[x]赋给最大值
				max=arr[x];			
			}
		}
			//将最大值返回
			return max;
	}

	//另一种获取最大值的方法，使用数组中元素的下角标
	public static int getMax_2(int[] arr){
		//最大值的角标初始化为0，即将数组中0下角标的元素作为最大值
		int max=0;
		for (int x=1;x<arr.length ;x++ )
		{
			//如果max角标的元素大于x角标的元素
			if (arr[max]>arr[x])
			{
				//将x角标作为最大角标传给max
				max=x;
			}
		}
		//返回max角标所在的最大元素
		return arr[max];
	}

主函数调用：
　　int[] arr={2,5,8,9,11,23};
		
		int max=getMax(arr);
		System.out.println("max="+max);
		
		int max_2=getMax_2(arr);
		System.out.println("max_2="+max);

		int sum = getSum(arr);
		System.out.println("sum="+sum);

(5)数组排序
　　选择排序： 所谓选择排序就是选择任一位置(角标)，让该位置中的元素依次与其他位置上的元素进行比较。
　　且内循环结束一次，最值出现在0角标的位置上。
　　

//返回值类型为void，只是对数组中的元素操作，操作完后还是那个数组，只是不同引用
	//第一次选择0角标位置的元素依次与其他角标位置的元素进行比较，
	//第二次选择1角标位置的元素依次与其他角标位置的元素进行比较，
	//依次类推，用for循环嵌套
	public static void selectSort(int[] arr)
	{
		//外循环控制的是比较的次数
		//当每次比较到最后一个时，最后一个元素不需要再比较
		for (int x=0;x<arr.length-1 ; x++)
		{
			//每次比较都是第一个和后面的比较，并没有和自身比较，与自身比较无意义，所以x+1
			for (int y=x+1;y<arr.length ;y++ )
			{
				//如果x角标的元素大于y角标的元素
				if (arr[x]>arr[y])
				{
					//定义一个临时变量，将arr[x]元素记录下来，此时x角标位置没有元素
					int temp=arr[x];
					//arr[x]>arr[y]，将两个元素交换位置，将arr[y]赋给arr[x]，此时y角标位置没有元素
					arr[x]=arr[y];
					//将大值temp放到y角标位置
					arr[y]=temp;
				}							
			}
		}	
}	

　　冒泡排序：相邻的两个元素比较，如果符合条件则两个元素换位。
　　且当比较第一圈时，最值出现在最后那个角标位置上。
	public static void bubbleSort(int[] arr)
	{
		//当每次比较到最后一个时，最后一个元素不需要再比较
		for (int x = 0;x<arr.length-1 ;x++ )
		{
			//当每比较一次，被比较的元素就会减少1  -x
			//避免角标越界  -1
			for (int y = 0;y<arr.length-x-1 ; y++)
			{
　　//如果arr[y]>arr[y+1],置换位置，
				if (arr[y]>arr[y+1])
				{
　　//定义第三方变量记录最大值，然后换位
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
	}	
	//编写主函数测试一下结果
	public static void main(String[] args)
	{
	 int[] arr = {3,2,8,5,7,11};
	  //排序前
	  printArray(arr);
	  //排序后
	 // selectSort(arr);
	 bubbleSort(arr);
	  printArray(arr);
	}
//为更清晰的比较排序前后的情况，将打印数组的功能封装到一个函数中
		public static void printArray(int[] arr)
		{
			System.out.print("[");
			for (int x=0;x<arr.length ;x++ )
			{
				if (x!=arr.length-1)
				{
					System.out.print(arr[x]+",");
				}else
　　			System.out.println(arr[x]+"]");			
			}
		}
	}

4、位置置换功能抽取
由于数组的排序的流程都涵盖位置置换这一步，所以，将这个功能单独提取出来，方便调用。在位置置换中，都是两个符合条件的元素互换位置。
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

5、查找

（1）简单查找
对于数组来说，要查找某个元素在数组中出现(第一次)的位置，只要获得该元素在数组中对应的角标的索引就可以。如果该角标对应的值是待查找的元素，则直接将该角标返回即可，否则返回-1，说明待查找的元素在数组中不存在。
下面编写一个简单的程序，查找元素在数组中的位置。
　 //接收一个未知数组和元素
public static int getIndex(int[] arr,int key)
{
　　//要查找必须先遍历数组
for (int x= 0;x<arr.length ;x++ )
{
　　//如果数组中的元素是待查找的元素
if (arr[x]==key)
　　//返回该角标
return x;
}
　　//如果不存在，返回-1
return -1;
}
主函数调用：
int[] arr = {3,5,7,9,13,23,29};
int index = getIndex(arr,5);
System.out.println("index="+index);

（2）折半查找
所谓折半查找，就是将数组的长度一分为二，判断要查找的元素在哪个区域内，缩小了查找的范围，提高了效率。
折半查找第一种方式：
将数组的中间值作为临界点，如果待查找的元素不在该范围内，则直接返回-1，该元素在数组中不存在。否则，再判断：如果待查找元素大于或小于中间值，则将中间值 +/- 1，以作为该向中间值的右或左移动的依据。

public static int halfSearch(int[] arr,int key)
	{
		int min,max,mid;
		//数组的最小角标为0
		min = 0;
		//数组的最大角标数组的长度减一
		max = arr.length-1;
		//将数组的长度折中，减少查找的范围，提高效率
		mid = (max+min)/2;
		
		//如果中间的元素不等于要查找的元素，则循环，判断
		while (arr[mid] != key)
		{
			//如果要查找的元素大于中间值
			if (key>arr[mid])
				//那么，最小值所在的角标就要向右移动，缩小查找范围，即中间值所在角标+1，才有可能查到
				min = mid + 1;
			else if (key<arr[mid])
				//要查找的元素小于中间值，
				//那么，最大值所在的角标就要向左移动，缩小查找范围，即中间值所在角标-1
				max = mid - 1;
			//如果最小值大于最大值，说明该查找的元素不存在，返回-1
			if (min>max)
				return -1;
			//若条件不符合，则程序处于死循环，则再进行折半查找
			mid = (max+min)/2;	
		}
		//若中间值正好等于要查找的元素，则将这个中间值返回
		return mid;
	}

折半查找第二中方式：
将数组的长度的最大值和最小值之间的距离作为循环依据，若最大值和最小值之间没有距离，即待查找元素不存在。否则继续判断。

public static int halfSearch_2(int[] arr,int key)
	{
		int min= 0,max= arr.length-1,mid;
		//如果min<=max,即最小角标和最大角标所在的位置有距离，那么就可以折半查找
		while (min<=max)
		{
			//折半，角标最小值与角标最大值相加 左移一位(除以2)
			mid = (max+min)>>1;
			//如果要查找的元素大于中间值，
			if (key>arr[mid])
				//那么，最小值角标右移，即中间角标值加一
				min= mid+1;
			else if (key<arr[mid])
				//如果待查找的元素小于中间值，则最大角标值左移
				max= mid-1;
			else 
				//若待查找值等于中间值，直接返回
				return mid;				
		}
		//若都不符合条件，即待查找元素不存在，则返回-1
		return -1;
	}

主函数调用：
　　int index_1 = halfSearch(arr,7);
　　System.out.println("halfSearch-index_1="+index_1);
　　
　　int index_2 = halfSearch(arr,50);
　　System.out.println("halfSearch-index_2="+index_2);

6、二维数组
二维数组，简单地说，就是数组中存储的是数组。
//定义一个长度为3的一维数组
int[] arr = new int[3];

//定义一个二维数组arr,长度为3，即二维数组中有3个一维数组，且一维数组中有4个元素
int[][] arr = new int[3][4];
arr.length ：表示的是该二维数组的长度
arr[0].length  ：表示的是二维数组中第一个一维数组的长度。
在堆内存中，存储着一个二维数组arr，arr中有3个一维数组，分别是arr[0][4]、
arr[1][4]、arr[2][4]，而每个一维数组是arr[0]、arr[1]、arr[2]、arr[3]。
在没有手动初始化时，他们的默认初始化值为null。

-------http://www.itheima.comjava培训、android培训期待与您交流！-------