---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
一、 Java概述：
1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言更名为Java；
Java的三种技术构架：
JavaEE ： Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；
JavaSE ： Java Platform Standard Edition，完成桌面应用程序的开发，是其他两者的基础；
JavaME ：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的应用程序
1. JDK: Java Development Kit，Java的开发和运行环境，java的开发工具和jre.
2. JRE: Java Runtime Environment,Java 程序的运行环境,java运行所需的类库+JVM(Java Virtual Machine)
3. 配置环境变量:让java jdk\bin目录下的工具,可以在任意目录下运行,原因是将该工具所在的目录告诉了系统,当使用该工具时,有系统帮我们去找制定的目录.
4. Java语言特点:
1. 跨平台:通过Java语言编写的应用程序在不同的系统平台上都可以运行;
2. 原理:只要在需要运行Java应用程序的操作系统上安装一个Java虚拟机即可,然后由JVM来负责Java程序在该系统中运行.
5. Java中常用DOS命令:
dir:列出当前目录下的文件以及文件夹。
md:创建目录
rd:删除目录
cd :进入指定目录
cd..:退回到上一级目录
cd/:退回到更目录
del:删除文件
exit：退出dos命令行
cls:清除当天屏幕内容
start:在当前DOS命令窗口的属性基础上，新建一个DOS命令窗口
6.系统变量的配置:
1). 永久配置方式:
(1)打开环境变量(Win7)配置窗口：
计算机-->属性-->高级系统设置-->环境变量-->系统变量
(2)打开开发工具JDK中的bin目录，将复制到的bin目录粘贴到系统变量path的最前面，例如：D:\ProgramFiles\Java\jdk1.7.0_09\bin，当然，为了方便使用，需要在bin目录后添加一个分号，避免导致计算机其他程序无法正常运行；
(3)为了安全和方便维护，可事先新建一个环境变量：JAVA_HOME，即将bin目录之前的路径封装到这个JAVA_HOME环境变量中，方便java程序的运行，例如：
变量名：JAVA_HOME
变量值：D:\ProgramFiles\Java\jdk1.7.0_09
然后再讲封装好的JAVA_HOME配置到path环境目录下，例如：
变量名：%JAVA_HOME%\bin;
备注：%%表示动态获取某一个环境变量的值
2).临时配置方式:
(1)set可以用于查看或者设置环境变量的值
例如：set path --> set path=%path%
(2)set path配置的环境变量只在当前dos窗口有效
set path=D:\ProgramFiles\Java\jdk1.6.0_23\bin
注意:系统默认先去当前路径下找要执行的程序,如果没有,再去path路径中设置的路径下找
3).classpath的配置:
(1)永久配置方式:classpath = .;c:\;d:\
(2)临时配置方式:set classpath = .;c:\;d:\
在定义classpath环境变量时,需要注意的情况:
1.如果没有定义环境变量classpath,java启动jvm(虚拟机)后,会在当前目录下查找要运行的类文件;如果指定了classpath,那么会在指定的目录下查找要运行的类文件.
2.其中,classpath配置路径的.的问题:
1).如果classpath的值结尾处有分号,在具体路径中没有找到运行的类,jvm会默认在当前目录下再找一次;
2).如果classpath的值结尾没有分号,在具体的路径中没有找到运行的类,那么jvm则不会在当前路径找查找
一般不指定分号,如果没有在指定目录下找到要运行的类文件,就报错,这样方便于调试程序.
4).path与classpath区别:
(1).path变量是windows程序文件的目录(exe,bat等),现在当前目录找,找不到就到path路径里去找,如果还是找不到就会报错.
(2).classpath变量值是java类文件(xxx.class文件)的目录
7.javac命令和java命令分别作什么事?
要知道java是分两个部分的:一个是编译,一个是运行.
Javac:负责的是编译部分,当执行javac时,系统会启动java的编译器程序.对指定扩展名为.java文件进行编译.生成jvm可识别的字节码文件,即.class文件,也就是java的运行程序.
Java:负责运行的部分,会启动jvm加载运行时所需的类库,并对class文件进行执行,其中,一个.字节码文件要被执行,必须要有一个执行的起始点,这个起始点就是main主函数.
二、 Java语法基础
1，关键字：其实就是某种语言赋予了特殊含义的单词；
保留字：其实就是还没有富裕特殊含义，但是准备为日后要使用的单词。
2，标识符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。
命名规则：
1)由26个英文字母的大小写，数字0-9，_和$等符号组成
2)不能以数字开头
3)不能与java的关键字重名
其中，
包：所有单词小写。
类和接口：
如果是由一个单词组成，那么单词首字母大写；
如果是由多个单词组成，第一个单词首字母大写，其后每个单词首字母也大写。
变量和方法：
如果是有一个单词组成，那么单词首字母小写；
如果是由多个单词组成，第一个单词首字母小写，其后每个单词首字母大写。
常量：
如果是一个单词组成，那么所有单词全部大写；
如果是由多个单词组成，每个单词大写，并且以下划线相连接。
3，常量：是在程序中不会变化的数据。
4，变量：其实就是内存中的一个存储空间，用于存储常量数据。
作用：方便于运算，因为有些数据不确定，所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
什么时候定义变量？ 只要是数据不确定的时候，就定义变量。
变量空间的开辟需要什么要素呢？
1. 这个空间要存储什么数据？数据类型
2. 这个空间叫什么名字？ 变量名称
3. 这个空间的第一次数据是什么？ 变量的初始化值
变量的作用域和生命周期：
变量的作用域：
作用域从变量定义的位置开始，到该变量所在的那对大括号结束；
变量的生命周期：
变量从定义的位置开始就在内存中活了，当变量到达它所在的作用域结尾的时候就在内存中释放了。
5，数据类型：
1. 基本数据类型：byte、short、int、long、float、double、char、boolean
1.byte、char和boolean均占1个字节，而一个字节分八位
2.short占2个字节，int占4字节，long占8字节
3.boolean的值只能是true或者是false
4.float单精度4个字节、double双精度8个字节
5.byte范围：-128-127，short范围：-32768-32767，char范围：0-65535
2. 引用数据类型：数组、类和接口。
级别从低到高为：byte,char,short(这三个平级) -->int -->float -->long-->double
自动类型转换：从低级别到高级别，系统自动转换；
强制类型转换：什么情况下使用？把一个高级别的数赋给一个该级别数的级别低的变量；
6，运算符：
1)、算术运算符
+ - * / % 其中，%：任何数%2不是0就是1，所以只要改变被%数就可以实现开关运算。
+：连接符。
++ --自增自减运算符
2)、赋值运算符
= += -= *= /= %=
3)、比较运算符
== !=< > >= <=
特点：运算完的结果是一个boolean类型的数据，即要么是true，要么是false,其中instanceof检查是否是类的对象，例如：”Hello” instanceof String
4)、逻辑运算符
& | ^ ! && ||
逻辑运算符除了!外都是用于连接两个boolean类型的表达式
&：只有两边都为true，结果就是true，否则为false
|：只有两边都为false，记过就是false，否则就是true
^:异或和或有点不一样，当两边结果一样就会false，两边结果不一样就为true
&和&&区别：
&：无论左边结果是什么，右边都参与运算；
&&：短路与，如果左边为false，那么右边不参与运算。
|和||区别：
|：无论左边结果是什么，两边都参与运算
||：短语或，如果左边为true，那么右边不参与运算。
5)、位运算符：用于操作二进制位的运算符
& | ^和<< >> 还有>>>(无符号右移)
6)、三元运算符
1.格式：(条件表达式) ? 表达式1 : 表达式2;
若条件为true，则运算结果为表达式1,；若条件为false，则运算结果为表达式2
2.示例：获取两个数中的大数
int x=3,y=4,z;
z = (x > y) ? x : y;//z变量存储的就是两个数中的大数
7)、常用交换两个元素值的方法
1.通过第三方变量
int n=3,m=8;
int temp = n;
n = m;
m = temp;
2.不用第三方变量
n = n + m;
m = n – m;
n = n – m;
3.异或^
n = n ^ m;
m = n ^ m;
n = n ^ m;
7，程序流程控制语句
程序流程控制语句有三种结构，分别是：判断结构、选择结构和循环结构
1. if语句
格式一：
if(条件表达式){执行语句;}
格式二：
if(条件表达式){
执行语句;
}else{
执行语句;
}
格式三：
if(条件表达式){
执行语句;
}else if(条件表达式){
执行语句;
}
…
else{
执行语句;
}
如果if语句中只有一个执行语句，那么那个大括号可以省略不写
2. switch语句
格式：
switch(表达式){
case 取值1：
执行语句;
break;
case 取值2：
执行语句;
break;
…
default :
执行语句;
break;
}
switch语句特点：
1) switch语句选择的类型有一下几种：byte，short，int，char，而JDK1.7新特性中加入了String类型的数据；
2) case之间与default没有顺序，先执行第一个case，没有匹配的case则执行default。
3) 结束switch语句有两种情况：遇到break和执行到switch语句结尾。
4) 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束
注意：由于最后一个default钟的break到了语句最后，因此可以省略break不写。
if 和switch语句很想，具体什么场景下，应用哪个语句呢？
如果判断的具体数值不多，而且符合byte，short,int,char和String这几种类型，那么建议使用switch语句；虽然两种语句都能使用，但switch效率更高。其他情况：对于区间判断，对结果为boolean类型的判断，使用if，因为if的使用范围更广。
3．while语句
格式一：
while(条件表达式){
循环体(执行语句);
}
特点：先判断条件，只有条件满足才会执行作用域里的循环体；
格式二：
do {
执行语句;
}
while(条件表达式);
特点：无论条件表达式是否成立，作用域中的执行语句至少执行一次，然后再来判断条件表达式是否成立，条件满足，在继续执行循环体；
注意：do while语句的while后面需要加分号，而while后加分号后则不会执行循环体
4．for语句
for(初始化表达式1; 循环条件表达式2; 循环条件表达式4){
执行语句3;
}
特点：
1) for里面的表达式运行的顺序，初始化表达式1只读一次，判断循环条件2，为真就执行循环体3，然后在执行循环后的操作表达式4，接着继续判断循环条件，重复这个过程，直到条件不满足为止；
2) while和for可以进行互换，区别在于：如果需要定义变量控制循环次数，建议使用for，因为for循环完毕，变量会在内存中释放。
4．break和continue
1)break:作用于switch和循环语句，用于调出循环或者结束程序；当break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break值调出当前嵌套中的外部循环，只要给循环命名即可，这个名字称之为标号。
2)continue:只作用于循环结构，继续循环用得；特点就是结束本次循环，继续下次循环，该语句单独存在时，下面不可以定义语句，因为执行不到。
颇具代表性的代码演示：
1. 输出一个99乘法表
class Print99 {
public static voidmain(String[] args) {
print99();
}
//定义一个99乘法表函数
public static voidprint99(){
for(int i=1;i<=9; i++){//外循环控制行
for(int j=1;j<=i;j++){//内循环控制列
System.out.print(j+ "*" + i + "=" + j*i + '\t');//\t:表示制表符，可以让输出的语句更美观
}
System.out.println();
}
}
}
2. 输出一个*号三角形
class Demo2 {
public static voidmain(String[] args) {
method();
}
//定义一个method方法
public static voidmethod(){
for(int i=0;i<=5; i++){//外循环控制行，内循环控制列
for(int j=i;j<=5; j++){
System.out.print("");
}
for(int k=0;k<=i; k++){
System.out.print("*");
}
System.out.println();
}
}
}
小结：
1. 外循环控制行数，内循环控制列数；
2. 输出图形的尖朝上，改变内循环条件，让条件随着外循环变化而变化；
3. 输出图形的尖朝下，改变内循环的初始值，让初始值随外循环的变化而变化
8，函数
1、函数
(1) 函数就是定义在类中具有特定功能的一段独立小程序，函数也成为方法
(2) 函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2, …){
执行语句;
return 返回值；
}
返回值类型：函数运行后结果的数据类型。
参数类型：是形式参数的数据类型。
主函数main：
1) 保证该类的独立运行；
2) 因为它是程序的入口
3) 因为它在被jvm所调用
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算后的结果，该结果会返回给调用者。
(3) 函数的特点：
1) 一般函数只有被调用后，才执行。
2) void表示没有返回，在这个函数的结尾可以不写return，其实jvm会自动在结尾处加上一句隐式的return语句；
(4) 如何定义一个函数？两个明确
1) 明确该功能的结果，其实就是该功能的返回值类型
2) 明确该功能的参数，其实就是明确该功能中是否需要未知内容(形式参数)参与运算，明确位置内容的类型和个数
(5) 函数的重载(overload):重载只和参数列表有关
1) 函数名相同，参数列表不同
参数类型不同：int add(int i); void add(idouble d)
参数个数不同：add(int a,int b); add(int a,int b, int c);
参数顺序不同
2) 特点：与返回值类型无关，只看参数列表，且只存在于同一个类中
3) 好处：便于阅读，优化程序设计
2、数组
(1) 数组的定义
概念：同一种类型数据的集合，其实数组就是一个容器。
好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
一维数组：
格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] x = newint[3];其中x为引用数据类型
格式2：元素类型[] 数组名 = new 元素类型[]{元素,元素，…};
int[] arr = new int[]{1,2,3,4,5};
int[] arr ={1,2,3,4,5};
二维数组：
格式1：int[][] arr = newint[3][];
1) 定义了名称为arr的二维数组
2) 二维数组中有3个一维数组
3) 每一个一维数组中有2个元素
4) 一维数组的名称分别为arr[0],arr[1],ar[2]
5) 给第一个一维数组1角标赋值为78的写法是：int[0][1] = 78;
格式2：int[][] arr = newint[3][]; int[] arr[] = newint[3][];
1) 二维数组中有3个一维数组
2) 每个一维数组都是默认初始化值为null
3) 可以对这个三个一维数组分别初始化
格式3：int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
静态初始化：初始化时有程序员显示指定每个数组元素的初始值，由系统决定数组长度。
动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
(2) 内存结构
Java程序在运行时，需要在内存中分配空间。为了提高程序效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。其中内存那种一共分配了五个区域，分别是：栈内存、堆内存、方法区、本地方法区和寄存器
栈：存储的都是局部变量(函数中定义的变量，函数上的参数，语句中的变量);只要数据运算完成所在的区域结束，该数据就会弹栈，即消失。
堆：用于存储数组和对象，也就是实体。什么事实体呢？就是用于封装多个数据的。
1) 每一个实体都有内存首地址值；
2) 堆内存中的变量都有默认初始化值，因为数据类型不同，值也不一样
3) 垃圾回收机制
简而言之就是：栈内存里的数据在被使用完成后会被自动释放；而堆内存中的数据则是通过垃圾回收器进行随机回收。
颇具代表性的代码演示：
1. 遍历数组
class ArrayDemo {
public static voidmain(String[] args) {
//定义一个数组
int[] arr ={3,6,4,1,9,6,0};
//调用遍历方法
printArray(arr);
}
//定义一个遍历数组的方法
public static voidprintArray(int[] arr){
//为了让输出格式更美观，这里有必要输出一个[
System.out.print("[");
for(int j=0;j<arr.length; j++){
if(j !=arr.length -1)//只要j不是数组中最后一个元素
System.out.print(arr[j]+ ",");
else
System.out.println(arr[j]+ "]");
}
}
}
2. 获取最值
class ArrayDemo1 {
public static voidmain(String[] args) {
int[] arr ={5,1,6,4,2,8,9};
//System.out.println("max="+getMax(arr));
System.out.println("max="+getMax2(arr));
}
//定义一个获取最大值的方法
public static intgetMax(int[] arr){
//定义一个max变量，用于记录数组中第一个元素，即arr[0]
int max = arr[0];
for(int i=0;i<arr.length; i++){
if(arr[i]> max)
max =arr[i];//将较大的那个数赋值给max
}
return max;
}
//获取最值的第二种方法
public static intgetMax2(int[] arr){
//定义一个max变量，用于记录数组中的第一个角标
int max = 0;
for(int i=1;i<arr.length; i++){
if(arr[i]> arr[max])
max =i;
}
return arr[max];
}
}
3. 常见排序方法
class ArrayDemo2 {
public static voidmain(String[] args) {
int[] arr = {3,5,1,6,4,7,2,8,9};
//选择排序法
//selectSort(arr);
//冒泡排序法
bubbleSort(arr);
//排序
sop(arr);
}
//冒泡排序法
public static voidbubbleSort(int[] arr){
for(int i=0;i<arr.length-1; i++){//为了提高比较效率，这里需要让其长度-1
for(int j=0;j<arr.length-1-i; j++){//-1:避免角标越界；-x:让每一次比较的元素逐渐减少
if(arr[j]> arr[j+1])
swap(arr,j,j+1);
}
}
}
//选择排序法
public static voidselectSort(int[] arr){
for(int i=0;i<arr.length-1; i++){//由于不需要比较到最后一个元素，因此这里可以将其长度-1，继而提高效率
for(intj=i+1; j<arr.length; j++){
if(arr[i]> arr[j]){
swap(arr,i,j);
}
}
}
}
//定义一个对数组进行排序的方法
public static voidsop(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]+ "]");
}
System.out.println();
}
//定义一个交换元素值的方法，通过定义第三方变量的方法
public static voidswap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}小结：
1. 选择排序：头元素与后面的元素一一比较，也就是内循环结束一次，最值出现在头角标位置上；接着头元素自增，循环与后面的元素进行比较，即可得到排序结果。
2. 冒泡排序：相邻的两个元素进行比较，如果符合条件就换位。
大圈套小圈，尖朝上，改变内循环条件；尖朝下，改变内循环初始值。
4. 数组的查找操作：折半查找
class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = {3,4,5,6,7,8,9};
//System.out.println(getIndex(arr,8));
//System.out.println(halfSearch(arr,8));
System.out.println(halfSearch2(arr,8));
}
//获取插入点角标
public static int getIndex(int[] arr,int key){
for(int i=0; i<arr.length; i++){
if(key == arr[i])
return i;
}
return -1;
}
//折半查找
public static int halfSearch(int[] arr,int key){
int min=0;//定义其数组索引的最小值
int max = arr.length-1;//定义索引的最大值
int mid = (min + max) >>> 1;//定义该数组的中间值,这是效率最高的一种除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) >>> 1;//如果条件不成立，让其中间值再除了2一次
}
return mid;
}
//折半查找的第二种方式
public static int halfSearch2(int[] arr,int key){
int min=0;
int max= arr.length-1;
int mid = (min + max) >>> 1;
//如果最小角标一直小于或等于最大角标，则进行判断，否则该数组中没有这个数
while(min <= max){
if(key > arr[mid])
min = mid + 1;
else if(key< arr[mid])
max = mid -1;
else
return mid;
mid = (min + max) >>> 1;
}
return -1;
}
}5. 进制转换
class ArrayDemo4 {
public static voidmain(String[] args) {
toHex(60);
}
//十进制-->十六进制
public static voidtoHex(int num){
//定义一个容器，用于存储数据
StringBuffer sb =new StringBuffer();
for(int x=0; x<8;x++){//由于取的是最低4位，而在十六进制中有4组八位，因此这里的x<8
int temp =num & 15;//之所以num&15,是为了得到其最低4位
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;//无符号往右移4位
}
System.out.println(sb.reverse());
}
}class ArrayDemo5 {
public static voidmain(String[] args) {
//toBin(6);
//toBa(60);
toHex(60);
}
//十进制-->二进制
public static voidtoBin(int num){
trans(num,1,1);
}
//十进制-->八进制
public static void toBa(intnum){
trans(num,7,3);
}
//十进制-->十六进制
public static voidtoHex(int num){
trans(num,15,4);
}
public static voidtrans(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 = newchar[32];//由于int的最大范围为32位，因此这里就定义最大区间
int pos =arr.length;
while(num!=0){
int temp =num & base;
arr[--pos] =chs[temp];
num = num>>> offset;
}
//直接将pos的值赋值给x
for(int x = pos;x<arr.length; x++){
System.out.print(arr[x]);
}
}
}---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
4701
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
