4 function _ Array

4 function _ Array

Lead

Think of writing

2. ArrayDemo
3. ArrayDemo2
4. ArrayDemo3
5. ArrayTest
6. ArrayTest2
7. MethodDemo
8. MethodDemo2
9. MethodDemo3
10. MethodTest
11. Test

1. ArrayDemo

class ArrayDemo 
    {
        public static void main(String[] args) 
        {
    
    
            /*
            数组的定义方式：
            元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
            好处：数组可以存储多个数据，而且可以对数据进行编号，
            从0开始。操作元素完成可以通过编号(索引)完成。
            */
            int[] arr = new int[3];//通过new关键字创建了一个长度为3，元素类型是int的数组实体。
    
            System.out.println(arr[1]);
    
    
    
            /*
            Java对内存空间的划分：五部分：
            栈，堆，方法区，本地方法区，寄存器。
    
            栈内存：存储都是局部变量。只要是在方法中定义的变量都是具备变量。
                    一旦变量的生命周期结束该变量就被释放。
    
            堆内存：存储都是实体(对象)
                    每一个实体都有一个首地址值。
                    堆内存的变量都有默认初始化值。不同类型不一样。int-0  double-0.0  boolean-false char-'\u0000'
                    当实体不在使用时，就会被垃圾回收机制处理。
            */
        }
    } 

2. ArrayDemo2

class ArrayDemo2 
    {
        public static void main(String[] args) 
        {
    
            int[] arr = new int[3];
    
    
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException：访问到了数组不存在的索引时，会发生该异常。
    
            arr = null;
            System.out.println(arr[0]);//NullPointerException:当使用没有任何实体指向的引用变量操作实体时，运行会发生该异常。
        }
    } 

3. ArrayDemo3

class ArrayDemo3 
    {
        public static void main(String[] args) 
        {
    
            //数组定义格式二：
            //int[] arr = new int[]{34,12,89};
    
            int[] arr = {34,12,89,50,11,78};
            //如何获取数组的长度呢？通过数组的属性 length
            System.out.println(arr.length);
            for(int x=0; x<arr.length; x++)
            {
                System.out.println("arr["+x+"]="+arr[x]);
            }
    
    
        }
    } 

4. ArrayTest

class ArrayTest 
    {
        public static void main(String[] args) 
        {
    
            int[] arr = {23,14,22,88,45,90,17};
            int[] arr2 = {3,1,45,7,9};
            int sum = add(arr2);
    
            System.out.println("Hello World!");
        }
        //获取多个数的和的功能。
        /*
        明确1：结果？和 int。
        明确2：参数？多个数，定义多个参数合适吗？既然是一组数，数组。
        */
        public static int add(int[] arr)
        {
            //1,定义变量记录和。
            int sum = 0;
            //2,通过循环对数组进行遍历。
            for(int x=0; x<arr.length; x++)
            {
                sum = sum + arr[x];
            }
    
            return sum;
        }
    
    
        //两个整数求和的功能。
        public static int add(int a,int b)
        {
            return a+b;
        }
        //三个整数求和。
        public static int add(int a,int b,int c)
        {
            return a+b+c;
        }
    } 

5. ArrayTest2

class ArrayTest2 
    {
        public static void main(String[] args) 
        {
            int[] arr = {23,15,67,25,90,33};
            int max = getMax(arr);
            System.out.println("max="+max);
        }
    
        /*
        需求：获取多个整数中最大值。
        思路：
        1，数据多了为了便于操作，先存储起来。需要容器。用数组。
        2，多个数据需要进行比较。每次都有较大的数，需要记录下来和下一个数比较。
        3，将数组中的元素都比一遍。最后，就有了最大值。
    
        步骤：
        1，需要数组。
        2，定义一个变量记录住较大的数。
        3，对数组进行遍历。让元素和较大的值进行比较。
            如果元素大于较大的数，用变量记录该元素。
        4，遍历完成后，变量中记录就是最大值。
        */
    
        //定义功能。
        /*
        明确1：结果?int
        明确2：参数？int[]
        */
        public static int getMax(int[] arr)
        {
            //1,定义变量。初始化为数组中的任意一个元素。
            int max = arr[0];
    
            //2，遍历数组。
            for(int x=1; x<arr.length; x++)
            {
                //遍历的元素只要比max大，就用max记录下来。遍历到最后max中记录就是最大值。
                if(arr[x]>max)
                    max = arr[x];
            }
            return max;
    
        }
    
    
        public static int getMax_2(int[] arr)
        {
            int max = 0;//初始化为数组中的任意一个角标。
    
            for(int x=1; x<arr.length; x++)
            {
                if(arr[x]>arr[max])
                    max = x;
            }
            return arr[max];
    
        }
    } 

6. MethodDemo

class MethodDemo
    {
        public static void main(String[] args) 
        {
    
            //调用自定义的方法。
            draw(4,5);
    
            draw(8,9);
    
    
        }
    
        /*
        问题：要画矩形，需要不断使用该for嵌套代码。造成代码复用性很差。
        解决：定义一个功能用于画矩形，每次只要使用该功能即可。这样提高复用性。
    
        如何定义一个功能呢？
        1，它应该是一个封闭的区间。就是大括号。
        2，它需要有名称。
        3，需要有参与运算的数据。
        4，需要定义该功能的结果类型。
        */
    
        public static void draw(int row,int col)
        {
            for(int x=0; x<row; x++)
            {
                for(int y=0; y<col; y++)
                {
                    System.out.print("*");
                }
                System.out.println();
            }
    
            //return;
        }
    
    } 

7. MethodDemo2

class MethodDemo2 
    {
        public static void main(String[] args) 
        {
            //int sum = add(2,5);    
            //System.out.println(sum);
            add(2,5);
    
    
        }
    
        /*
        修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
        {
                执行语句;
                return 返回值;//return关键字是用于结束该功能。并将后面的具体结构返回给调用者。
                            //必须有return语句。
        }
    
    
        注意：函数的返回值类型如果是void。时，return语句可以省略不写。return;
                void表示的是没有返回值的情况。
        */
    
        /*
        如何定义一个函数呢?
        函数就是一个功能。
        功能就需要两部分：
        1，结果，2，未知内容。
        明确1：这个功能的结果是什么？
                其实就是明确返回值类型。
        明确2：这个功能需要未知内容是什么？
                其实就是明确参数列表。
        */
    
        //需求:需要一个方法，进行加法运算，获取两个整数的和。
        /*
        明确1：功能的结果是什么呢？是一个和。和是整数。返回值的类型是 int.
        明确2：功能的未知内容有吗？有，加数和被加数。都是int类型，这就是参数列表。
    
        */
        /**/
        public static int add(int a,int b)
        {
            return a+b;
        }
    
    
        /*
        //不要把功能定义成这样，因为，功能内只定义所需的内容。不需要的不定义。
        public static void add(int a,int b)
        {
    
            return ;
        }
        */
    } 

8. MethodDemo3

class MethodDemo3 
    {
        public static void main(String[] args) 
        {
    
            //printCFB(9);
            int sum = add(3,4);
    
            System.out.println(sum);
        }
    
        /*
        函数名定义就是为了描述该功能。
    
        一个类中出现同名的函数，只要他们的参数个数或者参数类型不同，就称之为函数的重载。overload。
        和返回值类型无关。
        */
        //两个整数求和的功能。
        public static int add(int a,int b)
        {
            return a+b;
        }
        //三个整数求和。
        public static int add(int a,int b,int c)
        {
            return a+b+c;
        }
    
        //两个小数的和。
        public static double add(double a,double b)
        {
            return a+b;
        }
    
    
        //九九乘法表。
        public static void printCFB()
        {
            printCFB(9);
        }
    
        public static void printCFB(int num)
        {
            for(int x=1; x<=num; x++)
            {
                for(int y=1; y<=x; y++)
                {
                    System.out.print(y+"*"+x+"="+y*x+"\t");
                }
                System.out.println();
            }
        }
    }
    
    
    /*
    
    void show(int a,float b,char c){}
    
    下列哪些函数和给定函数重载了。
    
    a.
    int show(int x,float y,char z)//没有重载，这个函数不允许和给定函数存在于同一个类中。因为会产生调用的不确定性。
    
    b.
    void show(float b,int a,char c)//重载了，参数类型不同。
    
    c.
    void show(int c,float a,char b)//没有重载，和给定函数一样。不允许存在。
    
    d.
    void show(int a,int b,int c)//重载了，因为类型不同。
    
    e.
    double show()//重载了，因为个数不同。
    */ 

9. MethodTest

class MethodTest 
    {
        public static void main(String[] args) 
        {
            sop("hello world");
    
    
            //System.out.println("Hello World!");
        }
        public static void sop(String str)
        {
            System.out.println(str);
        }
    
        /*
        需求1：定义方法，比较两个数谁大？
        明确1：结果？int
        明确2：参数？int int
        public static int max(int a,int b)
        {
    
            //if(a>b)
                //return a;
            //else 
                //return b;
    
            return a>b?a:b;
        }
    
    
        需求2：判断两个数是否相同。
        结果？boolean。
        参数？int int
        public static boolean isEquals(int a,int b)
        {
            //return a==b?true:false;
    
            return a==b;
        }
    
    
        需求3，定义方法，完成99乘法表的显示。
    
    
    
        需求4，定义方法，获取任意整数的十六进制表现形式，升级为数组版。
    
    
        需求5，定义方法，用于打印给定的字符串信息。String str = "abc";
        public static void sop(String str)
        {
            System.out.println(str);
        }
    
        */
    } 

10. Test

class Test 
    {
        public static void main(String[] args) 
        {
            System.out.println("Hello World!");
        }
    
        /*
        需求1：定义功能，将{34,12,67}数组中的元素转成字符串  "34,12,67"
        */
    
        /*
        需求2：获取整型数组最小值。
        */
    
        /*
        需求3：定义方法，获取任意整数的十六进制表现形式，升级为数组版。
        */
    
        /*
        数组在内存图中分布，要求画图！
        */
    }