二维数组 方法

需求:
在数组里存人名和成绩
{“张迪”,”100”}
{“c”,”45”}
{“王”，”101”,”张”,”152”}

{{"张迪","100"}，{"c","45"},{"1","5","56"}}

———-引申出概念：二维数组

概念：数组的元素依然是数组
int[] a={1,2,3,4}
int[][] b={{1,2,},{3,4,}}

访问： b[0]–>{1,2}
b[1]–>{2,3,4,5,6}
b[2]–>{1,2,3}

   b[0][0] -->1
   b[0][1] -->2
   .....
   b[1][3] -->5
   b[1][4] -->6
   ...
   b[2][1] -->2


   x={
      {1,2,3},
      {1,2,3},
  {4,5,6}
     }

   x数组的元素：都是等长的数组，类似于矩阵。

   y ={
   {1,2},
   {1,2,3},
   {1}
      }
   y数组的元素：不是等长的数组。

方法内：
引用数据类型与基本数据类型的区别：
引用数据类型的 数据 称之为对象，存储在内存中某一个特定区域中，即堆

    引用类型的 变量 也存储在内存中的一个特定区域，即栈

引用类型的变量 存储的内容  不是 对象 ，而是对象所在的 堆空间 的位置信息

基本类型的数据不叫对象，直接存储在栈的变量空间里（不需要通过栈存堆位置信息）

基本数据类型的数据存在栈里，存储的内容是基本类型的数据

二维数组初始化;
静态初始化
如：int[][] a = {{1,2},{1,2,3}{1,2,3,4,5}};

动态初始化：
（1）等长初始化
    int[][] a = new int[3][2];//a有三个元素，每个元素都是2个长度的数据
（2）只规定高维数组的长度
    int[][] a = new int[3][];
    表示a有三个元素，但是都是null.
    null在使用时，需要新建数组对象(长度任意)
    a[0] = new int[2];//将null替换成数组对象

====================================================================
方法：即功能，封装了一段逻辑代码
方法的定义：
固定语法：

    修饰词 返回值类型 方法名（形式参数）{
    逻辑代码
    }

方法的位置：
    在类体中，与main方法是并列关系，类体中可以有多个方法

修饰词：public----公共的
    protected---受保护的
    private---私有的
    也可以不写修饰词，即默认的（default）

    static修饰词可以与上述三个连用
返回值类型：
    （1）void-----无返回值类型
    （2）java语言的任意一种类型，可以是基本数据类型，也可以是引用数据类型

方法名：见名知义，驼峰命名法，首字母小写

形式参数;
用于接收调用者传入的数据。与变量的声明语法相同。

关键字return：
    作用1：结束方法逻辑
    作用2：如果返回值类型标记的是java语言类型的某一个类型名，
        那么return关键字后必须跟着一个 此类型的数据或变量

    当方法有返回值类型时，return关键字后的数据就是此方法要返回的数据，
       返回给调用者。

    如：public static int sum(){
    int a = 3;
    int b = 5;
    int sum = a+b;
    return sum; 

例1：（无返回值用void） //方法中变量已赋值，调用时直接调用sum()
public static void sum(){
int a = 3;
int b = 5;
System.out.println(a+b);
[return;]—返回值类型处写void时，return可有可无；
}

  调用：
main(String[] args){
    sum();
        }

例2：计算两个整数a和b的和 (无返回值用void) //变量未赋值，方法中需要形参

public static void sum（int a，int b）{
//括号内为形式参数
    int sum = a+b；
System.out.println(sum);
}


PS:  方法定义期间，就是制定逻辑流程模板。

调用：
main(String[] args){
/*
调用者main 在使用sum(int a,int b)时
需要给形式参数赋值，赋的值叫实际参数
*/
int x = 1;
int y = 2;
sum(x,y);
}

例3.//有返回值，方法中变量已赋值，调用时直接调用sum（）
public static int sum(){
int a = 3;
int b = 5;
int sum = a+b;
return sum;
}

调用：main(String[] args){
    sum();
    /*int n = sum();*/    //暂时不用时可以用变量存起来
       }

例4.有返回值，需要形参
public static int sum(int a ,int b){
int sum = a+b;
return sum*3;
}

调用：main(String[] args){
    int m = 10;
    int n = 20;
    int s = sum(m,n);
     }
总结;
  调用方法时：
   ---- 无返回值   方法名（有参传参，即方法中有参数，调用时传实参）；

—–有返回值 返回值类型 变量=方法名（有参传参，即方法中有参数，调用时传实参）；

eclipse(日食):
是eclipse基金会提供的一款集成开发环境(IDE)。
也是一款绿色免安装，免费的开发工具。
使用前，需要JDK开发环境。
其他开发工具如：myeclipse,ideas，netBean,JBiulder

使用步骤：
(1)新建项目
File–>new–>java Project–name–>finish
(2)新建包(package)
命名规则
域名后缀.域名.项目名.模块名
src–>new–>package–name–finish
(3)创建源文件(.java)
选中包–>new–>class–name–finish

  补全键:  alt+ ?

  main方法的快捷方式
  main+补全键
  syso+补全键

ctrl + s的习惯

例1./* 二维数组得声明和初始化 概念：数组得元素依然输一个数组 /
import java.util.Arrays;// 导包
public static void main(String[] args){
/二维数组得声明和初始化/

    /*静态初始化：*/
    int[][] a= {{1,2},{3,4,5},{6,7}};
    /*使用 for循环进行遍历*/
    for(int i=0;i<a.length;i++){
        int[] n=a[i];//n是一个数组，存储的是a[i]的位置
/*      System.out.println(Arrays.toString(n));   */
        for(int j=0;j<n.length;j++){
            int m=n[j];//内层循环的位置
            System.out.print(n[j]+"");
            //双层for循环，最终答案从内层循环输出
        }
        System.out.println();4ihh
    }
    /*动态初始化    
      二维数组等长式初始化，考虑数组下标越界*/
    int[][] b= new int[6][5];
    //访问输出第一个数组
    System.out.println(Arrays.toString(b[0]));
    b[0][0] = 1;//替换元素
    //b[0][6]=7;
    System.out.println(Arrays.toString(b[0]));
    /*动态初始化
    只规定了高维的长度时，里面的元素是null,不能直接给null赋值，
    应该先把null替换成相应的数组对象*/
    int[][] c= new int[3][];//有三个数组，分别为默认值
    //输出第一个元素
    System.out.println(c[0]);//null
    c[0] = new int[2];//将null替换成数组对象
    System.out.println(Arrays.toString(c[0]));
    c[0][0] = 1;
    c[0][1] = 2;
    System.out.println(c[0]);
    System.out.println(Arrays.toString(c[0]));

    c[1] = new int[3];//内层第二个数组长度为3
    c[1][1] = 4;//内层第二个数组，第二个元素为4
    System.out.println(Arrays.toString(c[1]));//输出：0 4 0

    c[2] = new int[2];//内层第三个数组长度为2
    System.out.println(Arrays.toString(c[2]));//输出：0 0
    }

例2. 方法的封装及调用

  /** 计算半径为r的圆的周长：length */

 public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
    length(5);   //---------方法调用
    length(6);
    length(7);
    length(100);
}
public static void length(double r){   //-------方法封装
    //无返回值，用形参
    double length = r*2*3.14;
    System.out.println(length);
}
//方法封装与main方法并列

例3. 方法的封装及调用

/** 返回半径为r的圆的面积：area */

public class MethodDemo01{//存储路径MethodDemo01
    public static void main(String[] args){ 
        double area = area(9);   //---------方法调用
        System.out.println(area);
        System.out.println(area(10));
        System.out.println(area(100));
    }

public static double area(double r){    //-------方法封装
    //有返回值，
    return 3.14*r*r;
}

例4. 方法的封装及调用

/** 返回宽为3，高为5的方形的面积 area_square */

public class MethodDemo01{//存储路径MethodDemo01
    public static void main(String[] args){ 
        area_square();    //---------方法调用
    }

public static void area_square(){       //-------方法封装
    //有返回值，用void
    System.out.println(3*5);
}

例5. 方法的封装及调用

/** 返回一个字符数组，元素为随机7个小写字母 randomArr */

import java.util.Arrays;//导包
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
char[] a = randomArr(); //———方法调用

    char[] b = randomArr();

    Arrays.sort(a);//从小都大排序
    Arrays.sort(b);
    System.out.println(Arrays.toString(a));//对数组a进行字符输出
    System.out.println(Arrays.toString(b));
    }

    public static char[] randomArr(){     //-------方法封装
    //有返回值
    char[] chs = new char[7];//返回字符数组，得先定义一个字符数组，长度为7
    for(int i=0;i<chs.length;i++){
        chs[i]=(char)(Math.random()*26+97);
    }
    return  chs;
    }

例6. 方法的封装及调用

/** 定义一个猜数字的方法：被猜的数字由形参决定：
直到猜中为止。范围[1,100]  guessNum  */

import java.util.Scanner;//导包
public class MethodDemo01{//存储路径MethodDemo01
public static void main(String[] args){
int num = (int)(Math.random()*100+1); //———方法调用
guessNum(num);
}

    public static void guessNum(int num){   //-------方法封装
    Scanner sc = new Scanner(System.in);//键盘输入
    int guess = -1;
    do{
        System.out.println("输入您猜的数字：");
       guess = sc.nextInt();
       if(guess>num){
           System.out.println("猜大了");
       }
       if(guess<num){
          System.out.println("猜小了");
       }
    }while(guess!=num);
    System.out.println("猜中了，游戏结束");
    }

例7. 关键字
/*随便出10道加法题，加数在[1，100]区间内并作答，
每道题答对得10分，*/

public static void main(String[] args){     
    int total_score = 0;
    Scanner sc = new Scanner(System.in);
    for(int i=1;i<11;i++){
        int a = (int)(Math.random()*100+1);
        int b = (int)(Math.random()*100+1);
        System.out.print("请答题:   ");
        System.out.print(a+"+"+b+"=");          
        int input = sc.nextInt();
        if(input==(a+b)){
            total_score+=10;
        }

    }
    System.out.println("total_score:"+total_score);
}

例8.
/* 录入10个学生的数学，语文，英语三科成绩
计算每科的平均成绩与每人的平均成绩
并找出每科成绩的最高分与最低分。
*/
import java.util.Scanner;
import java.util.Arrays;
public class TestDemo02{
public static void main(String[] args){

    int[][] scores = new int[5][3];
    Scanner sc = new Scanner(System.in);
    for(int i=0;i<scores.length;i++){
        System.out.println("录入第"+(i+1)+"个学生的成绩");
        for(int j=0;j<scores[i].length;j++){
            scores[i][j]=sc.nextInt();  
        }
    }
    /*查看 每个学生的成绩*/
    for(int i=0;i<scores.length;i++){
        System.out.println("学生"+(i+1)+":"+Arrays.toString(scores[i]));
    }
    /*计算每个学生的总成绩和平均成绩
        int sum = 0;
        sum+=scores[0][0];
        sum+=scores[0][1];
        sum+=scores[0][2];
        sum/3.0;

        int sum = 0;
        sum+=scores[1][0];
        sum+=scores[1][1];
        sum+=scores[1][2];
        sum/3.0;

        .....
    */
    for(int i=0;i<scores.length;i++){
        int sum = 0;
        for(int j=0;j<scores[i].length;j++){
            sum+=scores[i][j];
        }
        System.out.println("学生"+(i+1)+"的总成绩："+sum+",平均成绩："+(int)((sum/3.0)*100)/100.0);
    }
    /*
        计算每科的总成绩和平均成绩
        int total_sum = 0;
        total_sum+=scores[0][0];
        total_sum+=scores[1][0];
        total_sum+=scores[2][0];
        total_sum+=scores[3][0];
        total_sum+=scores[4][0];
        total_sum+=scores[5][0];
        .....
        total_sum/10.0

        int total_sum = 0;
        total_sum+=scores[0][1];
        total_sum+=scores[1][1];
        total_sum+=scores[2][1];
        total_sum+=scores[3][1];
        total_sum+=scores[4][1];
        total_sum+=scores[5][1];
        .....
        total_sum/10.0

        int total_sum = 0;
        total_sum+=scores[0][2];
        total_sum+=scores[1][2];
        total_sum+=scores[2][2];
        total_sum+=scores[3][2];
        total_sum+=scores[4][2];
        total_sum+=scores[5][2];
        .....
        total_sum/10.0

    */
    /*
      顺便统计每科的最高分与最低分
    */
    for(int i=0;i<scores[0].length;i++){
        int total_sum = 0;
        int max = -1;
        int min = 101;
        for(int j=0;j<scores.length;j++){
            total_sum+=scores[j][i];

            if(max<scores[j][i]){
                max = scores[j][i];
            }
            if(min>scores[j][i]){
                min = scores[j][i];
            }
        }
        System.out.println("学科"+(i+1)+"的总成绩："+total_sum+",平均成绩："+total_sum/10.0+",最高分："+max+",最低分："+min);
    }

}

}