Java基础练习（矩阵的加减乘除运算）

简介

        对于有了解，但是了解不深的同学，学习Java总是感觉一看就会，一些就废。往往需要一些实操练习，来夯实我们的学习结果。九九乘法表和计算器都是在编程学习领域比较经典的案例。本文为大家讲解一下两个基础实操，熟悉一下随机数、遍历循环，返回值接收、类的调用 、静态方法和非静态方法的调用方法 。

飞机票折扣

用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况进行相应的优惠，优惠方案如下:5-10月为旺季，头等舱9折，经济舱8.5折; 11月到来年4月为淡季，头等舱7折，经济舱6.5折，请开发程序计算出用户当前机票的优惠价。

public class Test1 {
    public static void main() {

        System.out.println("Java实操练习");
    }
//    public static void和public void  两种语法得区别
//    Scanner falg = new Scanner;  如何将键盘输入传入下面得方法中

//    Scanner scanner=new Scanner(System.in);

    public  double tickets(String flag,double price, int month) {
//        arge参数是否可用
//        经济舱价格
        double y = 0 ;
//        头等舱价格
        double z = 0 ;
//        判断是否旺季
        boolean x = month>=5 && month <=10;
        //           如果是旺季 头等舱、经济舱对应打折
        if (x) {
//               经济舱折扣后价格
            y = price * 0.9;
//               头等舱折后价格
            z = price * 0.85;
            if (flag.equals("经济舱")){
                return y;
            }else {
                return z;
            }

        } else {
//               经济舱折扣后价格
            y = price * 0.65;
//               头等舱折后价格
            z = price * 0.7;
            if (flag.equals("经济舱")){
                return y;
            }else {
                return z;
            }
        }

    }


// 使用if语法  进行变换写法
    public static double if_tickets(String flag,double price, int month) {
        //        arge参数是否可用
//        经济舱价格
        double y = 0 ;
//        头等舱价格
        double z = 0 ;
//        判断是否旺季
        boolean x = month>=5 && month <=10;
        if (x){
            //               经济舱折扣后价格
            y=price*0.9;
//               头等舱折后价格
            z=price*0.85;
            if(flag .equals( "经济舱")){
                return y;
            }else {
                return z;
            }
        }else {
            //               经济舱折扣后价格
            y=price*0.65;
//               头等舱折后价格
            z=price*0.7;
            if(flag .equals( "经济舱")){
                return y;
            }else{
                return z;
            }
        }

    }

}

以上案例中主要考察学者对于 一class多method  的创建语法，if判断分支的语法，以及关键字viod 对于return 返回值的影响，

在创建method中如何有设置返回值，viod需要更改为以返回值同一数据类型。

在创建static method中如果带有static 称之为静态方法，没有带static 的称之为非静态方法。两种区别主要在于调用上的区别。以下通过举例调用方法，进行展示其区别。

method 调用

public class MethodCall {
    public static void main(String[] args) {
        //        调用一个静态main method   可以直接调用
        Test1.main();
//        调用非静态method tickets 需先创建一个Test1实例
        Test1 x1 =new Test1();
        double x2=x1.tickets("经济擦仓",4548,02);
//        调用静态方法可以直接调用
        double x3 = Test1.if_tickets("经济擦仓", 4548, 02);
        System.out.println(x3);
        System.out.println(x2);
    }
}

效果展示

思考

如何通过 

import java.util.Scanner;

模块，进行键盘输入对应的值传入method方法中去。

如何通过

import java.util.Random;

模块，进行随机输入对应的值传入method方法中去。

       

关键字说明 

在以上类中我们创建了三个method 分别是

public static void main(String[] args) 、

public  double tickets、

public static double if_tickets、

这个以main方法的为例说明一下各个关键字

public：这个关键字表示这个方法可以从任何地方被访问。这意味着你可以通过类名来调用这个方法，而不需要创建类的实例。
static：这个关键字表示这个方法是一个静态方法。静态方法可以被类直接调用，而不需要创建类的实例。此外，静态方法不能访问非静态变量和方法。
void：这个关键字表示这个方法没有返回值。如果一个方法返回值类型为 void，那么它将不会返回任何值。
main：这是 Java 程序的入口地址，Java 虚拟机运行程序的时候首先找的就是 main 方法。只有有 main 方法的 Java 程序才能够被 Java 虚拟机运行，可理解为规定的格式。

矩阵的加减乘除运算 

本文在Java使用list的方法创建3*3的矩阵，在java中也有二维数组可以创建创建3*3的矩阵。

这里涉及到一些简单的矩阵运算规则,不再做解释。

//java 在矩阵运算中的实现
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Matrix {
    public static void main(String[] args) {
//        生成一个A矩阵
        Random r1 = new Random();
        int a1 =r1.nextInt(100)-50;
        int a2 =r1.nextInt(100)-50;
        int a3 =r1.nextInt(100)-50;
        int a4 =r1.nextInt(100)-50;
        int a5 =r1.nextInt(100)-50;
        int a6 =r1.nextInt(100)-50;
        int a7 =r1.nextInt(100)-50;
        int a8 =r1.nextInt(100)-50;
        int a9 =r1.nextInt(100)-50;
        List<Integer> list1=new ArrayList<>();
        list1.add(a1);
        list1.add(a2);
        list1.add(a3);
        List<Integer> list2=new ArrayList<>();
        list2.add(a4);
        list2.add(a5);
        list2.add(a6);
        List<Integer> list3=new ArrayList<>();
        list3.add(a7);
        list3.add(a8);
        list3.add(a9);
        List<List> lists=new ArrayList<>();
        lists.add(list1);
        lists.add(list2);
        lists.add(list3);
        System.out.println("矩阵名称为:Lists");
        System.out.println("以下打印的是a1,a2,a3,a4,a5,a6,a7,a8,a9的对应值");
        System.out.println("a1:"+a1+",\n"+"a2:"+a2+",\n"+"a3:"+a3+",\n"+"a4:"+a4+",\n"+"a5:"+a5+",\n"+"a6:"+a6+",\n"+"a7:"+a7+",\n"+"a8:"+a8+",\n"+"a9:"+a9);
//        创建一个矩阵
        for (int i = 0; i < lists.size(); i++) {
            System.out.println(lists.get(i));
        }

//        生成一个B矩阵
        int b1 =r1.nextInt(100);
        int b2 =r1.nextInt(100);
        int b3 =r1.nextInt(100);
        int b4 =r1.nextInt(100);
        int b5 =r1.nextInt(100);
        int b6 =r1.nextInt(100);
        int b7 =r1.nextInt(100);
        int b8 =r1.nextInt(100);
        int b9 =r1.nextInt(100);
        List<Integer> listb1=new ArrayList<>();
        listb1.add(b1);
        listb1.add(b2);
        listb1.add(b3);
        List<Integer> listb2=new ArrayList<>();
        listb2.add(b4);
        listb2.add(b5);
        listb2.add(b6);
        List<Integer> listb3=new ArrayList<>();
        listb3.add(b7);
        listb3.add(b8);
        listb3.add(b9);
        List<List> listsb = new ArrayList<>();
        listsb.add(listb1);
        listsb.add(listb2);
        listsb.add(listb3);
        System.out.println("矩阵名称为:Listsb");
        System.out.println("以下打印的是b1,b2,b3,b4,b5,b6,b7,b8,b9的对应值");
        System.out.println("b1:"+b1+",\n"+"b2:"+b2+",\n"+"b3:"+b3+",\n"+"b4:"+b4+",\n"+"b5:"+b5+",\n"+"b6:"+b6+",\n"+"b7:"+b7+",\n"+"b8:"+b8+",\n"+"b9:"+b9);
//(a1*b1)+(a2*b4)+(a3*b7)
        for (int i1 = 0; i1 < listsb.size(); i1++) {
            System.out.println(listsb.get(i1));
        }
//实现矩阵Listsb+Lists
        List<Integer> listc1=new ArrayList<>();
        listc1.add(a1+b1);
        listc1.add(a2+b2);
        listc1.add(a3+b3);
        List<Integer> listc2=new ArrayList<>();
        listc2.add(a4+b4);
        listc2.add(a5+b5);
        listc2.add(a6+b6);
        List<Integer> listc3=new ArrayList<>();
        listc3.add(a7+b7);
        listc3.add(a8+b8);
        listc3.add(a9+b9);
        List<List> listsc = new ArrayList<>();
        listsc.add(listc1);
        listsc.add(listc2);
        listsc.add(listc3);
        System.out.println("实现矩阵Listsb+Lists");
        for (int ic = 0; ic < listsc.size(); ic++) {
            System.out.println(listsc.get(ic));
        }
        List<Integer> listd1=new ArrayList<>();
        listd1.add(a1-b1);
        listd1.add(a2-b2);
        listd1.add(a3-b3);
        List<Integer> listd2=new ArrayList<>();
        listd2.add(a4-b4);
        listd2.add(a5-b5);
        listd2.add(a6-b6);
        List<Integer> listd3=new ArrayList<>();
        listd3.add(a7-b7);
        listd3.add(a8-b8);
        listd3.add(a9-b9);
        List<List> listsd = new ArrayList<>();
        listsd.add(listd1);
        listsd.add(listd2);
        listsd.add(listd3);
        System.out.println("实现矩阵Listsb-Lists");
        for (int id = 0; id < listsd.size(); id++) {
            System.out.println(listsd.get(id));
        }
        List<Integer> liste1=new ArrayList<>();
        liste1.add((a1*b1)+(a2*b4)+(a3*b7));
        liste1.add((a1*b2)+(a2*b5)+(a3*b8));
        liste1.add((a1*b3)+(a2*b6)+(a3*b9));
        List<Integer> liste2=new ArrayList<>();
        liste2.add((a4*b1)+(a5*b4)+(a6*b7));
        liste2.add((a4*b2)+(a5*b5)+(a6*b8));
        liste2.add((a4*b3)+(a5*b6)+(a6*b9));
        List<Integer> liste3=new ArrayList<>();
        liste3.add((a7*b1)+(a8*b4)+(a9*b7));
        liste3.add((a7*b2)+(a8*b5)+(a9*b8));
        liste3.add((a7*b3)+(a8*b6)+(a9*b9));
        List<List> listse = new ArrayList<>();
        listse.add(liste1);
        listse.add(liste2);
        listse.add(liste3);
        System.out.println("实现矩阵Listsb*Lists");
        for (int ie = 0; ie < listse.size(); ie++) {
            System.out.println(listse.get(ie));
        }
    }
}

方法调用

public class MethodCall {
    public static void main(String[] args) {
        //        调用一个静态main method   可以直接调用
        Test1.main();
//        调用非静态method tickets 需先创建一个Test1实例
        Test1 x1 =new Test1();
        double x2=x1.tickets("经济擦仓",4548,02);
//        调用静态方法可以直接调用
        double x3 = Test1.if_tickets("经济擦仓", 4548, 02);
        System.out.println(x3);
        System.out.println(x2);
        Matrix.main(new String[]{"矩阵调用"});
    }
}

关键字说明

这里的Matrix.main(new String[]{"矩阵调用"});  是以上创建的阵列的method名称且为main ， 在我们创建main的时候会默认生成一个

String[] args 

代表一个名为args的变量，其数据类型为字符串数组。由于创建main是一个static 所以是可以直接调用的，而不需要创建实例。但是在main创建的时候有默认的参数，所以在调用的时候需要再次填入一个参数的值。

在Matrix类main的创建关键字中使用了viod 代表其方法没有返回值，所以也不需要创建变量对其返回值进行接收。

思考

使用Java的 二维数组实现以上同样的功能。