java基础（基础语法、执行结构、数组[涉及数组常用算法]）
一、基础语法
1 变量
变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。
变量分类：
- 按所属的数据类型划分：
- 基本数据类型变量
- 引用数据类型变量
- 按被声明的位置划分：
- 局部变量：方法或语句块内部定义的变量
- 成员变量：方法外部、类的内部定义的变量
特别注意：类的外面不能有变量的声明
2 数据类型
由于变量记录的数据内容大小不同, 导致所需的存储单元大小不同，在 Java 语言中使用数据类型的概念加以 描述 。
字节是计算机信息技术用于计量存储容量的一种计量单位，作为一个单位来处理的一个二进制数字串，是构成信息的一个小单位。
Java 中的字节是八位的字节，即它包含八位的二进制数。
3 标识符
Java对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。
规则如下：
- 由字母、数字、下划线（_）和美元符号（$）组成。
- 不能以数字开头。
- 区分大小
- 长度无限制
- 不能是Java中的保留关键字
注：标识符命名习惯是见名知意。
软性建议：
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。
变量名规范：全部小写
4 类型转换
boolean：不能转换任何其他数据类型
自动类型转换：
容量小的类型自动转换成容量大的数据类型。
byte，short，int -> float ->long ->double
byte，short，int 不会互相转换，它们三者在计算时会转换成 int 类
强制类型转换：
容量大的类型转换成容量小的数据类型时，要加上强制转换符。但可能造成精度降低或数据溢出。
例如：
long l = 100L;
int i = (int)l;
5 关键字大全
Java 中有一些赋予特定的含义，有专门用途的字符串称为关键字（keyword）。全部是小写。
保留字：没有定义用途，但保留备用。 goto、const
6 方法的使用
方法用于封装一段特定的逻辑功能。
**方法的主要要素有：**权限修饰符、方法名、参数列表和返回
格式：
权限修饰符 返回值类型声明 方法名称(参数列表){
方法中封装的逻辑功能;
return 返回值;
}
6.1、 权限修饰符
6. 2、返回值详解
方法调用结束后可以返回一个数据，称之为返回值。
方法在声明时必须指定返回值的类型。
通过 return 语句返回，return 语句的作用在于结束方法且将数据返回。
如果方法没有返回值（即方法不需要返回数据），需将返回值类型声明为 void 。
6.3、参数列表
在调用时传递给方法，需要被方法处理的数据。
在方法定义时，需要声明该方法所需要的参数变量。
在方法调用时，会将实际参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。
6.4、方法示例
public void say(int a,int b){
System.out.println(“方法 say 正在执行”);
}
7 运算符
7.1 算术运算符
i++：先运算，后自增
++i：先自增，后运算
i–：先运算，后自减
–i：先自减，后运算
7.2 赋值运算符
赋值运算符作用是将一个值赋给一个变量，运算顺序从右到左
7.3 关系运算符
关系运算符作用是比较两边的操作数，结果总是 boolean 型的。
7.4 逻辑运算符
逻辑运算符用于对 boolean 型结果的表达式进行运算，运算结果总是 boolean 型
7.5 字符串连接运算符
String s="He" + "llo";
结果"Hello"
"+"除了可用于字符串相连接，也能将字符串与其它的数据类型相连成一个新的字符串。
如：
String s="x" + 123;
结果"x123"
7.6 三目运算符
X ? Y : Z
X 为 boolean 类型表达式，先计算 x 的值，若为 true，整个三目运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。
例：
int score = 75;
String type = score
String type = score >=60 ? "及格" : "不及格";
7.7 操作符优先级
表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行：
| 优先次序 | 运算符 |
|---|---|
| 1 | . [] () |
| 2 | ++ — ! ~ instance of |
| 3 | new (type) |
| 4 | * / % |
| 5 | + - |
| 6 | >> >>> << |
| 7 | > < >= < |
| 8 | == != |
| 9 | & |
| 10 | ^ |
| 11 | | |
| 12 | && |
| 13 | || |
| 14 | ?: |
| 15 | = += -= *= /= %= ^ |
| 16 | &= |= <<= >>= |
7.8 转义字符
| 转义字符 | 意义 | ASCII码值（十进制） |
|---|---|---|
| \n | 换行，将当前位置移到下一行开头 | 010 |
| \r | 回车 ，将当前位置移到本行开头 | 013 |
| \t | 回车 ，将当前位置移到本行开头 | 009 |
| \\ | 代表一个反斜线字符’’\ | 092 |
| \’ | 代表一个单引号（撇号）字符 | 039 |
| \" | 代表一个双引号字符 | 034 |
二、执行结构
1 顺序结构
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作
2 分支结构
分支结构又被称为选择结构，根据条件成立与否来执行操作
2.1 if 条件语句
if 条件结构是根据条件判断之后再做处理
if(条件语句){…}
if (条件语句){…}else{…}
if (条件语句){…}else if(条件语句){…}
if (条件语句){…}else if(条件语句){…}else{…}
例子：用户输入学生成绩，判断成绩是否及格，判断条件为 优良： > 90、良好：81-90、中：60-80、不及格：<60
import java.util.Scanner;
public class Demo4{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入成绩：");
int score s= input.nextInt();
// 91 优 81-90 良 60-80 中 60 差
if(score >= 91){
System.out.println("您的成绩是优秀！继续加油哦！");
}else if(score >= 81 & score < 91){
System.out.println("您的成绩是良好！还要努力哦！");
}else if(score >= 60 & score <= 80){
System.out.println("您的成绩是中等！还要加倍努力哦！");
}else{
System.out.println("您的成绩是差！准备补考费吧！");
}
}
}
2.2 switch
switch(表达式){
case 取值 1: 语句块 1;break;
case 取值 n: 语句块 n;break;
default: 语句块 n+1;break;
}
switch 语句有关规则
表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
case 子句中的取值必须是常量，且所有 case 子句中的取值应是不同的；
default 子句是可选的；
break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；
如果 case 后面没有写 break 则直接往下面执行！
Case 后面的执行体可写{ }也可以不写{ }
例子： 多分支月份输出天数（充分利用语句特性 ）
import java.util.Scanner;
public class Demo6{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入月份：");
int month = input.nextInt();
switch(month){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月共有 31 天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月共有 30 天");
break;
case 2:
System.out.println(month +"月共有 28 天");
break;
default :
System.out.println("友情提示，您输入有误！");
break;
}
}
}
3 循环结构
分支结构又被称为选择结构，根据条件成立与否来执行操作
在循环条件满足的情况下，反复执行特定代码
3.1 while循环
符合条件，循环继续执行；否则，循环退出
特点：先判断，再执行
语法：
while(条件表达式){
//语句块；
}
例子： 录入班级人数和学员成绩，计算班级学员的平均成绩
/**
* 使用 while 循环的步骤 :
* 1、分析循环条件和循环操作
* 2、套用 while 语法写出代码
* 3、检查循环是否能够退出
*/
int sum = 0;
int score = 0;
int avg = 0;
int studentNum = 20;
while(i<=studentNum){
System.out.print("请输入第" + i + "位同学的成绩：");
score = input.nextInt();
sum = sum + score;
i++;
}
avg = sum / stuNum ;
3.2 do-while循环
先执行一遍循环操作，符合条件，循环继续执行；否则，循环退出
特点：先执行，再判断
语法：
do {
循环操作
}while (条件表达式);
while 循环和 do-while 循环的区别？
while:先判断条件，如果条件满足，再执行循环操作
do while:先执行一遍循环操作，然后再判读条件，如果条件满足，继续执行循环操作。
3.3 for循环
语法：
for(初始化参数; 判断条件; 更新循环变量){
循环体;
}
例子：
public class ForLoop {
public static void main(String [] args){
int result = 0;
for(int i=1; i<=100; i++) {
result += i;
}
System.out.println("result=" + result);
}
}
3. 4 循环的退出：
break：用于终止本轮所有次循环。即不执行本次循环中break后面的语句，直接跳出循环
continue：用于终止本轮本次村换。即本次循环中continue后面的代码不执行，进入下一次循环的入口判断。
三、数组
数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个 元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。
3.1 创建数组的格式
//格式1：数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};
int[] ages = {1,2,3,4,5,14}
//格式2：数据类型[] 数组名称 = new 数据类型[数组长度];
int[] ages = new int[5];
-
格式 3. 数据类型[] 数组名;
格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
-
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};
注：1、2常用，3、4不常用
3.2 操作数组
//通过下标操作数组数据的方式：
//1：给数组某个下标赋值：数组名称[下标] = 值;
ages[0] = 100;
//2：从数组某个下标取值：数组名称[下标]
System.out.println(ages[0]);
ages2[0] = 99;
System.out.println(ages2[0]);
System.out.println("------------------------");
//如何获取数组的长度： 数组名称.length
//数组的遍历
for(int index=0;index<ages.length;index++) {
//index: 0 1 2 3 4
System.out.println(ages[index]);
}
3.3 数组操作常见问题
1、数组下标越界问题
int[] nums = {10,11,12,13,14};
System.out.println(nums[5]);//出错
2、空指针问题
int[] nums = null;
System.out.println(nums[1]);//出错
3.4 数组常用算法
3.4.1 最大值|最小值
//寻找数组中的最大值 | 最小值
public static void main(String[] args) {
int[] nums = {10,30,40,33,22,20,11,0};
//1.创建一个变量，用于存储遍历数组时发现的最大值
int n = nums[0];
//2.循环取出数组中的每一个内容，从1开始
for(int i=1;i<nums.length;i++) {
//将数组中的每一个内容与n比较，如果比n大，则将n的值赋值为这个内容。
n = n<nums[i]?n:nums[i];
}
System.out.println(n);
}
3.4.2 冒泡排序
原理：
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的 数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
升序排列的口诀:
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1
降序排序的口诀:
N个数字来排队
两两相比大靠前,
外层 循环length-1
内层循环length-i-1
/**
* 冒泡排序
* @param args
*/
public static void main(String[] args) {
int[] nums = {20,15,18,13,30,60};
int temp;
//外层循环控制的是， 比较的轮数。
//外层循环次数： length-1
for(int i=0;i<nums.length-1;i++) {
//内层循环控制的是，每轮比较的次数
//第i轮（i从0开始计算）， 比较次数为：length-i-1
for(int j=0;j<nums.length-i-1;j++) {
if(nums[j]>nums[j+1]) {
//两两相比， 满足移动条件
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
}
//排序已经完成。 下面是遍历打印查看的过程
for(int i=0;i<nums.length;i++) {
System.out.println(nums[i]);
}
}
3.4.3 二分查找 （折半查找）
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺 序存储结构有序排列。
原理：
首先，假设数组中元素是按升序排列。将数组中间位置的数据与查找数据比较，
如果两者相等，则查找成功；否则利用中间位置记录将数组分成前、后两个子数组，
如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查 找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功；
直到子数组不存在为止，表示查找不成功
/**
* 二分查找（折半查找）
*/
public static void main(String[] args) {
int[] nums = {10,20,30,40,50,60,70,80,90};
//要查找的数据
int num = 20;
//关键的三个变量：
//1.最小范围下标
int minIndex = 0;
//2.最大范围下标
int maxIndex = nums.length-1;
//3.中间数据下标
int centerIndex = (minIndex+maxIndex)/2;
while(true) {
System.out.println("循环了一次");
if(nums[centerIndex]>num) {
//中间数据较大
maxIndex = centerIndex-1;
}else if(nums[centerIndex]<num) {
//中间数据较小
minIndex = centerIndex+1;
}else {
//找到了数据 数据位置：centerIndex
break;
}
if(minIndex > maxIndex) {
centerIndex = -1;
break;
}
//当边界发生变化， 需要更新中间下标
centerIndex = (minIndex+maxIndex)/2;
}
System.out.println("位置："+centerIndex);
}
96
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
