Java的植物大战僵尸源码 java写植物大战僵尸

转载

新新人类 2024-03-11 13:09:09

文章标签 Java的植物大战僵尸源码 java 算法数组 System 文章分类 Java 后端开发

一、方法

1.方法概述

假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。

2.方法定义及格式

简单的说：方法就是完成特定功能的代码块

在很多语言里面都有函数的定义
函数在Java中被称为方法

格式：

修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2…) { 函数体; return 返回值; }

3.方法格式的解释说明

方法格式解释

修饰符比较多，后面会详细介绍。目前public static
返回值类型用于限定返回值的数据类型
方法名一个名称，为了方便我们调用方法
参数类型限定调用方法时传入参数的数据类型
参数名是一个变量，接收调用方法时传入的参数
方法体完成功能的代码 return 结束方法以及返回方法指定类型的值
返回值程序被return带回的结果，返回给调用者

4.方法案例

如何写一个方法呢？两个明确

返回值类型明确功能结果的数据类型
参数列表明确有几个参数，以及参数的类型

按照格式和两个明确来完成如下功能

求两个数据之和的案例

package com.shujia.java.sx.day05;
/*
        方法：
            方法就是完成特定功能的代码块
                在很多语言里面都有函数的定义
                函数在Java中被称为方法
        语句格式：
            修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
			        函数体;
			        return 返回值;
            }

        名词解释：
            修饰符：修饰符比较多，后面在面向对象中详细介绍，
                    目前你只需要记住public static

            返回值类型：
                就是return返回的值的类型


            方法名：
                一个名词，为了方便我们的调用方法，自己起个名字

            参数：
                1、形参
                    定义在方法上的参数名
                2、实参
                    实际调用方法的时候传入的值叫实参

            参数类型：
                限定调用方法传入参数的数据类型

            参数名：（形参）
                就是一个变量，接收调用方法时传入的参数

            函数体：
                完成功能的代码，实现方法的主要功能

            return:
                结束方法以及返回方法指定类型的值

            返回值：
                程序被return带回的结果，返回给调用者



 */
public class FunctionDemo1 {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
//        int c = x+y;
//        System.out.println(c);
        //赋值调用，推荐方式
        int sum1 = sumNum(x,y); //sum
        System.out.println(sum1);
        //输出调用，这个方式有意义，但是不够好，
        // 如果我们后续好需要继续在这个结果上做操作的话就没办法完成了
//        System.out.println(sumNum(x,y));
        //方法里面又定义了一个方法，这样做法是错误的
        //方法与方法是平级关系，不能嵌套定义
        //可以在方法中调用其他方法
//        public static int sumNum(int a,int b){
//            int sum = 0;
//            sum = a+b;
//            return sum;
//        }
    }
    public static int sumNum(int a,int b){
        int sum = 0;
        sum = a+b;
        return sum;
    }
//    public static int sumNum(int a,int b){
//        int sum = 0;
//        sum = a+b;
//        return sum;
//    }
//    public static int sumNum(int a,int b,int c){
//        int sum = 0;
//        sum = a+b+c;
//        return sum;
//    }
}

5.有明确返回值的方法调用

有明确返回值的方法调用：

单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式

6.方法注意事项

方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要有return带回一个值

7.有明确返回值的方法举例

键盘录入两个数据，比较两个数是否相等

package com.shujia.java.sx.day05;
/*
    比较两个数据是否相等，参数类型为两个byte类型
 */
public class FunctionDemo6 {
    public static void main(String[] args) {
        byte a = 2;
        byte b = 3;
        boolean res = compareEquals(a,b);
        System.out.println(res);
    }
    public static boolean compareEquals(byte a1,byte b1){
        return a1 == b1;
    }
}

8.没有明确返回值的方法调用

没有明确返回值的函数调用：

其实就是void类型方法的调用
只能单独调用

返回值为void类型的方法举例：

键盘录入行数和列数，输出对应的星形

package com.shujia.java.sx.day05;
import java.util.Scanner;
public class FunctionDemo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数：");
        int n = sc.nextInt();//行数
        System.out.println("请输入列数：");
        int m = sc.nextInt();//列数

        //输出4行4列的星星
        printStar(n,m);
//        System.out.println("==========");
//        printStar();
    }
    public static void printStar(int n, int m) {
        for (int i=1;i<=n;i++) {
            for (int j=1;j<=m;j++) {
                System.out.print("*"+"\t");
            }
            System.out.println();
        }
    }
}

9.方法重载

方法重载概述

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载特点

与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法

二、数组

1.数组概述

数组概述

需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。
那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：

数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致

2.数组的概念

数组概念

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式

格式1：数据类型[] 数组名;
格式2：数据类型数组名[];
注意：这两种定义做完了，数组中是没有元素值的，如何对数组的元素进行初始化呢?

3.数组的初始化

数组初始化概述：

Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组的初始化方式

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：

int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

格式：

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

举例：

int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法

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

4.Java中的内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈存储局部变量
堆存储new出来的东西
方法区 (面向对象部分讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

5.数组操作常见的两个小问题

数组索引越界

ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。

空指针异常

NullPointerException
数组引用没有指向实体，却在操作实体中的元素时。

6.数组练习

数组遍历(依次输出数组中的每一个元素)
数组获取最大值

package com.shujia.java.sx.day05;
public class ArrayDemo3 {
    public static void main(String[] args) {
        double [] data =  {1.6,1.8,2.6,3.4};
        //打印所有数组元素
        for(int i = 0;i<data.length;i++){
            System.out.println(data[i]);
        }
    //计算所有元素的总和
        double num = 0;
        for (int i =0;i<data.length;i++){
            num+=data[i];
        }
        System.out.println("所有元素的总和为:"+num);
        //查找元素中的最大值
        double max = data[0];
        for (int i =1;i<data.length;i++){
            if(data[i]>max){
                max = data[i];
            }
        }
        System.out.println("所有元素中最大的那个数是:"+max);
    }
}

数组元素查找(查找指定元素第一次在数组中出现的索引)

package com.shujia.java.sx.day05;
import java.util.Arrays;
import java.util.Scanner;
/*
            要求:输入一个数字，在数组中查找，若有输出小标，若没有输出-1；

 */
public class ArrayDemo5 {
    public static void main(String[] args) {

        //  要求:编写JAVA程序，实现两个数组的合并，并按升序排列合并后的数组
        //       假定现有两个数组，分别为：
                Scanner sc = new Scanner(System.in);
                int [] arr = {12,23,56,32,75,48,25,46,68};
                System.out.println("输入一个数字:");
                int sz = sc.nextInt();
                for (int i = 0;i<arr.length;i++){
                    if (sz ==arr[i]){
                        System.out.println("数字下标为"+i);
                        return;
                    }
                }
                System.out.println("-1");
        //       int[ ] arr1={3, 1, 23};
        //       int[ ] arr2={27, 7, 2};
        //       设计程序，将两个数组合并成一个数组，并按升序排列合并后的数组，
        //       输出合并前和合并后的数组信息
        int [] arr1 = {3,1,23};
        int [] arr2 = {27,7,2};
        int [] arr3 =new int[arr1.length+arr2.length];//定义一个数组arr3长度为arr1和arr2长度之和
        for(int i =0;i<arr1.length;i++){
            arr3 [i] =arr1[i];
        }
        for (int i = 0;i<arr2.length;i++){
            arr3[arr1.length+i]=arr2[i];
        }
        for (int i = 0;i<arr3.length-1;i++){
            for (int j =0;j<arr3.length-i-1;j++){
                if (arr3[j]>arr3[j+1]){
                    int temp = arr3[j];
                    arr3[j] = arr3[j+1];
                    arr3[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i]+"  ");
        }
    }
}

7.二维数组概述

二维数组概述

我们大数据的班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个大数据班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。
由此可见：其实二维数组其实就是一个元素为一维数组的数组。

8.二维数组定义格式

格式一：

数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例：

int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取

表示获取第m+1个一维数组的第n+1个元素

格式二：

数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：

int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3]
arr[2] = new int[1];

格式三：

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：

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

9.二维数组练习

二维数组遍历

package com.shujia.java.sx.day06;
/*
    数组遍历(依次输出数组中的每一个元素)

 */
public class ArrayDemo6 {
    public static void main(String[] args) {
        //定义一个一维数组，元素类型为int类型，并且长度为3，用动态初始化
        int[] arr = new int[3];
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("====用for循环改进===========");

        for(int i=0;i<3;i++){
            System.out.println(arr[i]);
        }
        //由于我们上面的数组元素个数可以一眼看出来是多少，所以我们在遍历的时候知道给多大范围
        //但是呢，我们的数组元素过多的时候，你还数的过来吗？数不过来
        //那怎么办呢？
        //数组在Java中提供了一个属性可以方便我们获取数组元素的个数（数组的长度）
        //这个属性叫做：length
        //使用格式：
        //      数组名.length
        int[] arr2 = {11,23,123,214,123,12,4,12312,1312,31,3,213,21,3,213,21,321,3,213,213,21,321,3,213,21,312,3,4,3,54,5,435,56,43,53,5,46,5,6,4,5,645,99};
        System.out.println("arr2数组的长度为："+arr2.length);
        System.out.println("====用length属性获取数组长度加入到for循环遍历==========================");
//        for(int i=0;i<arr2.length;i++){
//            System.out.println(arr2[i]);
//        }
//        for(int i=0;i<arr2.length;i++){
//            System.out.print(arr2[i]);
//        }
        System.out.println("==标准输出数组格式====================");
        for(int i=0;i<arr2.length;i++){
            //当i等于length-1的时候，说明下标索引已经取到了最后一个元素
            if(i == arr2.length-1 ){
                System.out.println(arr2[i]+"]");
            }else if(i == 0){
                System.out.print("["+arr2[i]+",");
            }else {
                System.out.print(arr2[i]+",");
            }
        }
    }
}

打印杨辉三角形(行数可以键盘录入)

package com.shujia.java.sx.day06;
import java.util.Scanner;
/*
        需求：打印杨辉三角形（行数可以键盘录入）
        1
        1 1
        1 2 1
        1 3 3 1
        1 4 6 4 1
        1 5 10 10 5 1
        分析：看这种图像的规律
              A：任何一行的第一列和最后一列都是一
              B：从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和，
         步骤：
               A：首先定义一个二维数组，行数如果是n ，我们把列数也定义为n。
               B：给这个二维数组任何一行的第一列和最后一列赋值为1
               C：按照规律给其他元素赋值
                    从第三行开始，每一个数据是它上一行的的前一列和它上一行的本列之和
               D：遍历这个二维数组

 */
public class yanghuisanjiao {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //这个n的数据来自键盘录入
        System.out.println("请输入一个数据:");
        int n = sc.nextInt();
        //定义一个二维数组
        int [] [] arr =new int [n][n];
        //给这个二维数组任何一行的第一列和最后一列赋值
        for(int x =0;x<arr.length;x++){
           arr[x][0] = 1;//任何一行第一列
           arr[x][x] = 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<arr[x].length;y++){
//                System.out.print(arr[x][y]+"\t");
//            }
//            System.out.println();
        //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
        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();
        }
    }
}

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