一、java概述：
1991年Sun公司的James Gosling等人开始开发名称为Oak的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器，1994年将Oak语言更名为Java。
Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。是一门简单易学，完全面向对象，安全可靠，与平台无关的编程语言。
1、Java的三种技术架构:
J2EE(Java 2 Platform EnterpriseEdition)企业版
开发企业环境下的应用程序，主要针对web程序开发；
J2SE（Java 2 Platform Standard Edition）标准版
完成桌面应用程序的开发，是其它两者的基础；
J2ME(Java 2 Platform MicroEdition)小型版
开发电子消费产品和嵌入式设备，如手机中的程序；
2、JDK、JRE和JVM
JDK：是Java Development Kit的简称，java的开发和运行环境，包含了java的开发工具和jre。
JRE：是Java Runtime Environment的简称，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。
JVM：是JavaVirtual Machine 的简称，也称作虚拟机。它是运行所有Java程序的抽象计算机, JVM读取并处理编译过的与平台无关的字节码(class)文件。
Java编译器针对JVM产生class文件，因此是独立于平台的。
Java解释器负责将JVM的代码在特定的平台上运行。
Java虚拟机是不跨平台的.
3、配置环境变量：
让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。
1）环境变量的配置：
永久配置方式：JAVA_HOME=%安装路径%\Java\jdk
path=%JAVA_HOME%\bin
临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin
特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。
2）classpath的配置:
永久配置方式：classpath=.;c:\;e:\
临时配置方式：set classpath=.;c:\;e:\
注意：在定义classpath环境变量时，需要注意的情况
1、如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；
2、如果指定了classpath，那么会在指定的目录下查找要运行的类文件。并且：
1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。
2）：如果classpath的值结尾处没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。
一般情况下不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。
二、java语法基础：
关键字：其实就是某种语言赋予了特殊含义的单词。
保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。
1、Java标示符：
可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法变量名等。
命名规则：
(1)由字母、数字、下划线、$组成，不能以数字开头
注意:此处的字母还可以是中文,日文等;
(2)大小写敏感
(3)不得使用java中的关键字和保留字
(4)别用Java API里面的类名作为自己的类名。
2、Java中的常量与变量
1）常量：是在程序中的不会变化的数据。
2）变量：其实就是内存中的一个存储空间，用于存储常量数据。
作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
3、数据类型：
1）：基本数据类型：byte、short、int、long、float、double、char、boolean
2）：引用数据类型: 数组、类、接口。
级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；
4、运算符号：
1）算术运算符：+ - * /
%:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。
+:连接符。
++,--自增，自减
2）赋值运算符。
= += -= *= /= %=
3）比较运算符。
特点：该运算符的特点是：运算完的结果，要么是true，要么是false。
4）逻辑运算符。
& | ^ ! && ||
逻辑运算符除了! 外都是用于连接两个boolean类型表达式。
&: 只有两边都为true结果是true。否则就是false。
|:只要两边都为false结果是false，否则就是true
^:异或：和或有点不一样。两边结果一样，就为false，两边结果不一样，就为true.
& 和 &&区别：&无论左边结果是什么，右边都参与运算。
&&:短路与，如果左边为false，那么右边不参数与运算。
| 和|| 区别： | 两边都运算。
||短路或，如果左边为true，那么右边不参与运算。
5）位运算符:用于操作二进制位的运算符。
& | ^
<< >> >>>(无符号右移)
5、程序控制语句。
1）if语句:
基本语法:if(表达式){方法体}else if(表达式){方法体}else(方法体)
几种形式:
三种格式：
if(条件表达式){执行语句；}
if(条件表达式){执行语句；}else{执行语句；}
if(条件表达式){执行语句；}else if (条件表达式){执行语句；}……else{执行语句；}
public class If3
{
publicstatic void main(String args[])
{
inti = 3;
if(i > 5)
{
System.out.println("变量i大于5");
}
elseif (i > 4)
{
System.out.println("变量i小于4");
}
else
{
System.out.println("其他");
}
}
}
2）switch控制语句
格式：
switch(表达式)
{
case表达式可能的结果值1:
执行语句；
break；
case表达式可能的结果值2:
执行语句；
break；
...
default:
执行语句；
break；//最后这个一般不写
}
备注：
case之间与default没有顺序。先执行第一个case，都没有匹配的case值执行default。
结束switch语句的两种情况：遇到break，switch语句执行结束。
如果匹配的case或者default没有对应的break，那么程序会从第一次匹配的case语句开始继续向下执行，运行可以执行的语句，直到遇到break或者switch结束为止。
class switch2
{
publicstatic void main(String[] args)
{
inta = 7,b = 5;
switch(a-b)
{
case3://表达式可能的值；
{
System.out.println("33!");
}
break;
case4:
{
System.out.println("44!");
}
break;
default://都没有执行则执行该语句!
System.out.println("其它的");
}
}
}
6、循环结构
1）while语句
格式：
while(条件表达式值为true)
{
执行语句；
}
2）do while语句
格式：
do
{
执行语句；
}
while(条件表达式值为true);
3）for语句
格式：
for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)
{
执行语句；（4）
}
执行顺序：(1) →(2) → (4) → (3) → (2) → (4) → (3)
7、函数：
1）函数也称为方法，为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数有以下功能：
结构化代码
将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。
减少代码重复
一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。
2）java中的函数的定义格式：
[修饰符] 返回值类型 方法名([参数类型 形式参数1，参数类型 形式参数2，……])
{
执行语句; [return 返回值;]//需要的话
}
参数列表（参数的类型，参数的个数，参数的顺序）
当函数没有具体的返回值时，返回的返回值类型用void关键字表示。
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。
return的作用：结束函数。结束功能。
3）函数的重载的
定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。
8、数组：
1）数组(Array)是Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化代码的书写。
数组的好处：数组里的每个元素都有编号，编号从0开始，并且依次递增，方便操作这些元素；
使用Java数组：必须先声明数组，再给该数组分配内存；
数组对应在内存中一段连续空间。
数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。
2）数组的声明
一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；
一维数组的声明方式：
type varName[]; 或 type[] varName;(推荐)
3）数组初始化：
Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；
数组初始化的两种方式：
静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；
格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};
简化语法：数组名 = {元素1,元素2,元素3...元素n};
动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；
格式：数组名 = new 数组类型[数组长度];
4）二维数组
二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),
可以看做是一张表格。
二维数组的声明方式：
typevarName[][]; 或 type[][] varName;(推荐)
动态初始化
int[ ][ ] arr = newint[3][2];
定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素
静态初始化
int[ ][ ] arr = new int[][]{{1,2},{3,4},{5,6}};
int[ ][ ] arr ={{1,2},{3,4},{5,6}};
9、排序算法
1）选择排序：
//选择排序
//对给定数组进行排序
//｛5，1，6，4，2，8，9｝从小到大
class Shuzu2
{
//定义一个函数，让一个数组的0角标位与后面的元素依次比较
//若0角标的元素小，则两元素不变，否则两元素对换
public static int[] paiXu(int [] Shuzu)
{
//用一个外循环控制每次用哪个角标与后面的元素进行比较
for (intb=0;b<Shuzu.length ;b++ )
{
//用一个内循环使选定的元素与它后面的每个元素进行比较换位
for (inta=b+1;a<Shuzu.length ;a++ )
{
if(Shuzu[b]>Shuzu[a])
{
//元素对换语句
intx=Shuzu[b];
Shuzu[b]=Shuzu[a];
Shuzu[a]=x;
}
}
}
return Shuzu;
}
public static void main(String[] args)
{
int [] Shuzu=new int[]{5,1,6,4,2,8,52,51,23,7,11,26,9};
arrayPos(Shuzu);
arrayPos(paiXu(Shuzu));//打印排序后的数组数组
}
//定义一个打印数组的方法
public static void arrayPos(int [] al)
{
System.out.print("[");
for(intx=0;x<al.length;x++)
{
if (x!=al.length-1)
System.out.print(al[x]+",");
else
System.out.println(al[x]+"]");
}
}
}
2）冒泡排序
/*
1、从头开始每相邻两个比较一次，大的往后拿
3 5 1 4 9 8 6 2
3跟5比，5大，位置不变
5跟1比，5大，对换--- 3 1 5 4 9 8 6 2
5跟4比，5大，对换--- 3 1 4 5 9 8 6 2
5跟9比，9大，不变--- 3 1 4 5 9 8 6 2
9跟8比，9大，对换---
.
.
. 3 1 4 5 8 6 2 9
一次遍历后，最大值在最右边
2、再次从头开始比较，但是最后一位不用在比较了，因为是最大值了
3、以此类推，需要比较的数一次比一次少
*/
class Maopao
{
public static void maoPao(int[]Shuzu)
{
for (int x=0;x<Shuzu.length ;x++ )
{
for(inty=0;y<Shuzu.length-x-1;y++)
//-x:让每一次比较的元素减少，-1：避免角标越界
if (Shuzu[y]>Shuzu[y+1])
{
int temp =Shuzu[y];
Shuzu[y]=Shuzu[y+1];
Shuzu[y+1]=temp;
}
}
}
public static void main(String[] args)
{
int [] Shuzu = new int[]{5,1,6,4,2,8,9};
dayinShuzu(Shuzu);//打印排序前的数组
maoPao(Shuzu);//排序操作
dayinShuzu(Shuzu);//打印排序后的数组
}
//定义一个打印数组的方法
public static void dayinShuzu(int [] Shuzu)
{
System.out.print("[");
for(int x=0;x<Shuzu.length;x++)
{
if (x!=Shuzu.length-1)
System.out.print(Shuzu[x]+",");
else
System.out.println(Shuzu[x]+"]");
}
return;
}
}
3）快速排序
classQuickSort
{
public static void main(String[] args)
{
int [] x = newint[]{16,54,5,61,12,31,25,11,76,22,10};
for (int i=0;i<x.length ;i++ )
{
System.out.print(x[i]+"");
}
System.out.println();
quickSort(x,0,x.length-1);
for (int i=0;i<x.length ;i++ )
{
System.out.print(x[i]+"");
}
}
private static void quickSort(int[] arr, intleft, int right) {
int l,r; //左右哨兵，l为左哨兵位置，r为右哨兵位置
int baseNum; //存储基准数
if(left > right)
return;
baseNum = arr[left]; //第一次基准数默认为数组首位
l = left; //左哨兵从左边出发扫描
r = right; //右哨兵从右边出发扫描
while(l != r) {
//先从右边开始往左扫描,找到第一个比基准数小的
while(arr[r] >= baseNum&& l < r)
r--;
//再从左边开始往右扫描,找到第一个比基准数大的
while(arr[l] <=baseNum && l < r)
l++;
//交换两个数位置
if(l < r) {
int temp =arr[l];
arr[l] =arr[r];
arr[r] = temp;
}
}
//基准数归位
arr[left] = arr[l];
arr[l] = baseNum;
//递归处理左边
quickSort(arr, left, l - 1);
//递归处理右边
quickSort(arr, l + 1, right);
}
}
扫一扫
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
