目录
一、选择结构
IF选择结构
if....else
Switch Case选择结构
switch...case结构支持的数据类型有哪些？
char, byte, short, int, String
1、整数类型中的byte short int
2、字符型 char
3、String 属于引用类型（jdk8的新特性）
break结束switch...case结构
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体3;
break;
default:
语句体n;
break;
}
二、循环结构
for循环
for(表达式1;表达式2;表达式3){
循环体;
}或者
表达式1
for(;表达式2;){
循环体;
表达式3
}或者
表达式1
for(;;){
if(表达式){
循环体;
break;
表达式3
}
}
while循环
while(循环条件){
//满足条件，执行循环体
//循环结束条件（变量的递增或者递减、break强制结束while循环、continue）
}
do...while循环
do...while 相比while，至少执行一次，先执行一次，再判断是否满足条件
do{
//代码
}while(判断条件);
三、Random
随机数类
可以用于产生随机：整数、小数、布尔类型
r.nextInt()
r.nextInt(10) // [0,10)
r.nextFloat();
r.nextDouble();
r.nextBoolean();求[min,max]范围的值：
r.nextInt(max-min+1)+min;
四、break 和 continue区别（面试）
break 的作用 是结束当前for循环。
continue 结束本次循环，继续下次循环。
五、嵌套循环-多重循环
//外层循环控制行
for(){
//内层循环控制列
for(){
System.out.print("");
}
System.out.println();//换行
}while(){
while(){
}
}do{
do{
}while();
}while():
while(){
for(){
}}
六、一维数组
数组是一种特殊的数据类型，这种数据类型用于存储一组数据类型相同的数据。简单来说，数组就是一个容器，用于存储一组数据，这组数据具有相同的数据类型。
数组中的每个数据称为数组的元素。
变量：存储单个值
int i = 1;
double d = 1.0;
String name = "张三";数组：存储多个相同数据类型变量的值
double score1 = 60;
double score2 = 70;
double score3 = 80;
double[] scores = {60,70,80}声明数组
数据类型[] 数组名 ;
数据类型 数组名[] ;
数据的初始化
静态初始化
数据类型[] 数组名 = {元素1,元素2,元素3};
动态初始化
数据类型[] 数组名 = new 数据类型[5];
数组名[0] = 元素1;
package com.hl.array;
public class ArrayDemo1 {
public static void main(String[] args) {
//创建一个数组，存储班级同学姓名
//静态初始化
String[] name = {"小白","小黑","小紫","小红"};
//动态初始化 必须指定数组长度
String[] name2 = new String[30];
int[] age = new int[30];
//查看第一个元素（索引下标0）位置的值
System.out.println(name2[0]);//默认值 所有的引用数据类型 默认值为null
System.out.println(age[0]);//基本数据类型的默认值 整数0 浮点0.0 布尔false
//修改指定索引下标位置的元素
age[0] = 20;
name2[0] = "张三";
System.out.println(name2[0]);
System.out.println(age[0]);
}
}索引下标越界
package com.hl.array;
public class ArrayDemo2 {
public static void main(String[] args) {
//数组索引下标越界
//索引下标 0-9
int[] array = new int[10];
//java.lang.ArrayIndexOutOfBoundsException: 10
// System.out.println(array[10]);
// array[10] = 1;
}
}数组排序
数组排序指的是让一堆杂乱无章的数据，按从小到大排列，或者按从大到小排列，让其有规律。这个过程就是数组排序。排序的算法很多，例如：冒泡排序，选择排序，快速排序，归并排序，插入排序等等。咱们讲一下冒泡排序和选择排序。
冒泡排序（练习）
冒泡排序：海底的气泡由于水压的作用，越深的地方气泡就越小，气泡在上浮的过程中，由于水压的减小，气泡会越来越大，到达海面的时候，气泡会最大。基于这个启发，数学家们发明了冒泡排序。
冒泡排序的思想：以从小到大排序为例。依次比较相邻的2个数据，如果前面的数据大于后面的数据，二者交换位置，一趟下来之后，最大的数据就跑到了末尾，这个数据在下一趟不再参与比较。第二趟仍然是依次比较相邻的2个数据，如果前面的数据大于后面的数据，二者交换位置，第二趟下来之后，第2大的数据就跑到了倒数第二位，同样这个数据不再参与下一趟的比较，以此类推，对于具有n个数的数组而言，进行n-1趟上述过程，就能让数组有序。
package com.hl.sort;
import java.util.Arrays;
import java.util.Comparator;
public class SortDemo1 {
public static void main(String[] args) {
int[] array = {1,55,22,13,4,16,17,90,9};
//数组排序 升序排序
// Arrays.sort(array);
// for (int i = 0; i < array.length; i++) {
// System.out.print(array[i]+" ");
// }
System.out.println(array);
//冒泡排序 两两相邻比较，小的放前面（交换位置）
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1 - i; j++) {
if(array[j] > array[j+1]){//交换位置
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
System.out.println(Arrays.toString(array));
}
}
}七、二维数组
二维数组本质上就是一个一维数组，每一个元素又是一个一维数组。
int[] array = {1,2,3,4};
int[][] array = {
{1,2,3,4},
{5,6,7,8}
};
二维数组的定义和初始化
静态初始化：
int[][] array = {
{1,2,3,4},
{5,6,7,8}
};
动态初始化：
int[][] array = new int[2][4];
//2行 4列
0 0 0 0
0 0 0 0
array[0][0] ... [0][3]
array[1][0] ... [1][3]
二维数组的遍历
package com.hl.array2;
public class Demo1 {
public static void main(String[] args) {
int[][] array = {{1,2,3},{4,5,6},{7,8,9,10}};
//遍历查询
//求二维数组长度
System.out.println(array.length);
for(int i=0;i<array.length;i++){
//一维数组
int[] array2 = array[i]; // {1,2,3}
//遍历每一个一维数组
for (int j = 0; j < array2.length; j++) {
System.out.print(array2[j]+" ");
}
System.out.println();//换行符
}
}
}
八、方法
方法必须先创建才可以使用，创建只需要进行一次创建，使用可以多次。方法的创建过程称为方法的定义。
和变量类似，变量必须先定义再使用，方法也是先定义再使用。
方法创建后并不是直接运行的，需要手动使用才执行，使用方法称为方法调用。
方法的定义
方法隶属于类，因此方法要定义在类中，且方法不能定义在别的方法内。
方法定义的格式
public static 返回值类型 方法名(参数列表){
方法体
}
方法的调用
方法定义好之后，就可以在想要使用的时候调用方法，达到使用方法的目的。
方法调用的格式
方法名(参数);
方法可以简化程序的代码，让代码得以复用。
方法的组成
修饰符：public、static
方法名称：命名方式遵循变量的命名方式
参数：方法执行所需要的外界数据，多个参数用 "," 分隔。
返回值：方法执行完之后，给外界的数据。
方法体：方法中封装的要执行的代码
方法的分类
方法按有没有参数，有没有返回值可以分为以下4类：
-
无参数无返回值方法
-
无参数有返回值方法
-
有参数无返回值方法
-
有参数有返回值方法
无参数无返回值方法
如果一个方法没有参数，也没有返回值，这样的方法就是无参数无返回值方法。
如果方法没有返回值，我们在定义方法的时候，将返回值类型指定为 void。
无参数无返回值方法的定义格式
public static void 方法名(){
方法体
}
无参数无返回值方法的调用格式
方法名();
无参数有返回值方法
如果一个方法没有参数，但是有返回值，这样的方法就是无参数有返回值方法。
如果方法有返回值，方法体里要通过return语句将结果返回给外界。
定义方法时，返回值类型必须 和 方法体中return 返回的值的类型一致。
无参数有返回值方法的定义格式
public static 返回值类型 方法名(){
方法体
return 返回值;
}
无参数有返回值方法的调用格式
数据类型 变量名 = 方法名();//如果外界要用返回值，拿一个变量接收返回值
或
方法名();//如果外界不需要使用返回值，可以不接收
有参数无返回值方法
有参数无返回值方法的定义格式
public static void 方法名(参数类型 参数名1, 参数类型 参数名2, ...){
方法体
}
有参数无返回值方法的调用格式
方法名(参数值1,参数值2,...);
有参数有返回值方法
有参数有返回值方法的定义格式
public static 返回值类型 方法名(参数类型 参数1, 参数类型 参数2, ...){
方法体
return 返回值;
}
有参数有返回值方法的调用格式
数据类型 变量名 = 方法名(参数1,参数2,...);//如果外界要用返回值，拿一个变量接收返回值
或
方法名(参数1,参数2,...);//如果外界不需要使用返回值，可以不接收
方法分类总结
-
如果方法有返回值，在方法体内必须要有return语句。并且 return后面的返回值 必须和 返回值类型一致。
-
如果方法有参数，参数可以是1个也可以是多个，如果是多个参数，参数与参数之间用“,”隔开。
-
定义方法时的参数叫形参（形式参数），调用方法时的参数叫实参（实际参数）。
-
定义方法时：参数的类型和参数名都不能少。
-
调用方法时：不需要参数类型
-
参数可以是常量、变量、表达式、或者另外一个方法的返回值。
-
方法不能嵌套定义。
九、形参 实参
形参
全名叫形式参数，出现在方法定义中，形参只是用来占位的，用来代表未来调用方法时传递过来的数据。
实参
全名叫实际参数，出现在方法调用中，实参是方法执行时真正要用到的数据。在方法调用时，会把实参传递给形参，在执行方法过程中用于参与运算。
在方法调用时，要保证实参的数据类型和形参的数据类型一致。
实参到形参只是单向的值拷贝过程。如果实参是个数据，会把数据拷贝给形参；如果实参是个地址，会把地址拷贝给形参。----实参和形参是2个变量，只是值相等，实参的值拷贝给了形参。
如果参数是引用类型，可以在方法内修改内容。
如果参数是基本数据类型，无法在方法内修改内容。
方法重载
在同一个类中，如果多个方法具有相同的方法名，但参数类型或者参数个数不相同（或都不相同），这就是方法的重载。-----方法重载和返回值没有关系，不看返回值，只看方法名以及参数。
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(3.5, 2.0));
System.out.println(sum(1,2,3));
}
public static double sum(double x, double y) {
return x +y;
}
public static int sum(int x, int y) {
return x +y;
}
public static int sum(int x, int y, int z) {
return x + y + z;
}不定参数方法
不定参数方法：指的是方法的参数是可变的，不确定的，只有调用的时候，才知道参数的具体个数。
public static void main(String[] args) {
int num1 = calculate(1,2,3);
System.out.println(num1);
int num2 = calculate(100,20,50,30,200,150);
System.out.println(num2);
}
//不定参数方法
public static int calculate(int... nums) {
int sum = 0;
for(int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum;
}在不定参数的方法里，形参本质上是一个数组，数组里存放的是各个实参，实参按顺序存入数组。取的时候按数组名[下标]取出元素使用即可。
public static void main(String[] args) {
int num1 = calculate(true, 1, 2, 3, 4, 5);
System.out.println(num1);
int num2 = calculate(false, 2, 5, 20);
System.out.println(num2);
}
//不定参数方法---既有固定参数，又有不定参数时，不定参数要放到最后。
public static int calculate(boolean doAdd,int... nums) {
int result = doAdd ? 0 : 1;//如果是求和，初值设置为0，否则初值设置为1（求乘积）
if(doAdd) {
for(int i = 0; i < nums.length; i++) {
result += nums[i];
}
}else {
for(int i = 0; i < nums.length; i++) {
result *= nums[i];
}
}
return result;
}不定参数有两个规定：
第一，方法的参数列表中最多只有一个不定长度的参数；
第二，就是不定长度的参数的位置必须是最后一个参数。
对于第一个规定，是因为如果有多于一个不定长度的参数，当真正调用这个方法的时候，JVM将不知道前面的不定长度参数有多长, 下一个参数是从哪里开始.
对于第二个参数也是一样，编译器不知道不定长度参数的长度，无法确定从哪里开始下一个参数。
不定参数方法，也可以重载。
总结
方法是具有特定功能的代码块。方法可以大大简化程序的代码，提高代码的复用度。
方法分为：无参数无返回值方法，无参数有返回值方法，有参数无返回值方法，有参数有返回值方法。
方法必须先定义，再使用。
方法调用时，实参的值会拷贝给形参，实参和形参是2个变量。
在Java中，方法可以重载。
不定参数的方法，不定参数一定要放到末尾，而且一个方法最多只能有1个不定参数。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
