做头像网站静态中国四大软件外包公司是哪四个
目录
一、选择结构
IF选择结构
Switch Case选择结构
二、循环结构
for循环
while循环
do...while循环
三、Random
随机数类
四、break 和 continue区别（面试）
五、嵌套循环-多重循环
六、一维数组
声明数组
数据的初始化
静态初始化
动态初始化
索引下标越界
数组排序
冒泡排序（练习）
七、二维数组
二维数组的定义和初始化
二维数组的遍历
八、方法
方法的定义
方法的调用
方法调用的格式
方法的组成
方法的分类
无参数无返回值方法
无参数无返回值方法的定义格式
无参数无返回值方法的调用格式
无参数有返回值方法
无参数有返回值方法的定义格式
无参数有返回值方法的调用格式
有参数无返回值方法
有参数无返回值方法的定义格式
有参数无返回值方法的调用格式
有参数有返回值方法
有参数有返回值方法的定义格式
有参数有返回值方法的调用格式
方法分类总结
九、形参 实参
形参
实参
方法重载
不定参数方法
总结
一、选择结构
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]);//默认值 所有的引用数据类型 默认值为nullSystem.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-9int[] 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个不定参数。