java 基础概括02

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.判断语句

1. 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] 
}