4.方法
1.方法的定义:
修饰符 返回值类型 方法名 （参数列表）｛
代码...
return ;
}
2.定义格式解释：
1.修饰符： 目前固定写法 public static 。
2.返回值类型：
①void
②表示方法运行的结果的数据类型，方法执行后将结果返回到调用者 。
3.方法名：为我们定义的方法起名
4.参数列表：
①无参数
②方法在运算过程中的未知数据，调用者调用方法时传递
5.return：方法结束。
①因为返回值类型是void，方法大括号内的return可以不写
②将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
例子:
public static void methodName() {
System.out.println("这是一个方法");
}
3.无返回值方法的调用
方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在 主方法中，直接写要调用的方法名字就可以调用了。
public static void main(String[] args) {
//调用定义的方法method
method();
}
//定义方法，被main方法调用
public static void method() {
System.out.println("自己定义的方法，需要被main调用运行");
}
注意:
1.方法必须定义在一类中方法外
2.方法不能定义在另一个方法的里面
3.返回值类型，必须要和 return 语句返回的类型相同，否则编译失败
4.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码
// 返回值类型要求是int
public static int getSum() {
return 5;
// 正确，int类型
return 1.2;
// 错误，类型不匹配
return true;
// 错误，类型不匹配 }
4.有返回值方法调用
需求：定义方法实现两个整数的求和计算。
明确返回值类型：方法计算的是整数的求和，结果也必然是个整数，返回值类型定义为int类型。
明确参数列表：计算哪两个整数的和，并不清楚，但可以确定是整数，参数列表可以定义两个int类型的 变量，由调用者调用方法时传
public class Method_Demo2 {
public static void main(String[] args) {
// 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数 // 并接收方法计算后的结果，返回值
int sum = getSum(5, 6);
System.out.println(sum);
}
/* 定义计算两个整数和的方法 返回值类型，计算结果是int 参数：不确定数据求和，定义int参数.参数又称为形式参数 */
public static int getSum(int a, int b) {
return a + b;
}
}
5.调用方法的三种形式
①直接调用：直接写方法名调用
public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("方法被调用");
}
②赋值调用：调用方法，在方法前面定义变量，接收方法返回值
public static void main(String[] args) {
int sum = getSum(5,6);
System.out.println(sum);
}
public static int getSum(int a,int b) {
return a + b;
}
③输出语句调用：
public static void main(String[] args) {
System.out.println(getSum(5,6));
}
public static int getSum(int a,int b) {
return a + b;
}
例题:
1.计算1+2+3...+100的和
2.比较两个整数是否相同
5.判断语句
- if语句
if(关系表达式)｛
语句体;
}
public static void main(String[] args){
System.out.println("开始"); // 定义两个变量
int a = 10;
int b = 20;
//变量使用if判断
if (a == b){
System.out.println("a等于b");
}
int c = 10;
if(a == c){
System.out.println("a等于c");
}
System.out.println("结束");
2.if...else 语句
if(关系表达式) {
语句体1;
}else {
语句体2;
}
public static void main(String[] args){
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 1;
if(a % 2 == 0) {
System.out.println("a是偶数");
} else{
System.out.println("a是奇数");
}
System.out.println("结束");
}
3.选择语句
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
... default:
语句体n+1;
break;
}
public static void main(String[] args) {
//定义变量，判断是星期几
int weekday = 6;
//switch语句实现选择
switch(weekday) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的数字有误");
break;
}
}
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
4.for循环
for(初始化表达式①; 布尔表达式②; 步进表达式④){
循环体③
}
执行顺序:
①②③④>②③④>②③④…②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况
//用循环改进，循环10次 //定义变量从0开始，循环条件为<10
for(int x = 0; x < 10; x++) {
System.out.println("HelloWorld"+x);
}
注意:
①break:终止switch或者循环
public static void main(String[] args) {
for (int i = 1; i<=10; i++) {
//需求:打印完两次HelloWorld之后结束循环
if(i == 3){
break;
}
System.out.println("HelloWorld"+i);
}
}
②continue:结束本次循环，继续下一次的循环
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}
5.循环语句2--while
while循环语句格式：
初始化表达式①
while(布尔表达式②){
循环体③
步进表达式④
}
执行流程执行顺序：
①②③④>②③④>②③④…②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句。
④循环后，循环变量的变化情况。
例子1:while循环输出10次HelloWorld
public static void main(String[] args) {
//while循环实现打印10次HelloWorld
//定义初始化变量
int i = 1;
//循环条件<=10
while(i<=10){
System.out.println("HelloWorld");
//步进
i++;
}
}
例子2:while循环计算1-100之间的和
public static void main(String[] args) {
//使用while循环实现 //定义一个变量,记录累加求和
int sum = 0;
//定义初始化表达式
int i = 1;
//使用while循环让初始化表达式的值变化
while(i<=100){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
}
//打印求和的变量
System.out.println("1‐100的和是："+sum);
}
for 和 while 的小区别：
- 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继 续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消 失，能够提高内存的使用效率。
- 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
6.数组
数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
定义方式一
格式：
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数组定义格式详解：
数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字：为定义的数组起个变量名
new：关键字，创建数组使用的关键字。
数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改
int[] arr = new int[3];
定义方式二
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
int[] arr = new int[]{1,2,3,4};
定义方式三
格式：
数据类型[] 数组名 = {元素1,元素2,元素3...};
int[] arr ={1,2,3};
索引访问数组中的元素：
数组名[索引]=数值，为数组中的元素赋值
变量=数组名[索引]，获取出数组中的元素
注意:
每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的 长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数 组的最大索引值为 数组名.length-1 。
数组的遍历
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 };
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
例题:
1.数组获取最大值元素
public static void main(String[] args) {
int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
//定义变量，保存数组中0索引的元素
int max = arr[0];
//遍历数组，取出每个元素
for (int i = 0; i < arr.length; i++) {
//遍历到的元素和变量max比较
//如果数组元素大于max
if (arr[i] > max) {
//max记录住大值
max = arr[i];
}
}
System.out.println("数组最大值是： " + max);
}
2.数组作为方法参数
数组作为方法返回值
数组作为方法的返回值，返回的是数组的内存地址
public static void main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9 };
//调用方法，传递数组
printArray(arr); }
/* 创建方法，方法接收数组类型的参数 进行数组的遍历 */
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
3.数组作为方法返回值
public static void main(String[] args) {
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static int[] getArray() {
int[] arr = { 1, 3, 5, 7, 9 };
//返回数组的地址，返回到调用者
return arr; }
4.Arrays类
如果我们不用Arrays这个类,我们想对一个数组从小到大进行排序,该怎么实现呢?代码如下:
public static void main(String[] args) {
int[] arrold = {12,10,2,5,20};
for (int i = 0 ; i < arrold.length;i++){
for (int j = i+1; j < arrold.length;j++){
if(arrold[i]> arrold[j] ){
int index = arrold[i];
arrold[i] = arrold[j] ;
arrold[j] = index;
}
System.out.println("i的值为"+i);
System.out.println("j的值为"+j);
String s = Arrays.toString(arrold);
System.out.println(s);
}
}
// String s = Arrays.toString(arrold);
// System.out.println(s);
}
public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
public static void main(String[] args) {
// 定义int 数组
int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
System.out.println("排序前:"+ Arrays.toString(arr));
// 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6, 2]
// 升序排序
Arrays.sort(arr);
System.out.println("排序后:"+ Arrays.toString(arr));
// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46, 48]
}
倒序
public static void main(String[] args) {
Integer[] arrold = {12, 10, 2, 5, 20};
Arrays.sort(arrold, Collections.reverseOrder());
for (int i = 0; i < arrold.length; i++) {
System.out.println(arrold[i]);
}
}
public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
public static void main(String[] args) {
// 定义int 数组
int[] arr = {2,34,35,4,657,8,69,9};
// 打印数组,输出地址值
System.out.println(arr);
// [I@2ac1fdc4 // 数组内容转为字符串
String s = Arrays.toString(arr);
// 打印字符串,输出内容
System.out.println(s);
// [2, 34, 35, 4, 657, 8, 69, 9]
}