黑马程序员——java基础--java语言入门

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

以下内容为本人观看黑马程序员毕向东老师java基础视频及张孝祥老师java高新技术视频所整理的内容。

一、java语言入门

Java语言的基本组成：关键字，标识符，注释，常量与变量，运算符，语句，函数和数组，这里介绍了java语言里面基础的知识，一些值得注意的地方已用红字标出。

1. 初识java

基础常识：

1.软件开发

软件：一系列按照特定顺序组织的计算机数据和指令的集合

常见的软件：

系统软件----如DOS，windows，Linux等

应用软件----扫雷，迅雷，qq等

开发：

制作软件

2.人机交互方式

软件的出现实现了人与计算机之间的更好的交互

交互方式：

图形化界面：这种方式简单直观，使用者易于接受，容易上手操作。

命令行方式：需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记住一些命令。

3.常用的DOS命令

dir：列出当前目录下的文件及文件夹

md：创建目录

rd：删除目录

cd：进入指定目录

cd..：退回到上一级目录

cd/：退回到根目录

del：删除文件

exit：退出dos命令行

4.计算机语言

通过DOS命令行的演示，发现原来操作计算机就如同和计算机说话一样，我们告诉它做什么，它就可以做什么。前提是，我们和它说的内容它必须识别才可以，这就是计算机语言。

计算机语言是人与计算机交流的方式，如果要和计算机沟通，就要学习计算机语言，包括c语言，java等，这里主要学习java。

5.java语言的特性

跨平台型：通过java语言编写的程序可以在不同的系统平台上都可以运行，原理是java运行需要一个jvm虚拟机，这个虚拟机是有很多系统版本的。

2. 环境搭建

1.jre和jdk

jre：Java Runtime Environment  即java运行环境

jre包含java程序运行所需要的虚拟机和核心类库，如果要运行java程序，需要先安装jre

jdk：Java Development Kit  即java开发工具包，也包括了jre，所以安装jdk就不需要安装jre了

其中的开发工具：编译工具（javac.exe）打包工具（jar.exe）等

简单的讲：使用jdk开发完成的java程序，交给jre去运行

2.下载jdk

www.oracle.com

java.sun.com

3.安装jdk

4.配置环境变量

jdk路径复制，打开系统环境变量配置，找到变量名为Path的系统变量，将路径粘贴到变量值的最前面，并用分号隔开后面的

也可以自己创建一个JAVA_HOME的环境变量存储路径，然后在path里面用%JAVA_HOME%的方式调用

如果想临时配置环境变量可以在dos命令行使用set path=命令

如：

set path=haha;%path%  加上原有

5.验证是否成功

3. classpath配置

想执行java.class文件，可以先把路径告诉系统，让系统自行去找

临时配置方式

set classpath=class文件路径；

配置classpath后如果跟分号：系统会先找环境变量里面的路径，如果没有设置classpath，先找当前目录

配置后classpath后如果不跟分号，系统会先找环境变量里面的路径，如果没有设置classpath，不会再找

最好不加分号，如：set classpath=c:\;d:\

如果需要在当前目录找一下，可以在前面加个点：set classpath=.;c:\;d:\

path和classpath相反，path先在当前目录找，找不到才在指定的目录下找

4. 注释、标识符

注释：

单行注释用：//注释内容

多行注释：/*        注释            */

标识符：在程序中自定义的一些名称。

由26个英文字母大小写，数字：0-9 符号：_$组成

定义合法标识符规则：

  1.数字不可以开头。

  2.不可以使用关键字。

java中严格区分大小写。

在起名字的时候为了提高阅读性，要尽量有意义。

java中的名称规范：

包名：多单词组成时所有字母都小写。xxxyyzzz

类名接口名：多单词组成时，所有单词首字母大写。XxxxYyyyZzz

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

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

5. 常量与变量

常量表示不能改变的数值。

Java中常量的分类：

1，整数常量，所有整数

2，小数常量，所有小数

3，布尔型常量，较为特有，只有两个值，true和false

4，字符常量，将一个数字或字母用单引号‘’标识。

5，字符串常量，将一个或者多个字符用双引号”“标识

6，null常量：只有一个值就是null

对于整数：java有三种表现形式

十进制：0-9，满十进一

八进制：0-7，满八进一

十六进制：0-9，A-F，满十六进一，用0x开头表示
进制越大，表现形式越短
进制的转换：

十进制转二进制：

方法：对十进制数进行除2运算，一直除到商位1，把余数从后向前连起来

二进制转十进制：

方法：10110：0*2^0+1*2^1+1*2^2+0*2^3+1*2^4
其他进制转换：

转成16进制
0101-1010
算4个为一组，1010  十进制10          0101  十进制5

所以十六进制为   0x5A

转为八进制

三个二进制位代表一位

值得注意的是：负数的二级制是其对应正数的二进制取反+1，例如6=110，6在内存中占32位，即0000-0000 0000-0000 0000-0000 0000-0110

所以-6的二进制是：1111-1111 1111-1111 1111-1111 1111-1010

将int转为二进制的函数：Integer.toBinaryString(-6)

变量：就是将不确定的数据进行存储。

也就是需要在内存中开辟一个空间。

class  
{
	public static void main(String[] args) 
	{
		//定义变量的格式；
		//数据类型 变量名 = 初始化值；
		int x = 4;
		byte b = 2;    //-128~127;

		short s = 30000;
		
		long l = 41;

		float f = 2.3f;

		double d = 34.56;

		char ch = '4';   //占两个八位

		String s = "4";

		boolean b = true;
	}
}

 

6.关键字

7. 运算符

运算符分为：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三元运算符

算术运算符：

class  YunSuanFu
{
	public static void main(String[] args) 
	{
		int x = 4270;
		x = x/1000*1000;

		System.out.println(-1%5);

		int a = 3,b;
		a++;//a = a+1;
		b = ++a;
		//字符串数据和任何数据使用+都是相连接，最终都会变成字符串。
		System.out.println("5+5"+5+5);

	}
}

赋值运算符：

符号：=，+=，-=，*=，/=,%=

示例：int a,b,c;  a=b=c=3;

            int a = 3;a+=5;等同运算a=a+5;

比较运算符：

比较运算符的结果都是boolean型，也就是要么是true，要么是false

比较运算符的==不能写成=

逻辑运算符：

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

注意的是：&  和&&的区别，&  左边无论真假，右边都进行运算；&&  如果左边为真，右边会参与运算，如果左边为假，右边不会运算

|    和    ||   的区别，|    左边无论真假，右边都会运算，||     左边如果为真，右边不会运算，如果左边为假，右边会运算。

位运算符：

位运算符直接对二进制进行运算

/*
练习：
1，最有效率的方式算出2乘以8等于几？2<<3；

分析：2乘以8，即为二进制是逢2进一，8是2的3次方，所以要进三次，也就是在2的基础上
左移三位，如果不好理解的话可以把2想象成10,10的3次方是1000，需要计算10*1000的值，
是不是需要在10的基础上要左移三位？所以要想到用位运算符计算2*8应该是最有效率的。
2的二进制表现形式 0000-0000 0000-0000 0000-0000 0000-0010
         左移三位 0000-0000 0000-0000 0000-0000 0001-0000
		 其结果为 十进制的  16


2，对两个整数变量的值进行互换（不需要第三方变量）

分析：	int x = 6;
		int y = 3;
		想要把x和y的值调换，除了借助第三方变量以外还可以用到位运算符的异或：相同出0，不同出1
		根据此特征可知  x^y^x  = y;  可用x或者y其中的一个变量先记录住x^y的值，那么只要知道另一个的值
		就可以再异或x^y的值推出另一个值

*/

class  WeiYunSuan
{
	public static void main(String[] args) 
	{
		System.out.println(2<<3);

		int x = 6;
		int y = 3;

		x = x^y;   //x = 6^3 = 110^011 = 101
		y = x^y;	//y = 101^011 = 110 = 6
		x = x^y;	//x = 101^110 = 011 = 3

		System.out.println("x="+x);
		System.out.println("y="+y);
	}
}

三元运算符:

格式：（条件表达式）？表达式1：表达式2

如果条件为true，运算后结果是表达式1；

如果条件为false，运算后结果是表达式2；

例如：

         int x=3,y=4,z;

         z = (x>y)?x:y;     先判断x是否大于y，大于，则将x赋值给z，不大于，将y赋值给z，

即z存储的是x和y中的最大值；

8. 语句

判断结构：

if语句特点：

1，每一种格式都是单条语句。

2，第二种格式与三元运算符的区别：三元运算符运算玩要有值的出现

3，条件表达式无论写成什么样子，只看最终结果是true还是false

选择结构：

选择结构特点：

1，switch语句选择的类型只有四种：byte，short，int，char

2，case之间与defult没有顺序，先执行第一个case，没有匹配的case执行defult

3，结束switch语句有两种情况：遇到break，执行到语句结束。

4，如果匹配的case或defult没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束

循环结构：

注意：

1.for循环里面三个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后在执行循环后的操作表达式，接着继续判断循环条件，重复这个过程直到条件不满足为止

2.while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
3.最简单无限循环格式： while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

其他流程控制语句：

break（跳出），continue（继续）

9. 函数

函数的定义：

1，什么是函数：函数就是定义在类中具有特定功能的一段独立小程序。函数也称方法

2，函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2， )
{
执行语句;
return 返回值;
}

返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。

函数的特点：

1，定义函数可以将功能代码进行封装

2，便于对该功能进行复用

3，函数只有被调用才会执行

4，函数的出现提高了代码的复用性

5，对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：函数中只能调用函数，不可以在函数内部定义函数。

定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的应用：

两个明确：

明确要定义的功能最后的结果是什么

明确在定义该功能的过程中，是否需要未知内容参与运算

/*
需求：定义一个功能，可以实现两个整数的加法运算。
分析：
	该功能的运算结果是什么？两个数的和，也是一个整数（int）
	在实现该功能的过程中是否需要有未知内容参与运算？加数和被加数是不确定的。
	（两个参数int，int）
*/

class  SumDemo
{
	static int getSum(int x,int y)
	{
		return x+y;
	}

	public static void main(String[] args) 
	{
		System.out.println(getSum(3,5));
	}


}

函数的重载：
 

10. 数组

1. 数组概述

数组的定义：

数组的内存结构图：

内存结构：java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

1，栈内存：

用于存储局部变量，当数据使用完，所占空间会自动释放。

2，堆内存：

数组和对象，通过new建立的实例都存放在堆内存中

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不再被使用，会在不确定的时间被垃圾回收器回收

3，方法区，本地方法区，寄存器

2. 常见操作-->遍历和获取最值

//数组常见操作：遍历
class ArrayDemo3 
{
	public static void main(String[] args) 
	{
		//数组的操作；
		//获取数组中的元素，通常会用到遍历。

		int[] arr = new int[3];

		//数组中有一个属性可以直接获取到数组的长度，length
		//使用方式：数组名称.length = 
		System.out.println(arr.length);
		int sum = 0;
		for(int x=0;x<arr.length;x++)
		{
			sum+=arr[x];
			System.out.println(arr[x]);//arr[0] = 0;
		}
	}

	//定义功能，用于打印数组中的元素。元素间用逗号隔开
	public ststic void printArray(int[] arr)
	{
		for(int x=0;x<arr.length;x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.print(arr[x]);
		}
	}
}

获取最值：

/*
给定一个数组{5,1,6,4,2,8，9}

1，获取数组中的最大值，以及最小值。
*/

class ArrayTest 
{
	/*
	获取数组中的最大值。
	思路：
	1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
	通过一个变量进行临时存储。
	2，让数组中的每一个元素都和这个变量中的值进行比较。
	如果大于了变量中的值，就用该变量记录较大值。
	3，当所有元素都比较完成，那么该变量中存储的就是数组中的最大值了。

	步骤：
	1，定义变量，初始化为数组中任意一个元素即可。
	2，通过循环语句对数组进行遍历。
	3，在便利过程中定义判断条件，如果遍历到的元素大，就赋值给该变量

	需要定义一个功能来完成，以便提高复用性
	1，明确结果，数组中的最大元素int。
	2，未知内容：一个数组。int[]
	*/
	public static void main(String[] args) 
	{
		int[] arr = {5,1,6,4,2,8，9};
		getMax(arr);
	}

	public static int getMax(int[] arr)
	{
		int max = arr[0];
		for(int x=1;x<arr.length;x++)
		{
			if(arr[x]>max)
				max = arr[x];
		}
		return max;
	}
}

3. 排序

1.选择排序

/*
选择排序
*/

class  XunZePaiXu
{
	public static void main(String[] args) 
	{
		int[] arr = {5,4,6,7,9,2,9};
		for(int x=0;x<arr.length-1;x++)
		{
			for(int y=x+1;y<arr.length;y++)
			{
				if(arr[y]<arr[x])
				{
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
		for(int x=0;x<arr.length;x++)
		{
			System.out.println(arr[x]);
		}
	}
}

 

2.冒泡排序

/*
冒泡排序
*/

class  MaoPaoPaiXu
{
	public static void main(String[] args) 
	{
		int[] arr = {5,4,6,7,9,2,9};
		for (int x=0;x<arr.length ;x++ )
		{
			for (int y=0;y<arr.length-x-1 ;y++ )
			{
				if (arr[y]>arr[y+1])
				{
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
		for(int x=0;x<arr.length;x++)
		{
			System.out.println(arr[x]);
		}
	}
}

插入排序和希尔排序

3.折半查找

 

/*
数组的查找操作。
*/

class  ArrayTest4
{
	public static void main(String[] args) 
	{
		int[] arr = {1,2,3,4,5,6,7,8,9};
		int index = getIndex(arr,2);
		int index1 = halfSearch(arr,8);
		System.out.println(index1);
	}
	/*
	折半查找：提高效率，但必须要保证该数组是有序的数组
	*/
	public static int halfSearch(int[] arr,int value)
	{
		
		for (int x=0;x<arr.length-1 ;x++ )
		{
			if(arr[x+1]<arr[x])
			{
				return -2;
			}
		}
		int min = 0;
		int max = arr.length;
		int mid = (min + max)/2;
		while (mid!=0)
		{
			if (value>arr[mid])
			{
				min = mid;
				mid = (min + max)/2;
			}
			else if(value<arr[mid])
			{
				max = mid;
				mid = (min + max)/2;
			}
			else
				return mid;
		}
		return -1;
	}


//定义功能，获取key第一次出现在数组中的位置。如果返回时-1，代表该key在数组中不存在
	public static int getIndex(int[] arr,int key)
	{
		for(int x=0;x<arr.length;x++)
		{
			if(arr[x]==key)
				return x;
		}
		return -1;
	}
}

4. 二维数组

 二维数组就是数组中的数组

格式1：int[][] arr = new int[3][4]   ：定义了名称为arr的二维数组，二维数组中有3个一维数组，每个一维数组有4个元素

数组的内存结构图：

/*
int[] x,y[];//此种定义方式x为一维数组，y为二维数组

判断：
a，
x[0] = y;  错误

b,
y[0] = x;  正确

c,
y[0][0] = x;  错误

d,
x[0][0] = y;  错误
*/