一，Java语言概述
1.JDK,JRE,JVM三者之间的关系，以及JDK、JRE包含的主要结构有哪些
JDK = JRE + Java的开发工具（javac.exe,java.exe,javadoc.exe） JRD = JVM + Java核心类库
2.掌握常用的DOS命令
| DIR | 显示该目录下所有的文件和文件夹 |
|---|---|
| cd .. | 到上一级目录 |
| cd 文件夹名字 | 进入某个文件夹 |
| cd \ | 直接到根目录 C:\ D:\ |
| cls | 清空屏幕 |
| C: 回车 D: 回车 | 切换盘符 |
| ping 网址或者IP地址 | 查看网络是否连通 |
| ipconfig -all | 查看所有网络硬件设备 |
3.Java语言自身的特点
-
面向对象 (面向过程 --> 面向对象)
-
跨平台
-
分布式
-
多线程
-
健壮性
-
优雅
-
标准
4.编译并运行Java程序
Javac.exe负责编译；【编译 -- 将源代码 编译转换成 电脑能够识别的二进制代码】
Java.exe负责运行（翻译）；【有一个中间软件,将源代码直接翻译成软件能够识别的内容,就能直接运行】
Java -- 编译翻译语言,先将源代码编译成字节码,然后字节码再在虚拟机中被翻译成当前系统能够识别的内容
二，Java基本语法
1.Java的基本结构
1.1 建立一个类
【java所有的代码,都必须在一个类里面,必须先建一个类,注意文件名也必须和类名一致】
public class 类名{
代码要写在{}里面
}
1.2 建立程序的入口函数main函数
【没有main函数,程序是不能启动的】
public class 类名{
public static void main(String [] args){
程序的入口
}
}
1.3 打印语句（输出语句）
就是输出打印语句话到dos命令行窗口中
System.out.println("Hello World");
注意:中文除了在打印语句中 ""中可以出现之外,在其他的任何地方不能出现中文,包括标点符号
1.4输入语句
//1.声明Scanner 变量 Scanner input = new Scanner(System.in); //2.在类名的上边,引入Scanner所在的位置(包) import java.util.Scanner; //3.使用 input.nextXXX(); //获取用户输入的int的值 //input.nextInt(); //获取用户输入的double的值 //input.nextDouble(); //获取用户输入的float的值 //input.nextFloat(); //获取用户输入的String的值 //input.next(); 当然,获取了之后,我们一般情况下都会将用户输入的值,放入到一个变量当中保存
2.变量
1.变量的表达式
| INT COUNT = 10; |
|---|
| 关键字 变量名(标识符) 运算符 字面量(直接量) 符号； |
2.标识符的命名规范
2.1.标识符只能出现字母,数字,下划线和$
2.2.标识符的首位不能是数字
2.3.标识符不能是关键字
2.4.标识符最好遵循驼峰规则--如果标识符有多个单词组成
包名:xxxyyyzzz
类名、接口名：XxxYyyZzz
变量名、方法名：xxxYyyZzz
常量名：XXX_YYY_ZZZ
3.变量的数据类型
| 数据类别 | 具体的数据类型 |
|---|---|
| 整型 | byte short int long |
| 浮点型 | float double |
| 字符型 | char |
| 布尔型 | boolean |
| 整数类型 | 占用储存空间 | 表数范围 |
|---|---|---|
| byte | 1字节=8bit | -128~127 |
| short | 2字节 | -2的15次方~2的15次方-1 |
| int | 4字节 | -2的31次方~2的31次方-1（约21亿） |
| long | 8字节 | -2的63次方~2的63次方-1 |
| 浮点数类型 | 占用储存空间 | 表数范围 |
|---|---|---|
| 单精度float | 4字节 | -3.403E38~3.403E38 |
| 双精度double | 8字节 | -1.789E308~1.789E308 |
3.算数运算符
| + | 加法 |
|---|---|
| - | 减法 |
| * | 乘法 |
| / | 除法 |
| % | 取余(求模) |
注意：除法的时候除数不能为0
int a = 10; int b = 0; int c = a / b; System.out.println(c);
3.1.浮点数运算是一个近似值
3.2.整和整数做计算,永远得到的都是整数
int a = 11; int b = 2; int c = a / b; System.out.println(c);
3.3.如果计算的时候,类型不一样,最后得到的肯定是大的类型的结果
下面的代码会报错:
double a = 11.5; int b = 2; int c = a + b; System.out.println(c);
3.4.取余
例子:
开始
用户输入一个4位数
分别声明4个变量来保存个,十,百,千位上的数字
通过取余数,来获取每个位置上的数字
倒序打印
结束
/倒序的打印输入的4位数
System.out.println("请输入四位数:");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
int ge,shi,bai,qian;
ge = num % 10;
shi = num / 10 % 10;
bai = num / 100 % 10;
qian = num / 1000;
System.out.println("===" + ge + shi + bai + qian);
4.赋值运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
赋值运算符 = 永远是 把右边的值赋值给左边
int num = 10; int num2 = 20; num2 = num;
当一个变量要加上某一个值,然后再赋值给自身的时候,可以使用赋值运算符的简写
int num = 5; num = num + 4; // num += 4; num = num - 2; // num -= 2; num = num * 5; // num *= 5; num = num / 3; // num /= 3; num = num % 2; // num %= 2;
5.关系运算符
| > | 大于 |
|---|---|
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
| == | 比较是否相等 相等返回true,不相等返回false |
| != | 比较是否不相等 |
关系运算符,最后都会得到一个boolean类型的结果
6.位运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 如果相对应位都是 0，则结果为 0，否则为 1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
7.逻辑运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真。 |
8.三元运算符
该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false
三.分支循环语句
1.if语句
if（条件表达式1）{
执行代码块1；
}else if(条件表达式2){
执行代码块2；
}
.............
else{
执行代码块n;
}
2.switch语句
switch(表达式){
case 常量1：
语句1；
//break;
case 常量N：
语句N；
//break；
default:
语句；
//break;
}
3.if和switch语句的对比
（1），如果判断的具体数值不多，而且符合byte，short，char，int，String,枚举等几种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率高。
（2），其他情况：对区间判断，对结果为boolean类型判断，使用if，if的适用范围更广。也就是说，使用switch-case的，都可以改写为if-else。反之不成立。
4.循环结构
1.for循环
for（①初始化部分；②循环条件部分；④迭代部分）{
③循环体部分
}
执行过程①-②-③-④-②-③-④-②-③-④..............
说明：
1.循环条件部分为boolean类型表达条件，当值为false时，退出循环
2.初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
3.可以有多个变量更新，用逗号分隔
2.while循环
①初始化部分
while（②循环条件部分）{
③循环体部分
④迭代部分
}
执行过程：
①-②-③-④-②-③-④-②-③-④...........
3.do-whlie循环
①初始化部分
do{
③循环体部分
④迭代部分
}while（②循环条件部分）；
执行过程：
①-③-④-②-③-④-②-③-④............
4.特殊流程控制语句
break；
1.break御酒用于终止摸个语句块的执行
{ .......
break；
.........
}
2.break语句出现在多层嵌套的语句中时，可以通过标签指明要终止的是哪一层语句
label1：{。。。。。。
label2： {。。。。。。
label3: {。。。。。。
break label2；
}
}
}
continue；
continue只能使用在循环结构中
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
return；
return：并非专门用于结束循环的语句，它的功能是结束一个方法。当方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少成循环之内。
四.数组
1.数组的概述
-
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
-
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
-
数组的长度一旦确定，就不能修改。
-
我们可以直接确定通过下标（或索引）的方式调用指定位置的元素，速度很快。
-
数组的分类：
①按照纬度：一维数组、二维数组、三维数组、.......
②按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组（既对象数组）
2.一维数组的使用：
-
1.声明
type var[]或type[] var：
例如：int a[];
int[]a1;
double b[];
String[] c;//引用类型变量数组
-
（2）、java语言中声明数组时不能指定其长度（数组中元素的数），例如：int a[5];//非法
-
（3）、动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
int[] arr = new int[3];
-
（4）、静态初始化：在定义数组的同时就为数组元素分配数组元素分配空间并赋值。
int arr[] = new int[]{1,2,3};
2.数组元素的引用
（1）、定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
（2）、数组元素的引用方式：数组名[数组元素下标]
1.数组元素下标可以是整型常量或整形表达式。如a[3],b[i],c[6*i];
2.数组元素下标从0开始：长度为n的数组合法下标取值范围：0--->n-1;如int a[]=new int[3];可引用的数组元素为a[0]、a[1]、a[2]
3.每个数组都有一个属性length指明它的长度，例如：a.length指明数组a的长度（元素个数）
①数组一旦初始化，其长度是不可变的
3.数组的默认初始化值
对于基本数据类型而言，默认初始化值各有不同
byte ：0； short：0； int 0； long：0L；
float：0.0F； double:0.0; boolean:false;
char:0或者写为"\u0000"（表示为空）
对于引用数据类型而言，默认初始化值为null
3.二维数组的使用
1.声明
-
格式1（动态初始化）：int arr = new int3;
-
格式2（动态初始化）：int arr = new int3;
-
格式3（静态初始化）：int arr = new int{{1,2,3},{1,2,3},{1,2,3}}
4.排序算法
排序：假设含有n个记录得出序列为{R1,R2,.......,Rn},其相应的关键字序列为{K1,K2,.......,Kn}。将这些记录重新排序为{Ri1,Ri2,.......,Rin},使得相应的关键字满足条件Ki1<=Ki2<=...<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。
衡量排序算法的优劣：
-
1.时间复杂度：分析关键字的比较次数和记录的移动次数
-
2.空间复杂度：分析排序算法中需要多少辅助内存
-
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，称这种排序算法是稳定的。
1.数组中常见的排序算法：冒泡排序
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
//冒泡排序(从小到大排)
for(int i = 0;i < arr.length - 1;i++){//外层循环控制轮数 数组长度-1
for(int j = 0;j < arr.length - 1 - i;j++){//内层进行判断如果j+1>j的值就进行交换 内层循环次数=数组长度-1-外层循环的次数
if(arr[j] > arr[j + 1]){
int temp = arr[j];//temp中间变量，起到替换两个值时中间量的作用
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
2.数组中常见的排序算法：算法排序
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
int temp= 0;//中间变量，起到替换两个值时中间量的作用
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
for (int i = 0; i < arr.length - 1; i++) {// 外层循环控制轮数 数组长度-1
for (int j = i+1; j < arr.length; j++) {// 内层进行判断如果i>j的值就进行交换 循环次数=等于数组长度 内层循环的初始值等于外层循环+1
if (arr[i] > arr[j ]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
3.数组中常见的排序算法：选择排序
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
int temp= 0;
for (int i = 0; i < arr.length; i++) {
int k = i;//记录此时数值的下标位置
for (int j = arr.length-1; j >i ; j--) {//从数组的最后一位开始循环 循环的初始值=数值长度-1
if(arr[j]>arr[k]) {//进行比较，如果外层循环（数组前面的数）比内层循环（数组后面的数）小，
k = j; //那么进入判断记录此时内层循环（数组后面的数）的下标，
//此时k记录的就是内层循环（数组后面的数）比外层循环（数组前面的数）大的数的下标。
}
}
//通过获取的比较后的数组下标进行交换
temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
4.数组中常见的排序算法：插入排序
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
int temp = 0;
int j = 0;
for(int i=0; i<arr.length; i++) {
temp = arr[i];
for(j=i; j>0 && temp<arr[j-1]; j--) {
arr[j] = arr[j-1];
}
arr[j] = temp;
}
System.out.println("插入排序之后====");
System.out.println(Arrays.toString(arr));
5.Arrays工具类的使用
java.util.Arrays类既为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
-
1 boolean equals(int[] a,int[] b) (判断两个数组是否相等。)
-
2 String toString(int[] a) (输出数组信息。)
-
3 void fill(int[] a,int val) (将指定值填充到数组中。)
-
4 void sort(int[] a) (对数组进行排序。)
-
5 int binarySearch(int[] a,int key) (对排序后的数组进行二分法检索指定的值)
数组脚标越界异常（ArraylndexOutOfBoundsException）
空指针异常（NullPointerException）
五.面向对象
1.变量的分类（成员变量和局部变量）
在方法体外，类体内声明的变量称为成员变量
在方法体内部声明的方法称为局部变量。
（成员变量）——>①实例变量（不以static修饰）②类变量（以static修饰）
（局部变量）——>①形参（方法、构造器中定义的变量）②方法的局部变量（在方法内定义）③代码块局部变量（在代码块中定义）
2.方法
1.什么方法（method、函数）：
方法是类或对象行为特征的抽象，用来完成某个功能的操作。在某个语句中也成为函数或过程
将功能封装为方法的目的是，可以实现代码的重用，简化代码
java里的方法不能独立存在，所有的方法必须定义在内中
2.方法的声明格式
修饰符——返回值类型——方法名—（参数类型--形参1，参数类型--形参2，......）{
方法体程序代码
return 返回值；
}
【修饰符类型】
public、缺省、private、protected等
【返回值类型】
没有返回值： void
有返回值，声明出返回值类型。与方法体中“return返回值”搭配使用。
【方法名】：属于标识符，命名是遵循标识符命名规则和规范，见名知意。
【形参列表】：可以包含多个或零个参数，多个参数时中间用逗号隔开。
【返回值】：方法在执行完毕后返回给调用它的程序数据。
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
