java二维数组四列求每列最大值

转载

棉花糖 2024-09-13 22:55:25

文章标签 java二维数组四列求每列最大值二维数组面向对象封装继承 文章分类 Java 后端开发

1:二维数组(掌握)

2:两个思考题(理解)

3:面向对象(掌握)

1:二维数组(掌握)

(1)元素是一维数组的数组。

(2)格式：

格式1：

数据类型[][] 数组名= new 数据类型[m][n];

m:表示这个二维数组有多少个一维数组。

n:表示每一个一维数组的元素有多少个。

注意：

A:以下格式也可以表示二维数组

a:数据类型数组名[][] = new 数据类型[m][n];

b:数据类型[]数组名[] = new 数据类型[m][n];

B:注意下面定义的区别

int x;

int y;

int x,y;

int[] x;

int[] y[];

int[] x,y[];

格式2：

数据类型[][] 数组名= new 数据类型[m][];

m:表示这个二维数组有多少个一维数组。

列数没有给出，可以动态的给。这一次是一个变化的列数。

格式3：

基本格式：

数据类型[][]数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}};

简化版格式：

数据类型[][]数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

举例：

int[][] arr = newint[][]{{1,2,3},{4,5,6},{7,8,9}};

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

(3)案例(掌握):

A:二维数组的遍历

class Array2Test {
   publicstatic void main(String[] args) {
          //其实，外面的这个循环的长度就是二维数组的长度
          //用方法改进
          //调用方法
          printArray2(arr);
          int[][] arr2 = {{1,2,3},{4,5},{6}};
          printArray2(arr2);
   }
   /*
          需求：遍历二维数组
          两个明确：
                 返回值类型：void
                 参数列表：int[][] arr
   */
   publicstatic void printArray2(int[][] arr) {
          for(int x=0; x<arr.length; x++) {
                 for(inty=0; y<arr[x].length; y++) {
                        System.out.print(arr[x][y]+"");
                 }
                 System.out.println();
          }
   }
}

B:二维数组的求和

class Array2Test2 {
       publicstatic void main(String[] args) {
              //把题目的数据用二维数组来表示
              int[][] arr ={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
              //定义一个求和变量sum，初始化值是0。
              int sum = 0;
              //通过遍历就可以得到每一个二维数组的元素。
              for(int x=0; x<arr.length; x++) {
                     for(inty=0; y<arr[x].length; y++) {
                            //把元素累加即可。
                            sum += arr[x][y];
                     }
              }
              //最后输出sum，就是结果。
              System.out.println("一年的销售额为："+sum+"万元");
       }
}

C:杨辉三角形

class Array2Test3 {
     public static voidmain(String[] args) {
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            //这个n的数据来自于键盘录入。
            System.out.println("请输入一个数据：");
            int n = sc.nextInt();
           
            //定义二维数组
            int[][] arr = new int[n][n];
            //给这个二维数组任何一行的第一列和最后一列赋值为1
            for(int x=0; x<arr.length; x++) {
                   arr[x][0] = 1; //任何一行第1列
                   arr[x][x] = 1; //任何一行的最后1列
            }
            //按照规律给其他元素赋值
            //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
            for(int x=2; x<arr.length; x++) {
                   //这里如果y<=x是有个小问题的，就是最后一列的问题
                   //所以这里要减去1
                   //并且y也应该从1开始，因为第一列也是有值了
                   for(int y=1;y<=x-1; y++) {
                          //每一个数据是它上一行的前一列和它上一行的本列之和。
                          arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
                   }
            }
            //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
            for(int x=0; x<arr.length; x++) {
                   for(int y=0;y<=x; y++) {
                          System.out.print(arr[x][y]+"\t");
                   }
                   System.out.println();
            }
     }}

2:两个思考题(理解)

(1)Java中的参数传递问题

Java中只有值传递。

基本类型：形式参数的改变不影响实际参数

引用类型：形式参数的改变直接影响实际参数

class ArgsDemo {
   publicstatic void main(String[] args) {
          int a = 10;
          int b = 20;
          System.out.println("a:"+a+",b:"+b);           //a:10,b:20
          change(a,b);
          System.out.println("a:"+a+",b:"+b);           //???        a:10,b:20
          int[] arr = {1,2,3,4,5};
          change(arr);
          System.out.println(arr[1]);                         //???        4
   }
   publicstatic void change(int a,int b) { //a=10,b=20
          System.out.println("a:"+a+",b:"+b);           //a:10,b:20
          a = b;      //a=20
          b = a + b; //b=40
          System.out.println("a:"+a+",b:"+b);           //a:20,b:40
   }
   publicstatic void change(int[] arr) { //arr={1,2,3,4,5};
          for(int x=0; x<arr.length; x++) {
                 if(arr[x]%2==0){
                        arr[x]*=2;
                 }
          }
          //arr={1,4,3,8,5};
   }
}

(2)数据加密问题

综合的小案例。

某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，

在传递过程中需要加密，加密规则如下：

首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，

最后将第一位和最后一位数字交换。请任意给定一个小于8位的整数，

然后，把加密后的结果在控制台打印出来。

题目要求：

A:数据是小于8位的整数

定义一个int类型的数据

int number = 123456;

B:加密规则

a:首先将数据倒序

结果 654321

b:然后将每位数字都加上5，再用和除以10的余数代替该数字

结果 109876

c:最后将第一位和最后一位数字交换

结果 609871

C:把加密后的结果输出在控制台

通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。

不是直接写成这个样子的：

int[] arr = {1,2,3,4,5,6};

如何把数据转成数组呢?

A:定义一个数据

intnumber = 123456;

B:定义一个数组,这个时候问题就来了，数组的长度是多少呢?

int[]arr = new int[8]; //不可能超过8

在赋值的时候，我用一个变量记录索引的变化。

定义一个索引值是0

intindex = 0;

C:获取每一个数据

intge = number%10

intshi = number/10%10

intbai = number/10/10%10

arr[index]= ge;

index++;

arr[index]= shi;

index++;

arr[index]= bai;

...

class JiaMiDemo2 {
   publicstatic void main(String[] args) {
          //创建键盘录入对象
          Scanner sc = new Scanner(System.in);
          //请输入一个数据
          System.out.println("请输入一个数据(小于8位)：");
          int number = sc.nextInt();
         
          //写功能实现把number进行加密
          //调用
          String result = jiaMi(number);
          System.out.println("加密后的结果是："+result);
   }
   /*
          需求：写一个功能，把数据number实现加密。
          两个明确：
                 返回值类型：String 做一个字符串的拼接。
                 参数列表：int number
   */
   publicstatic String jiaMi(int number) {
          //定义数组
          int[] arr = new int[8];
          //定义索引
          int index = 0;
          //把number中的数据想办法放到数组中
          while(number > 0) {
                 arr[index]= number%10;      //此处已实现了数据的倒序
                 index++;
                 number/= 10;                      //避免死循环
          }
          //把每个数据加5，然后对10取得余数
          for(int x=0; x<index; x++) {
                 arr[x]+= 5;
                 arr[x]%= 10;
          }
          //把第一位和最后一位交换
          int temp = arr[0];
          arr[0] = arr[index-1];
          arr[index-1] = temp;
          //把数组的元素拼接成一个字符串返回
          //定义一个空内容字符串
          String s = "";
          for(int x=0; x<index; x++) {
                 s+= arr[x];
          }
          return s;
   }
}

3:面向对象(掌握)

(1)面向对象：是基于面向过程的编程思想

面向过程：强调的是每一个功能的步骤

面向对象：强调的是对象，然后由对象去调用功能

(2)面向对象的思想特点

A:是一种更符合我们思考习惯的思想

B:把复杂的事情简单化

C:让我们从执行者变成了指挥者

举例：

买电脑：

面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑

面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了

洗衣服：

面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来

面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来

吃饭：

面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃

面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃

(3)类与对象

A:现实世界的事物

属性事物的基本描述

行为事物的功能

B:Java语言中最基本的单位是类。所以，我们要用类来体现事物

C:类

成员变量事物属性

成员方法事物行为

D:类：是一组相关的属性和行为的集合。是一个抽象的概念。

对象：是该类事物的具体存在，是一个具体的实例。(对象)

学生事物：

属性：姓名，年龄，地址...

行为：学习，吃饭，睡觉...

把事物要转换为对应的类：

学生类：

成员变量：姓名，年龄，地址...

成员方法：学习，吃饭，睡觉...

(4)类的定义及使用

A:类的定义

成员变量定义格式和以前一样，就是位置不同，在类中，方法外。

成员方法定义格式和以前一样，就是去掉了static。

B:使用类的内容

a:创建对象

格式：类名对象名 = new 类名();

b:如何使用成员变量和成员方法呢

对象名.成员变量

对象名.成员方法()

(6)案例：

A:手机类的定义和使用

class Phone {
   //品牌
   Stringbrand;
   //价格
   intprice;
   //颜色
   Stringcolor;
   //打电话的方法
   publicvoid call(String name) {
          System.out.println("给"+name+"打电话");
   }
   //发短信的方法
   publicvoid sendMessage() {
          System.out.println("群发短信");
   }
   //玩游戏的方法
   publicvoid playGame() {
          System.out.println("玩游戏");
   }
}
class PhoneDemo {
   publicstatic void main(String[] args) {
          //创建手机对象
          //类名 对象名 = new 类名();
          Phone p = new Phone();
          //直接输出成员变量值
          System.out.println(p.brand+"---"+p.price+"---"+p.color);
          //给成员变量赋值
          p.brand = "诺基亚";
          p.price = 100;
          p.color = "灰色";
          //再次输出
          System.out.println(p.brand+"---"+p.price+"---"+p.color);
          //调用方法
          p.call("林青霞");
          p.sendMessage();
          p.playGame();
   }
}

(8)Java程序的开发，设计和特征

A: 面向对象开发：就是不断的创建对象，使用对象，指挥对象做事情

B: 面向对象设计：就是管理和维护对象间的关系

C: 面向对象特征

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。