1．Java语言概述
Java语言是SUN公司（Stanford University Network，斯坦福大学网络公司），1995年推出的一门高级编程语言。它是一种面向internet的编程语言。随着Java技术在web方面的成熟，已经成为Web应用程序的首选开发语言。Java简单易学，完全面向对象、安全可靠，与平台（操作系统）无关的编程语言。
2．Java语言的三种技术架构
J2EE(Java 2 Platform Enterprise Edition)企业版
在jdk5.0版本后称为JAVAEE,是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如Servlet Jsp等，主要针对于Web应用程序开发。是传智播客就业班和黑马训练营的主要学习内容之一.。
J2SE（Java 2 Platform Standard Edition）标准版
在jdk5.0版本后称为JAVASE,这是在java基础阶段主要学习的内容,也是java的基础,以后不管从事Android开发或者是物联网+云计算的开发,等是建立在JSE基础上的,因此该技术是java的最核心技术,是传智播客基础班的主要上课内容.。
J2ME(Java 2 Platform Micro Edition)小型版
在jdk5.0版本以后称为JAVAME,该技术多应用于一些电子产品的嵌入式开发,以前在手机开发上应用的也比较多,但是随着智能手机的发展,现在手机应用程序(比如Android程序)的开发已经不再使用该技术。
注：Java5.0版本后，更名为JAVAEE、JAVASE、JAVAME
3. Java语言的 跨平台？原理是什么？JVM是什么？
所谓跨平台性，是指java语言编写的程序，一次编译后，可以在多个系统平台上运行。
Java跨平台图解
跨平台原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统安装了相应的java虚拟机，该系统就可以运行java程序。（注意不是能在所有的平台上运行，关键是该平台是否能安装相应的虚拟机）。
JVM（Java Virtual Machine）就是Java虚拟机。
它是运行所有Java程序的抽象计算机,是Java语言的运行环境，它是Java 最具吸引力的特性之一，JVM读取并处理编译过的与平台无关的字节码(class)文件。Java编译器针对JVM产生class文件，因此是独立于平台的。Java解释器负责将JVM的代码在特定的平台上运行。Java虚拟机是不跨平台的.
注：用Java编写的语言之所以能跨平台运行，是因为各个操作系统都有JVM，Java编写的程序通过JVM编译运行，与操作系统并无直接关系。
4.JRE和JDK是什么？两者有什么区别？
JRE：（Java Runtime Environment），java运行环境。包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE 即可。
JDK：（Java Development Kit Java）开发工具包。JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
简单而言：JDK中包含JRE，使用JDK开发完成的java程序，交给JRE去运行。
5.Java环境变量配置？
为了在任意盘符下通过dos窗口编译运行Java编写的程序，我们将要对javac所在目录进行环境变量的配置。
针对windows7操作系统
步骤：右击“计算机”——>单击“属性”——>单击“高级系统设置”——>在“系统属性”窗口中单击“环境变量”——>在“环境变量”窗口中找到“系统变量中的path”单击“编辑”——>将jdk的bin目录复制到“变量值”窗口内的最前面并通过分号以示区分——>之后保存退出即可.
JAVA_HOME永久配置
在path路径中JDK的安装目录中bin是不变化，而其他的可能是变化的，所以通过自定义JAVA_HOME为以后操作提供方便。
步骤：通过%%动态获取JAVA_HOME的地址 即将JAVA_HOME%bin%;配置到path路径中即可，而JAVA_HOME的配置是在在“环境变量”窗口中找到“系统变量中的path”单击“新建”——>将“变量名”设置为JAVA_HOME 将“变量值”设置成除了bin以外的安装路径即可。
Java环境变量临时配置方式
在dos命令行中配置 通过 set来设置 set path可以查看当前的path路径，通过set path = 将要配置的程序的目录，即可做到临时配置。dos配置的环境变量只在当前窗口有效，通过start方式可以延续已有的配置信息
注意：在配置的时候一定要注意是分号，还有通过键盘上的Home键可以使光标跳转到文本的最前面。
6、常见的dos命令
dir：列出当前目录下的文件以及文件夹 eg：dir D:\java_test
md：创建目录eg：d:\>md kkk
rd：删除目录eg：d:\>rd kkk
cd：进入指定目录eg：d:\>cd java_testcd
cd..：回到上一级目录
cd/：退回到根目录
del：删除文件eg：d:\>del *.txt
cls：清屏
exit：退出dos命令行
7.Java程序的运行机制？
Java都是以类class的形式体现，{}是类的区间。
注：我们编写的程序必须转换为虚拟机所识别字节码文件才能被执行，所以通过Javac命令将 文件名.java文件编译成字节码文件即.class文件，在通过JVM运行产生结果。
8.classpath如何配置？
通过dos命令中的 set classpath命令
例如：set classpath = 是对环境变量清空
set classpath = class文件所在路径；
set classpath = .\c:\;d:\意思是先在当前目录下寻找没有再去c盘和d盘
注：虚拟机在启动时先找classpath中的路径 之后再找当前目录。有分号先在classpath指定目录中找，如果没有找到文件则在当前目录找，在配置classpath时不建议加分号。
9.类名的名称及java中需要注意的？
一个Java源文件里可以定义多个Java类，但其中最多只能有一个类被定义成public类；
若源文件中包括了public类，源文件必须和该public类同名；
一个源文件中可能包含多个Java类，编译后会生成多个字节码文件，即每个类都会生 成一份单独的class文件，且字节码文件名和其对应的类名相同；
Java语言拼写上严格区分大小写；
10.关键字
在java中被赋予了特殊含义的词，叫做关键字（也叫保留字）。比如public 、class、 int、 string等等。在java中常见的关键字有一下这些。
图片
注：虽然goto、const在java中并没有任何意义，却也是保留关键字，与其他的关键字一样，在程序中不能用来作为自定义的标示符。
11.标示符
标示符就是在程序中自己定义的一些名称即Java中的包名、类名、方法名和变量名，可有任意顺序的大小写字母、数字、下划线 _ 和美元符号$等组成，但标示符不能以数字开头，不能使用java中的关键字。
命名时应遵循的规则：阅读性强、见词识意
包名：多单词组成时所有字母都小写。eg：xxxyyyddd
类名：多单词组成时首字母都大写其余小写。eg：XxxYyyDdd
变量名和函数名：多单词组成是第一个单词字母小写，其余单词首字母都大写。
eg： xxxYyyDdd
常量名：所有单词都大写 多单词组成是之间通过下划线’_’相连接。
eg：XXX_YYY_DDD
12.注释
在java中分为注释分为单行注释、多行注释、文档注释,注释可以注解说明程序和调试程序，并且被注释的内容会被编译器所忽略。
单行注释 // 被注释的内容 只在本行有效
例如：int x = 1；//定义一个整数
多行注释 可以跨行
例如：
文档注释 java特有的可以通过javadoc之类的工具生成文档
13.常量
常量是不能被改变的数据在Java中固定不变的数。比如：Hello World
Java中的常量分类：
① 整数常量：所有的整数
② 小数常量：所有的小数
③ 布尔常量：较为特殊只有两个值 true 和 false
④ 字符常量：将一个数字、字母或符号用单引号（‘’）标示
⑤ 字符串常量：将一个或多个字符用双引号（“ ”）标示
⑥ null常量：只有一个数值就是null
14.变量
什么是变量？
变量是栈内存中的一个存储区域，该存储区域有自己的名称（变量名）和数据类型，该 区域的数据可以在同一类型范围内不断变化。
为什么定义变量？
定义变量是为了存放同一类型的常量，并可以重复使用。
变量应注意什么？
变量的作用范围（定义开始到定义它的代码块结束），并且要有初始化值。
定义变量的格式：
数据类型 变量名 = 初始化值；例如：int a = 4；
什么时候定义变量？
当数据不确定的时候，需要对数据进行存储，就定义一个变量来完成存储动作，在同一 范围内不允许变量名同名，定义变量时要有初始化值。
理解：变量就如同数学中的未知数
变量栈内存中图例
15.Java中的数据类型的划分
Java是强类型语言，它为每一种数据都定义了明确的数据类型，并且每一种数据类型在内存中都拥有不同的内存空间。
Java中数据类型划分为：基本数据类型和引用数据类型。基本数据类型也就是我们常说的8大数据类型，他们在内存中所占用的空间和默认值都不相同。
整数类型：
整型类型的数据一般代表整数，但是他们的范围各部相同，所以我们要根据我们实际的需求进行选择。注意：整数在java中默认的数据类型是 int类型。Long类型的数据需要用L来标示。例如: long num = 4;是错的，正确应该是：long num = 4L;
浮点类型：
代表小数值的类型，当需要存储一个小数是就在float和double中进行选择。
注意在java中小数默认的数据类型为double类型的，float类型的数据需要用字母f 来标示。例如：float f = 2.3；是错误的，正确的应该是float f = 2.3f；
字符型：
字符型代表特定的某个字符，按照前面介绍的知识，计算机中都是以字符集的形式来保存字符的，所以字符型的值实际只是字符集中的编号，而不是实际代表的字符，由计算机完成从编号转换成对应字符的工作。Java 语言中为了更加方便国际化，使用Unicode 字符集作为默认的字符集，该字符集包含各种语言中常见的字符。在程序代码中，字符使用一对单引号加上需要表达的字符来标识。
布尔类型
布尔类型的变量，只有true（真）和false（假）两种。也就是说，当将一个变量定义成布尔类型时，它的取值只能是true和false，初次之外，没有其他的值可以赋值给这个变量。
引用数据类型
类（class）、接口（interface）和数组（[])三种引用数据类型，引用数据类型指向类产生的对象。
16.数据类型转换
Java中有严格的数据类型限制。数据类型是不可以轻易转换的。但在特殊的情况下还是 需要进行这样的操作。但必须有严格的步骤和福鼎数据类型的转换方式可分为自动类型 转换和强制类型转换两种。
自动类型转换（向上转型）
整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：
容量小的类型可自动转换为容量大的数据类型；
byte,short,char → int → long → float → double
byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。
boolean 类型是不可以转换为其他基本数据类型。
强制类型转换（向下转型）
当程序需要转换数据类型是，可实施强制性的类型转换，其语法如下。
（欲转换的数据类型）变量名称；
当两个整数相除时，小数点以后的数字就会被截断，使得运算结果保持为整数。但由于 这并不是预期的计算结果，而想要得到运算的结果为浮点型，就必须将两个整数中的一 个做强制转换为浮点数。
例如：a和b都是int类型（float）a/b； a/(float)b; (float)a/(float)b;
17.运算符
运算符是一种特殊符号，用以表示数据的运算、赋值和比较等共分以下几种：
算术运算符（+ 、— 、* 、/ 、%）
算数运算符要注意的是%，意思是取模即取余。
规律：左边小于右边结果是左边 例如：2%5结果是2
左边等于右边结果是0 例如：5%5结果是0
右边是1结果是0 例如：5%1结果是0
注意：取模时如果有负数，其结果的符号只看被模数，即看左边数的符号。例如—2%5 结果是-2。字符串数据和任意数据使用加号（+）相连接最终都会变成字符串。
赋值运算符（= 、+=、-=、*=、/=,、%=）
实例: short s = 4;
s = s+5;//编译报错
s += 5；//结果通过
分析：因为5默认是整形int而s是short类型，在运算s+5时s会自动提升类型结果 变成int类型，将整形赋值给短整型,好比将4两的东西放到2两的碗中，会损失精度， 所以编译时报错。而 += 是一个赋值运算符，内部有自动转换动作会直接将结果赋值给 s，所以不会报错。
关系运算符（= =、！=、>、<、>=、<=）
比较运算符结果都是boolean类型其结果要么是true
逻辑运算符（&、&&、|、||、^、！）
逻辑运算符多用于连接boolean类型的表达式。
& 的特点：只要两边的boolean表达式结果中有一个为false，那么结果就是false。
| 的特点：两边只要有一边为true那么结果为true，只有两边都为false结果才是false。
^ 的特点：两边相同为假，不同为真
！的特点：就是“非”的意思
&&的特点：是左边为false右边不进行运算（短路）而&左边无论是true还是false右 边都进行运算
|| 的特点：当左边的结果为true时右边不运算，而（|）左边无论是true还是false右边 都进行运算
位运算符（&、|、^、~、>>、<<、>>>）
位运算都是直接对二进制进行运算。
左移(<<)越移越大，左移n位后的值为:乘以2的n次幂。例如:3左移2位后其值为3*2^2=12;
右移(>>)越移越越小，因为有效位都给移走了，右移n位后的值为:除以2的n次幂。例如:6左移2位后其值为6/2^2=1(取整);
无符号右移(>>>) ，无论最高为是0或1，右移后都用0补。
?进行位运算时，可以先把数转换为二进制数，然后按1为真0为假，进行"&","|","^"运算。
三元运算符
(条件表达式)?表达式1：表达式2 // (优点是可以简化代码,缺点是三元运算符是 一个运算符，就说明它运算一定会有的结果)
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
在十六进制中， 'A' 'B' 'C' 'D' 'E' 'F'
对应ASCLL码值 65 66 67 68 69 70
对应十进制数 10 11 12 13 14 15
那么怎么把这几个十进制数，转换成字母呢？可以把对应十进制数减10加'A',
例如：(12-10)+'A' = 2+65=(char)67再强转下，对应的就是'C'
18.程序控制语句l
|--顺序结构
就是程序一行一行的往下读，直到结束。
|--判断结构（if语句）
l if语句有哪几种结构？
(1) if(条件表达式) (3) if(条件表达式)
{ {
执行语句; 执行语句;
} }
else if(条件表达式)
(2)if(条件表达式) {
{
执行语句; 执行语句;
} }
else .....
{ else(条件表达式)
执行语句; {
} 执行语句;
}
if语句有什么特点？
1.每一种格式都是单条语句。就是if开面的语句如果执行了，那这条语句就 结束了，也就是你无论是if也觉得那种结构，只执行里面的一句，要么if里面的，要么else if里面的，要么就是else里 面的
2.在一个if语句中，可以有多个else if语句， 但是只能有一个else语句。
3.条件表达式无论写成什么样子，最后只看表达式的结果是真还是假，如果 是真就执行与其对应{}里的执行语句。
4.if else 语句与三元运算符的区别是：三元运算符运算完要有一个结果，
例如：
b=(3>2)?100:200; 运算到最后一定要有个结果赋给b，
像这样既不行了：b=(3>2)?System.out.println("100");:200;
|--选择结构
switch语句(相当于在做选择题)
格式：
switch(表达式)//相当于选择题，看switch里表达式的值是什么，然后依次往 下读case语句
{
case 取值1: //
执行语句；
break；// break 跳出switch语句，如果这个case语句 //的值满足条件，break之后,就不读下面的语句了
case 取值2:
执行语句；
break；
…...
default: //如果都不满足，执行这条语句相当于else执行语句；
break; //最后这个break 可写可不写，因为break的作用就是跳
//出switch语句，都执行到大括号
//的最后了，你不写，这个switch语句也结束了
}
switch语句特点有哪些：
1.switch语句选择的类型只有四种：byte，short，int ，char。
2.case之间与default没有顺序。先执行第一个case，没有匹配的case执行 default。
3.结束switch语句的两种情况：遇到break，执行到switch语句结束。
4.如果匹配的case或者default没有对应的break，那么程序会继续向下执行， 运行可以执行的语句，直到遇到break或者switch结尾结束。
例如：
int x =3;
switch(x) //只能有四种类型，但是随着JDK版本的升级它能判断的类型也增加了
{
default:/default与case没有顺序，哪个放上面都无所谓，但是系统执行的时候，是从第一个case开始
System.out.println("a")
break;
case 3: //执行到这句的时候，发现这个case的值与表达式x的值相匹配，那么就会执行它下面的执行语句
System.out.println("b")
/ /break； 但是如果匹配的这个case下没有写break，那么这个switch语句不会结束，会接着往下读
case 2: //上面已经找到匹配的case了而没有break，再接着往下读的时候，就不再管case的值了直接愣着头往下找
System.out.println("c");//直到找到可执行的语句然后再接着往下找，直到碰到break跳出switch语句
break；
case 4:
System.out.println("c");
break
}
if语句和switch很像，但是什么时候用if什么时候用switch呢？
在运用过程中，如果要判断的具体数值不多而且又是byte，short，int，char里的一种，建议用switch；
因为效率稍微比if高点，其他情况如对区间进行判断，对结果是布尔型的进行判断建议使用if。
|--循环结构
循环语句的作用是反复执行一段代码，直到循环到条件不满足时为止，代表语句：while ， do while ， for (; ; )
循环语句的四个要素为？1.循环变量初始化，2.循环的条件 3.循环体 4.循环变量控制
|--while循环：
while循环格式
例：int x=5；//循环变量初始化
while（x>1）//是否要循环，要循环的条件
{
System.out.println("x="+x);//循环体，循环的时候要干什么事儿
x++；//循环变量的控制语句，这是个循环语句，就是系统读到大括号里面的最后的时候，会再返回去读
//while里面的循环变量是否满足条件，就像这个，如果不写x++的话，将会是一个死循环
}
使用while循环要注意哪些问题？
1.一定要记得在写循环体之后对循环变量进行处理
2.执行while循环语句的时候，首先要判断是否满足条件，只要满足循环的条件，则 执行循环体和循环变量控制，然后再去判断是否满足循环的条件.....以此类推，直 到条件不满足，结束循环。
3.如果说第一次判断就不满足条件的话，则循环体一次也不被执行。
|--do-while循环
do-while循环格式如下
例如： int x=5； //循环变量初始化
do
{
System.out.println("x="+x); //循环体
x++; //循环变量控制
}
while (x<3);//循环条件表达式
System.out.println("x="+x);
上面这条语句会输出x=5;和x=6;
使用do-while循环要注意?
1.使用do-while时，要注意它的书写格式，在while后面写分号，就像上面它是 一个整体，只不过是把循环条件
放下面了。
2.因为循环条件在下面，所以不管循环变量是否满足循环条件，do里面的的循环 体和循环变量控制也最少被执
行一次。
|--for循环
for循环格式如下
例如：for(int x=1(循环变量初始化);x<5(循环条件);x++(循环变量控制))
{
System.out.println("x="+x);//循环体
}
使用for循环是要注意的问题是？
1.在for(A:B:C){D}循环中，无论A是个数还是表达式，A都只执行一次,执行 顺序为ABDCBDCB...一直到B条件
不成立。因为A就是循环变量的初始化，既然是初始化，那就执行一次， B是要循环的条件，每次 循环
都要判断下，D是循 环体，C是循环变量控制，所以顺序是ABDC...
2.变量有自己的作用域，当循环变量x定义在for中，那么此变量只在for循 环中有效，for循环结束，x在内存
中的空间就被释放了。而while循环里的循环变量在循环之后还可以用， 参看例1
3.在for(A:B:C){D}循环中，ABC三个表达式都可以为空，但是分号不可以省 略，当三者都为空的时候，相当于
一个无限循环。最简单的两种死循环：while(true) for(;;)
4.在for循环中，变量的初始化部分和迭代部分可以使用逗号语句进行多个操 作,参照下面的例2
5.一个for循环里面还可以嵌套另一个for循环 如例3
例1： for(int i=0;i<5;i++) 例2: for(i=0,j=10;i
{ {
...... ......
} }
System.out.println(i);//超出循环体。非法
例3：for(int x=1;x<=9;x++)
{
for(int y=1;y<=x;y++)
{
System.out.print(y+"*"+x+"="+x*y+"\t");
}
System.out.println();
}
|--跳转语句
java语言提供了四种跳转语句：break，continue，return和throw，跳转语句的功能是改变程序的执行流程。
break(跳出)作用于分支结构(if、switch)和循环结构中，而 continue 仅作用于循环结构中
跳转语句有什么用？
在分支结构和循环结构中有时候需要提前继续或提前退出分支或循环结构，要实现这一功能就用到了break
和continue语句。
比如说，有一个语句要循环50次，如果说在某次的循环时执行到了break语句，那么整个循环就结束了。如果说
在某次循环体中执行到了continue，那么在本次循环中continue后面的语句将不被执行，直接进行下次循环。
使用跳转语句时应该注意的问题：
1. break语句后可以带标号也可以不带标号，break时跳出当前循环， 例1
2. continue只能作用于循环语句中，它也有两中形式可以带标号也可以不带标号r, 如例1
3. break和continue语句离开应用范围，存在是没有意义的，必须存在于分支或循环结构中。
4.break和continue语句单独存在时，下面不能有任何语句，因为执行不到 如例2
例1：w:for(int x=0;x<3;x++)
{
for (int y=0;y<3;y++ )
{
System.out.println("x="+x);
break w;//标号可带可不带，带的话就是跳出标号的循环，不带就是跳出当前循环
//continue w;
}
}
例2：
for (int y=0;y<3;y++ )
{
break; //这就属于单独存在，它下面是不允许有语句的
System.out.println("x="+x);//因为读到break就跳出循环了,本条 语句永远也不会被执行到
}
利用for循环语句的嵌套打印出乘法口诀表
class break1
{
public static void main(String[] args)
{
for(int i=1;i<=10;i++)//定义i与j的值必须在for循环里面，否则每次跳出循环重新 //执行就无法取值
{
for(int j=1;j<=10;j++)
{
if(j<=i)
System.out.print(j+"*"+i+"="+i*j+" ");//小注意:print()括号里面必须传递参数,println()无限制!
}
System.out.println();
}
}
}
1、什么是函数？
函数就是定义在类中具有特定功能的一段小程序，也叫做方法。
小知识：开发中我们在编写程序，其实就是在不断的实现功能，而java中最小的功能单元就是函数，所以我们在编程的时候尽可能的将一些功能通过函数的形式体现，这样不仅有利于阅读而且便于使用。
2、定义函数的格式?
修饰符 返回值类型 函数名称（参数类型 形式参数1，参数类型 形式参数2）
{
执行语句；
return 返回值；（谁调用返回给谁）
}
返回值类型：就是该方法运算结束后产生结果的数据类型。
参数类型：是形式参数的数据类型。
实际参数：是传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
注意：函数中只能调用函数，不可以在函数内部定义函数；
定义函数时，函数的结果应该返回给调用者，交由调用者处理；
函数无论放哪都可以，但是执行时要先从主函数开始执行
3、函数的特点
a：定义函数可以将功能代码进行封装
b：便于对该功能进行复用（多次调用）
c：函数只有被调用才会被执行
d：函数的出现提高了代码的复用性
e：对于函数没有具体返回值类型时，返回值类型用关键字void表示，那么该函数中的return语句如果 在最后一行可以省略不写
f：如果一个函数的返回值是void类型的，那么该方法不能再输出语句中打印，因为没有具体返回值 不清楚打印什么，到时候直接在主函数中调用即可
4、如何定义一个函数？
首先要明确两点 ：第一点 既然函数是一个独立的功能，那么该功能的运算结果是什么先明确（明确返回值类型）
第二点 再明确，在定义该功能的过程中是否需要那些未知内容参与运算（明确参数列表）
总而言之：就是明确该功能运算结束后产生的结果的数值类型再明确函数的参数列表
eg：class MethodDemo
{
public static void main(String[] args)
{
int num1 = add1();//返回值固定 扩展性差
int num2 = add2(3,4);//参与运算值由用户决定，扩展性强便于使用
}
//方法1 定义一个返回值是3加4的和，该方法不利于扩展不便于使用不能满足用户需求
public static int add1()
{
return 3+4;
}
//方法2 通过用户自己传递参数，大大提高了程序的扩展性而且便于调用
public static int add2(int x，int y)
{
return x+y;
}
}
5、函数的特性——重载（overload）
定义：重载就是在同一个类中 允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可
特点：与返回值类型无关，只看参数列表（构造函数就是一重载的形式体现的）
好处：方便于阅读，优化了程序设计
注：判断两个函数是否是以抽在的形式体现的就看它们的参数列表是否相同即可
6、什么时候用重载?
当定义的功能相同但是参与运算的未知内容不同，那么这时候就定义一个函数的名称以表示其该功能，方便阅读而通过参数列表的不同来区分多个同名函数。例如下面定义的两个方法 都是求和的功能，就是未知能容不固定通过重载的形式体现，方便了阅读。
eg： class overloadDemo
{
//定义一个两个整数相加的方法
int add（int x，int y）
{
return x+y；
}
//定义一个三个整数相加的方法
int add（int x，int y，int z）
{
return x+y+z；
}
}
7、函数练习
（1）通过函数定义一个方法打印矩形
package one;
public class print
{
public static void main(String[] args)
{
Print(9,9);
}
//需求：定义一个用*号打印矩形的功能
//思路：第一步明确返回值，没有返回值直接打印了 所以返回值类型是void
// 第二部明确参数列表，该功能需要传递两个int数据
// 通过两个明确该功能已经可以编写
public static void Print(int row,int col)
{
for(int x=0;x
{
for(int y=0;y
{
System.out.print("*");
}
System.out.println(); //打印完一行换行一次
}
}
}
（2）定义一个打印99乘法表的内容
package one;
public class printDemo {
public static void main(String[] args) {
print99();
}
//定义一个打印九九乘法表的功能
public static void print99()
{
for(int x=1;x<=9;x++)//x是行 y是列
{
for(int y=1;y<=x;y++)
{
System.out.print(y+"*"+x+"="+(y*x)+"\t");
}
System.out.println();
}
}
}
（3）判断给定函数与下列函数是否重载？
8、数组的概念、好处和格式
概念：数组是同一种类型数据的集合，其实就是一个容器（菜篮就是蔬菜不能装水果，果篮就只能装水果）。
好处：数组可以自动给数组中的元素从0开始编号，方便操作这些元素（好比宿舍楼里的宿舍从101到124编号一样）
格式1： 元素类型 [ ] 数组名 = new 元素类型 [元素个数或数组长度]
eg：int [ ] arr = new int [5]; //定义了一个可以存5个整形的数组、arr是引用数据类型即数组类型
格式2： 元素类型 [ ] 数组名 = new 元素类型 [ ] {元素1，元素2，元素3，元素4}
eg：//显示初始化
int [ ] arr = new int [ ] {3,4,6,7,8,8,9};
int [ ] arr = {4,5,6,7,8,9,9,7};
注：[ ]：中括号[ ]是用来标示数组的
new关键字：new一出现就会在内存中产生一个容器，用来存储许多数据的目的地，用new来完成。
9、内存结构（栈内存和堆内存）
Java在程序运行时，需要在内存中分配空间。为了提高效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据的方式和内存管理方式。内存可以划分为五个区域分别是：栈内存、堆内存、方法区、本地方法区和寄存器（好比房子中有卧室、有厨房、有卫生间功能各部相同）下面看一下栈内存和堆内存的作用：
栈内存是用于存储局部变量（方法中的变量、方法参数中的变量、for循环中的变量）的，当数据使用完，会自动释放
堆内存是用于存储数组和对象和通过new关键字建立的实例对象；
每一个实体在堆内存中都有内存地址值（好比门牌号）；
实体中的变量都有默认初始化值（int 为0、double为0.0、float为0.0f、boolean为false）；
实体不在被使用就是没有引用指向实体时，会在不确定时间被垃圾回收器回收；
10、数组在内存中的图例
int [ ] arr = new int [ 3];在内存中的图例
数组int [ ] arr = new int [3]；首先在栈内存中开辟一块空间用于存放arr变量，之后在内存中通过new关键字在最内存中建立了一个实体，堆内存为了标记这块空间给它分配了内存地址值，通过赋值把内存地址值赋值给arr，arr变量就指向了堆内存中的实体，也就是arr引用了内存地址值，所以说arr是引用数据类型。引用数据类型才能使用null常量，例如arr=null；意思是arr不在指向实体。
11、int [ ] arr = new int [3]; 打印arr[3]会报错吗？
该语句编译时期不会报错，因为编译时期只检查语法错误。但是在运行时期会报错，角标越界错误，因为arr数组是从0开始编号的所以只有arr[0],arr[1],arr[2]，没有arr[3]。
12、数组的一些操作？
（1）获取数组中的数据通常会用到遍历通过 for循环
（2）数组中有一个属性可直接获取数组元素的个数即 length
格式：数组名 . length
（3）但凡用到数组的情况下，大多都要用到for循环
eg：//需求：求给出数组中数据的和
//思路：通过for循环遍历数组进行累加
class ArrayDemo
{
public static void main(String[] args)
{
//定义一个数组并对其进行显示初始化
int[] arr = new int[]{3,4,5,6,7,8,9,7};
int sum = 0;
for (int x=0;x
{
sum += arr[x];
}
System.out.println("sum="+sum);
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
//打印数组中的数据并用逗号隔开
public static void pringtArray(int[] arr)
{
for (int x=0;x<=arr.length-1 ;x++ )//注意数组的最后一个角标数值是length-1
{
if(x!=arr.length-1)//length-1是数组的最后一个元素
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
System.out.println(); //打完一个数组换行一次
}
------------------------------------------------------------------------------------------------------------------------------------------------------------
public static int max(int[] arr)
{
int max = arr[0];
for (int x=0;x<=arr.length-1 ;x++ )
{ int temp=arr[x];
if(temp>max)
max=temp;
}
return max;
}
//需求：给定一个数组 获取数组中的最小值
public static int min(int[] arr)
{
int min = arr[0];
for (int x=0;x<=arr.length-1 ;x++ )
{ int temp=arr[x];
if(temp
min=temp;
}
return min;
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
13、数组——选择排序
选择排序图解
public static void selectSort(int[] arr)
{
//外循环控制第一个角标，内循环控制遍历
for (int x=0;x
{
for (int y=x+1;y
{
if(arr[x]>arr[y])//如果是降序将>换成<即可
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
14、数组——冒泡排序
冒泡排序图解
//冒泡排序
//相邻元素进行比较 如果符合条件就进行换位
//如果第一位的数据大于第二位置数据，就交换位置
public static void bubbleSort(int[] arr)
{
//第一圈 第二圈 剩最后一个元素时就不用参与比较所以length-1
for (int x=0;x
{
//第一圈循环完 最大的元素就能确定
//第二圈循环完 第二大元素就确定...直到结束
//所以每一圈循环结束后最后一个元素就不用参与比较所以length-x
for (int y=0;y
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
15、数组——折半查找
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (min+max)/2;
//定义一个循环 进行判断
while(key!=arr[mid])
{
if(key > arr[mid])
min = mid+1;
else if (key < arr[mid])
max = mid-1;
if(min>max) //最小的角标超过了最大的角标就意味没有找到指定元素
return -1;
mid=(min+max)/2;
}
return mid;
}
16、进制转换
进制转换-例：十进制-->十六进制
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for(int x=0; x<8; x++)//int型四个字节，每次右移四个二进制，最多八次
{
//求一个数的十六进制方法--"重复右移(四位)并&15"
int temp = num & 15;//把一个数二进制的后四位求出,并求出其对应的十六进制数
if(temp>9)//如果大于9求出对应的字符
sb.append((char)(temp-10+'A'));
else
sb.append(temp);
num = num >>> 4;//控制循环变量，没循环一次往右移四位
}
System.out.println(sb.reverse());
}
17、二维数组
理解：数组中的数组
一维数组好比大箱子里有格子每个格子里放的是元素；
二维数组好比大箱子里有小箱子每个小箱子里有格子；
格式：数据类型 [ ] [ ] 数组名称 = new 数据类型[二维数组的长度] [二维数组中每一个一维数组的长度]；
eg：int [ ] [ ] arr = new int [3] [3];//有三个一维数组每一个一维数组的长度是3；
eg：int [ ] [ ] arr = new int [3] [ ];//其中arr[0][ ] 的值是null
显示初始化：int [ ] [ ] arr = { {1,2,3,4},{4,5,6,7},{7,8,9,4},{4,5,4,3} };
注：二维数组的长度通过 arr.length获取 二维数组中一维数组的长度通过arr[0].length获取
内存中二维数组的图例
练习：求二维数组 int [ ] [ ] arr = { {1,2,3,4},{4,5,6,7},{7,8,9,4},{4,5,4,3} };中的所有数据的和 ？
public static int towArraySum(int[][] arr)
{
//大圈套小圈
int sum=0;
for (int x=0;x
{
for (int y =0;y
{
sum += arr[x][y];
}
}
return sum;
}
18、Arrays工具类中操作数组的一些静态方法
1、int binarySearch(type[] a, type key)
使用二分搜索法来搜索key元素在数组中的索引；若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。
2、int binarySearch(type[] a, int fromIndex, int toIndex, type key)
使用二分搜索法来搜索key元素在数组中从fromIndex到toIndex的索引；
若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。
3、boolean[] copyOf(type[] original, int newLength)
复制指定的数组
4、byte[] copyOfRange(type[] original, int from, int to)
将数组的指定范围复制到一个新数组。
5、 boolean equals(type[] a, type[] a2)
如果两个数组长度相等和元素一一相等，则返回 true
6、void fill(type[] a, type val)
将a数组所有元素都赋为val。
7、void fill(type[] a, int fromIndex, int toIndex, type val)
将a数组从formIndex 到tiondex索引之间的元素都赋为val
8、 void sort(type[] a)
sort(int[] arr)对指定的数组按数字升序进行排序
9、void sort(type[] a, int fromIndex, int toIndex)
对指定数组的从formIndex 到tiondex索引之间的元素按数字升序进行排序。
10、String toString(type[] a)
返回指定数组内容的字符串表示形式。多个数组元素之间用英文逗号或空格隔开。