Java学习day08-day09-方法

今日目标：

1.参数
2.返回值
3.调用
4.传参
5.重载
6.成员变量

1.方法的理解和语法格式:

1.解决某一件事的功能实现。方法，是一段代码块的封装，方法中的代码应围绕某一功能的实现来写，目标明确，逻辑清晰。方法的语法格式
2.格式：在Java中，声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句
1.方法的调用
2.变量的操作：声明 赋值 修改
3.程序结构：选择结构 循环结构………
return 返回值; }

public static void test1(int a,String b) {//修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．)
System.out.println();//执行语句
return;//返回值
}

对于上面的语法格式中具体说明如下：

• 修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，这些修饰符在后面的学习过程中会逐步介绍
• 返回值类型：用于限定方法返回值的数据类型
• 有返回值：基本数据类型 类和接口 没有返回值：void
• 参数类型：用于限定调用方法时传入参数的数据类型
• 参数名：是一个变量，用于接收调用方法时传入的数据
• return关键字：用于结束方法以及返回方法指定类型的值
• 返回值：被return语句返回的值，该值会返回给调用者

需要特别注意的是，方法中的“参数类型 参数名1，参数类型
参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。

2.为什么有的方法有参数，有的没有？

1.榨汁机榨苹果汁需要苹果。吃饭需要食物。
以上描述的都是一个动作，都可以用程序的方法表示，实现这个动作所需消耗的物资，就对应方法的参数。一般情况下，参数都会在方法体中被使用和改变。
当然，不是所有的方法都需要参数，例如：跑步，说话，睡觉，玩手机，看书。

3.参数分形参和实参（参数的分类）

形参：形式参数，在声明一个方法时，方法名后面的小括号中，就是形参，
格式：（参数数据类型 参数名）
参数的声明同变量的声明（如int a；），只是定义类型，取名字，不赋值。
实参：实际参数，在调用一个方法时，方法名后面的小括号中，就是实参。
格式：（参数值或一个同类型的变量）
补充：方法的状态：方法编写完成后，没有调用的状态叫作方法的声明，被其它方法调用时，叫调用状态。
案例：
榨苹果汁，吃饭，跑步，说话（背诗歌），睡觉，玩手机，看书。
方法调用时是实参，定义时是形参，形参和实参的关系，实参是给形参赋值的。

4.方法的返回值

1.返回值指的是：根据实际的业务需求，对某一功能用程序实现后，需要有一定的产出。
比如：榨一杯苹果汁，最后会产出一杯苹果汁。这个时候就有人会问：参数和返回值之间好像有着某种联系？
其实，这两者之间没有任何必然的联系。也就是说，一个方法，可以有参数，也可以没有参数，可以有参数，没有返回值，也可以有参数，也有返回值…
打个比方：盖房子需要木头，水泥，砖块。这些都是“盖房子”这个方法的参数，但是产出只有一个——房子。再打个比方，“种水稻”这个方法需要的参数有：种子，化肥，除草剂，产出的是大米。可天有不测风云，万一闹灾荒，可能颗粒无收，这个时候，没有产出。当然，我们希望的是每年风调雨顺，国泰民安。再比如，“学习”这个方法，需要的参数是：时间，精力，和思考。可最终是否学业有成，还得看个人在这个过程中是否用心了，有可能学业有成，知识高产出，也有可能中途放弃，或误入歪门邪道，最终没有产出。我们还是祝愿所有的学员能够学员有成！
2.返回值类型定义在方法名的前面，分两种：
有返回值：基本数据类型，和引用数据类型（也就是类和接口）（选做最后一题）
无返回值：void
3.返回值用关键字return 表示。

类的成员：属性和方法


可变形参和数组的区别

public static void main(String[] args) {
        test(1,1.0 ,2.0,3.0);
    }
    public static void test(int a, double... b){
        for (int i = 0; i <b.length ; i++) {
            System.out.println(b[i]);
        }
    }

理解静态和实例

public class Person {
    int a=10;
    static int b=20;
    public static void main(String[] args) {
        System.out.println(Person.b);//20
        //System.out.println(Person.a);
        Person p1=new Person();
        p1.a=6;
        p1.b=6;
        System.out.println("a="+p1.a+"  b="+p1.b);//a=6  b=6
        Person p2=new Person();
        System.out.println(p2.b);//6
        System.out.println(p2.a);//10
    }
}

案例：
种水稻，学习。
1.定义一个方法，模拟水稻种植施肥的过程：参数是肥料的袋数，如果小于5袋， 返回的是“营养不够，舍不得花钱，产量低下，可不要怪我”，如果大 于5袋，输出：“营养充足，可以亩产三千斤！”。

5.方法的调用和传参

1.调用：方法分静态和非静态，同一个类中，静态方法直接调用静态方法，
静态方法调用非静态，要先创建对象，然后再调用。因为静态方法是属于类的，非静态属于对象的。
不同的类中：调用静态方法，直接是类名.方法名（）；调用非静态：创建对象，再调用。同一个类中：

2.传参，调用有多个参数的方法时，传参的顺序一致，数据类型保持一致。
同一个类中

package com;
public class Hello4 {
    //实例方法
    public void fun1(){
        System.out.println("实例方法1");
        //情况3.1 新创建一个对象
        Hello4 h4_1 = new Hello4();
        h4_1.fun1_1();

        //情况3.2 当前对象--谁调用我所在的实例方法，谁就是当前
        this.fun1_1();
        fun1_1();
        System.out.println("方法1中的h4_1:"+h4_1);
        System.out.println("方法1中的this:"+this);
        System.out.println(h4_1==this);

        //情况4
        Hello4.fun2();
        fun2();
    }
    public void fun1_1(){
        System.out.println("实例方法1_1");
    }


    //静态方法
    public static void fun2(){
        System.out.println("静态方法");
    }

    public static void main(String[] args) {
        //情况1
        Hello4.fun2();
        fun2();
        //情况2
        Hello4 h4 = new Hello4();
        h4.fun1();
        Hello4 h5 = new Hello4();
        h5.fun1();
        System.out.println("主方法中的h4:"+h4);
        System.out.println("主方法中的h5:"+h5);
    }
    /*
    1.静态方法 中 调用 静态方法  类名.静态方法() ,可以省略类名
    2.静态方法 中 调用 实例方法  对象名.实例方法()
    3.实例方法 中 调用 实例方法   3.1 新对象.实例方法()  3.2 当前对象this.实例方法()  可以省略this
    4.实例方法 中 调用 静态方法  类名.静态方法() ,可以省略类名
     */
}

不同类中

public class Hello1 {
    public void  fun1(){
        Hello2 h2=new Hello2();//3.实例方法 中 调用另一个类的实例方法  对象名.实例方法()
        h2.fun1();
        Hello2.fun2();//4.实例方法 中 调用另一个类的静态方法  类名.静态方法()
        System.out.println("Hello1的实例方法1");
    }
    public static void  fun2(){
        Hello2.fun2();//1.静态方法 中 调用另一个类的静态方法  类名.静态方法()
        Hello2 h2=new Hello2();//2.静态方法 中 调用另一个类的实例方法  对象名.实例方法()
        h2.fun1();
        System.out.println("Hello1的静态方法2");
    }
}

public class Hello2 {
    public void  fun1(){
        System.out.println("Hello2的实例方法1");
    }
    public static void  fun2(){
        System.out.println("Hello2的静态方法2");
    }
}

6.构造方法（day09）

1.构造方法的作用：开辟内存空间，生成对象，俗称类创建对象的过程叫实例化
特点：方法名和类名相同，没有返回值一说，连void也没有。

2.构造方法分为有参构造和无参构造
无参构造：jvm虚拟机在加载类时会自动创建，每个类都默认有一个无参构造
有参构造：需要开发人员自己去编写，它的作用是：实例化对象的同时，为对象的成员
属性赋值。有参构造=无参构造+set方法

注意：如果开发人员编写了有参构造，那么虚拟机就不会默认生成无参构造。如果仍要使用无参构造，需要手动编写。
案例：以girlfriend类为例，从无参构造演化到有参构造。

无参构造只能创建对象

构造方法快捷键：alt+Insert(或者鼠标右键选择Generate)
点击Constructor

选择即可

构造方法一

对象数组

构造方法二

成员属性与构造方法的个数：n个成员属性（类型不同，如int，double）就有____个构造方法

7.方法的重载

1.同一个类中，同名不同参数的两个或以上的方法叫做方法的重载。
有参构造和无参构造就是典型的方法重载
Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法。
2.如果类中只有有参构造，忘记了写无参构造 ，类中的有参构造会覆盖无参构造
3.如果类中有参构造和无参构造都忘记了写 虚拟机在加载该类的时候会默认帮你生成一个无参构造

有参构造会覆盖默认的无参构造。

3.有参构造中的this指的是，调用该构造方法得到的那个对象。

Public User(String name){
This.name=name;
}
Public User(String name1){
This.name=name1;
}

New User(“张三”);

3.判断是否是重载只看两个因素：1.方法名相同，2.参数不同。
其它的返回值 修饰符什么的都不用看。
例如：println()

8.成员变量和局部变量

成员变量：类的成员，也叫全局变量。全局和局部，哪个作用域大呢？
主方法里的变量也叫局部变量，需要赋值才能输出
作用域又是什么呢？变量的有效使用范围
Java里面的作用域的范围是什么呢？代码块{} 类代码块，方法代码块，循环代码块，无名代码块， try-catch代码块
思考：成员变量和属性又是什么关系呢？同一个东西的不同称呼。从作用域的范围看，叫成员变量，从类的剖析角度来看，叫属性。
方法的参数属于的局部变量，形参相当于变量的声明，实参相当于初始化（赋值）。

作业：

1.需求说明：正确使用带参方法实现学员信息管理，增加学员姓名；在保存了多个学生姓名的数组中，指定查找区间，查找某个学生姓名并显示是否查找成功，程序输出结果如图所示。

package homework.run;

import java.util.Scanner;

public class TestInForMation {
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        InForMation in=new InForMation();
        for (int i = 0; i <in.name.length ; i++) {
            System.out.print("请输入学生姓名： ");
            in.name[i]=sc.next();
        }
        in.fun1();
        int a1,a2;//位置
        String name1;//查找姓名

        System.out.println("请输入开始查找的位置：");
        a1=sc.nextInt();
        System.out.println("请输入结束查找的位置：");
        a2=sc.nextInt();
        System.out.println("请输入查找的姓名：");
        name1=sc.next();
        in.fun2(a1,a2,name1);
    }
}

package homework.run;

import java.util.Scanner;

public class InForMation {
    String name[]=new String[5];
    public void fun1(){
        System.out.println("本班学生列表：");
        for (int i = 0; i <name.length ; i++) {
            System.out.print(name[i]+" ");
        }
        System.out.println();
    }
    public void fun2(int a,int b,String c){
        for (int i = 0; i <name.length ; i++) {
            if(a-1>=0&&b-1<name.length){
                if (name[i].equals(c)){
                    System.out.println("*****查找结果*****");
                    System.out.println("找到了");
                    return;
                }
            }
    }
            System.out.println("没有这个数");
        }

    }

//1 2 3 4 5

2.需求说明：定义学员类，存储学员信息（属性：姓名、成绩；方法：显示个人成绩）。编写修改成绩类，使用学员对象数组作为参数，实现学员成绩修改，条件为：如果学员成绩小于60，集体提高2分。最终输出修改成绩后每个学员的成绩，该程序的输出效果如图所示。
（注：构造学员对象时，使用无参构造方法）

package homework.two;

public class Student {
    String name;
    double achievement;
   /* public  Student(String name,double achievement){
        this.name=name;
        this.achievement=achievement;
        }*/
       public Student(){

       }
}

package homework.two;

public class TestStudent {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.name="张三";
        s1.achievement=45;
        Student s2 = new Student();
        s2.name="李四";
        s2.achievement=80;
        Student s3 = new Student();
        s3.name="王五";
        s3.achievement=84;
        Student s4[]=new Student[]{s1,s2,s3};
        for (int i = 0; i <s4.length ; i++) {
            System.out.println(s4[i].name+"的成绩为："+s4[i].achievement);
        }
        for (int i = 0; i <s4.length ; i++) {
            if (s4[i].achievement<60){
                for (int j = 0; j <s4.length ; j++) {
                    s4[j].achievement+=2;
                }
                break;
            }

        }
        System.out.println("修改后的成绩：");
        for (int i = 0; i <s4.length ; i++) {
            System.out.println(s4[i].name+"的成绩为："+s4[i].achievement);
        }
    }
}

3.为学员类添加带参构造方法，重新实现第2题所示程序功能，
构造学员对象时，使用带参构造方法实现。

package homework.three;

public class Student {
    String name;
    double achievement;
    public  Student(String name,double achievement){
        this.name=name;
        this.achievement=achievement;
        }
        /* public void fun1(){
            System.out.println(name+"的成绩为："+achievement);
        }*/
}

package homework.three;
public class TestStudent {
    public static void main(String[] args) {
        Student s1=new Student("张三",45);
        Student s2 = new Student("李四",84);
        Student s3 = new Student("王五",90);
        Student s4[]=new Student[]{s1,s2,s3};
        for (int i = 0; i <s4.length ; i++) {
            System.out.println(s4[i].name+"的成绩为："+s4[i].achievement);
        }
        for (int i = 0; i <s4.length ; i++) {
            if (s4[i].achievement<60){
                for (int j = 0; j <s4.length ; j++) {
                    s4[j].achievement+=2;
                }
                break;
            }

        }
        System.out.println("修改后的成绩：");
        for (int i = 0; i <s4.length ; i++) {
            System.out.println(s4[i].name+"的成绩为："+s4[i].achievement);
        }
          /* System.out.println("-------------------------");
        for (int i = 0; i <s4.length ; i++) {
            s4[i].fun1();
        }*/
    }
}

4.需求说明：有5位学员参加了Java知识竞赛的决赛，正确使用带数组参数方法，输出决赛的平均成绩和最高成绩，输出结果如图所示。

package homework.three;
import java.util.Scanner;
public class TestExam {
    public static void main(String[] args) {
        System.out.println("请输入5名参数者的成绩：");
        Scanner sc = new Scanner(System.in);
        double[] scores = new double[5];
        for (int i = 0; i < 5; i++) {
            scores[i]=sc.nextDouble();
        }
       //调用方法
        avgAndMax(scores);
    }
    public static void avgAndMax(double[] scores){
        double sum=0.0;
        double Max=0;
        for (int i = 0; i < scores.length; i++) {
            sum+=scores[i];
            if(scores[i]>Max){
                Max=scores[i];
            }
        }
        //求平均
        double avg=sum/5;
        //求最高
        System.out.println(Max);
    }
}

5.正确使用方法重载实现简易计算器，分别实现两个整数、三个浮点数的加法运算，并在控制台输出加法运算的结果。计算器输出效果如图所示。

package homework.five;

import java.util.Scanner;

public class Calculator {

    public static void main(String[] args) {
        System.out.println("请输入两个整数");
        Scanner sc = new Scanner(System.in);
        int a,b;
        a=sc.nextInt();
        b=sc.nextInt();
        System.out.println("请输入三个小数");
        double c,d,e;
        c=sc.nextDouble();
        d=sc.nextDouble();
        e=sc.nextDouble();
        System.out.println("这两个整数的和为："+Add(a,b));
        System.out.println("这三个小数的和为:"+Add(c,d,e));


    }

    private static int Add(int a,int b) {
        int n=0;
        n=a+b;
        return n;
    }

    private static double Add(double a,double b,double c) {
        double n=0;
        n=a+b+c;
        return n;
    }

}

---------------------第二批-------------

1.根据用户不同的选择计算不同形状的面积（三角形、正方形、长方形）（用不同方式实现：1.参数和面积在自定义方法中输入和输出 2.参数在主方法中接收 3.参数在主方法中接收并且在主方法中要计算面积和）

package homework.four;
import java.util.Scanner;
/*1.根据用户不同的选择计算不同形状的面积（三角形、正方形、长方形）
（用不同方式实现：
1.参数和面积在自定义方法中输入和输出
* */
public class Hello1 {
   static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        System.out.println("请输入您要计算的图形：（三角形--1、正方形--2、长方形--3）");
        int i = sc.nextInt();
        //调用方法
        calArea(i);
    }
    public static void calArea(int i){
        switch (i){
            case 1:
                System.out.println("请输入底边：");
                double bottom = sc.nextDouble();
                System.out.println("请输入高度：");
                double height = sc.nextDouble();
                System.out.println(bottom*height/2);
                break;
            case 2:
                System.out.println("请输入边：");
                double side = sc.nextDouble();
                System.out.println(side*side);
                break;
            case 3:
                System.out.println("请输入宽度：");
                double width = sc.nextDouble();
                System.out.println("请输入高度：");
                double height1 = sc.nextDouble();
                System.out.println(width*height1);
                break;

        }
    }

}

package homework.four;
import java.util.Scanner;
/*1.根据用户不同的选择计算不同形状的面积（三角形、正方形、长方形）
（用不同方式实现：
 2.参数在主方法中接收,计算面积放在自定义方法中
* */
public class Hello2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要计算的图形：（三角形--1、正方形--2、长方形--3）");
        int i = sc.nextInt();
        switch (i){
            case 1:
                System.out.println("请输入底边：");
                double bottom = sc.nextDouble();
                System.out.println("请输入高度：");
                double height = sc.nextDouble();
                calTriangle(bottom,height);
                break;
            case 2:
                System.out.println("请输入边：");
                double side = sc.nextDouble();
                calSquare(side);
                break;
            case 3:
                System.out.println("请输入宽度：");
                double width = sc.nextDouble();
                System.out.println("请输入高度：");
                double height1 = sc.nextDouble();
                calRectangle(width,height1);
                break;

        }
    }

    //三角形
    public static void calTriangle(double bottom,double height){
        System.out.println(bottom*height/2);
    }
    //正方形
    public static void calSquare(double side){
        System.out.println(side*side);
    }
    //长方形
    public static void calRectangle(double width,double height){
        System.out.println(width*height);
    }
}

package homework.four;
import java.util.Scanner;
/*1.根据用户不同的选择计算不同形状的面积（三角形、正方形、长方形）
（用不同方式实现：
  3.参数在主方法中接收并且在主方法中要计算面积和）
* */
public class Hello3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要计算的图形：（三角形--1、正方形--2、长方形--3）");
        int i = sc.nextInt();
        switch (i){
            case 1:
                System.out.println("请输入底边：");
                double bottom = sc.nextDouble();
                System.out.println("请输入高度：");
                double height = sc.nextDouble();
                System.out.println(bottom*height/2);
                break;
            case 2:
                System.out.println("请输入边：");
                double side = sc.nextDouble();
                System.out.println(side*side);
                break;
            case 3:
                System.out.println("请输入宽度：");
                double width = sc.nextDouble();
                System.out.println("请输入高度：");
                double height1 = sc.nextDouble();
                System.out.println(width*height1);
                break;
        }
    }

}

2.编写方法，计算圆的面积和周长，在主方法中接受圆的半径，在自定义方法中计算并输出

import java.util.Scanner;

public class Circular {
static Scanner sc=new Scanner(System.in);

    public static void main(String[] args) {
        System.out.println("请输入圆的半径：");
        double a;
        a=sc.nextDouble();
        Circular(a);
    }
    private static void Circular(double a){
        System.out.println("圆的面积为："+3.14*a*a);
        System.out.println("圆的周长为："+2*3.14*a);
    }
}

3.定义一个方法，用于求2个数中的较大数，并将其返回，这2个数字在主方法中由用户输入

package com.homework.three;

import java.util.Scanner;

public class Compare {
        public static void main(String [] args ){
            System.out.println("请输入两个数：");
            Scanner sc=new Scanner(System.in);
            double a,b;
            a=sc.nextDouble();
            b=sc.nextDouble();
            System.out.println(max(a,b));
        }
        private static double max(double a,double b){
            double max1;
            if (a>b){
                max1=a;
            }else {
                max1=b;
            }
            return max1;
    }
}

4.在主方法中从键盘接收X, Y , Z 3个数，编写方法计算这3个数的立方和并返回计算结果：S=X3+Y3+Z3

package com.homework.four;

import java.util.Scanner;

public class Cube {
    public static void main(String[] args) {
        System.out.println("请输入三个数：");
        Scanner sc=new Scanner(System.in);
        double a,b,c;
        a=sc.nextDouble();
        b=sc.nextDouble();
        c=sc.nextDouble();
        System.out.println(cube1(a,b,c));
    }
    private static double cube1(double a,double b,double c){
        double S;
        S=Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3);
        return S;
    }
}

5.定义一个方法，用于计算m的n次幂，m和n在主方法中由用户输入，调用自定义方法进行计算，并输出结果

package com.homework.five;

import java.util.Scanner;

public class Power {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数：");
        double m;
        m=sc.nextDouble();
        System.out.println("要进行几次幂的运算：");
        int n;
        n=sc.nextInt();
        power1(m,n);
    }
    private static void power1(double a,int b){
        System.out.println(Math.pow(a,b));
    }
}

6.在主方法中产生20个0-10之间的随机数，将这20个随机数存入数组，并通过方法计算某个数在这些随机数中出现的次数（这“某个数”是在主方法中由用户输入的）
Math类中的取整方法
round返回值是一个long类型，可以使用long定义，或使用强制类型转换

package homework.five;
import java.util.Arrays;
import java.util.Scanner;
public class Hello1 {
    /*
    * 6.在主方法中产生20 个0-10之间的随机数，
    * 将这20个随机数存入数组，并通过方法计算某个数在这些随机数中出现的次数
    * （这“某个数”是在主方法中由用户输入的）*/
    public static void main(String[] args) {
        long[] nums = new long[20];
        for (int i = 0; i < 20; i++) {
            nums[i] =  Math.round(Math.random() * 10);
        }
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入某个数");
        long X = sc.nextLong();
        //调用方法
        search(nums,X);
    }
    //计算某个数在数组中出现的次数
    public static void search(long[] nums,long X){
        int count=0;
        for (int i = 0; i < nums.length; i++) {
            if(X==nums[i]){
                count++;
            }
        }
        System.out.println(Arrays.toString(nums));
        System.out.println("次数："+count);

    }
}

package com.homework;

import java.util.Arrays;
import java.util.Scanner;

public class six {
    public static void main(String[] args) {
        int nums[]=new int[20];
        for (int i = 0; i <nums.length ; i++) {
            nums[i]=(int)Math.round(Math.random()*10);
        }
        System.out.println("请输入1-10之间的一个整数");
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        appear(nums,a);


    }
    private static void appear(int nums[],int a){//出现的次数
        int count=0;
        for (int i = 0; i <nums.length ; i++) {
            if (nums[i]==a){
                count++;
            }
        }
        System.out.println(Arrays.toString(nums));
        System.out.println(a+"一共出现"+count+"次");

    }
}

7.在主方法中接收10个数存入数组，在自定义方法中，将该数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后在主方法中输出交换后的数组

package com.homework.seven;

import java.util.Arrays;

public class Exchange {
    public static void main(String[] args) {
        int nums[]=new int[10];
        for (int i = 0; i <nums.length; i++) {
            nums[i]=(int)Math.round(Math.random()*100);
        }
        System.out.println(Arrays.toString(nums));
        exchange(nums);
        System.out.println(Arrays.toString(nums));
    }

    private static void exchange(int num[]) {
        int max=num[0];
        int min=num[0];
        for (int i = 0; i <num.length ; i++) {//比较大小
            if (num[i]>max){
                max=num[i];
            }
            if (num[i]<min){
                min=num[i];
            }
        }
        System.out.println("最大值为："+max);
        System.out.println("最小值为："+min);
        for (int i = 0; i <num.length ; i++) {//交换位置
            if(max==num[i]){
                int a=num[i];
                num[i]=num[0];
                num[0]=a;
                break;
            }
        }
        for (int i = 0; i <num.length ; i++) {//交换位置
            if(min==num[i]){
                int a=num[i];
                num[i]=num[num.length-1];
                num[num.length-1]=a;
                break;
            }
        }

    }

}

8.用自定义方法是实现求某数组元素的和（大小不固定）

package com.homework.eight;

import java.util.Arrays;

public class Summation {
    public static void main(String[] args) {
        int a=(int)Math.round(Math.random()*20);
        System.out.println("数组长度为："+a);
        int num[]=new int[a];
        for (int i = 0; i <num.length ; i++) {
            num[i]=(int)Math.round(Math.random()*10);
        }
        System.out.println("数组为："+Arrays.toString(num));
        summation1(num);
        System.out.println("数组的和为"+ summation1(num));
    }

    private static int summation1(int num[]) {
        int a=0;
        for (int i = 0; i <num.length ; i++) {
            a+=num[i];
        }
        return a;
    }

}

选做
.
现有电视商品价格竞猜活动，活动的规则：随机出现一个商品名，用户猜测它的价值，如果在规定次数内猜对，便可获得此商品。模拟竞猜活动，运行结果如下所示： （选作）
分析：1、准备一批用来竞猜的商品
2、随机获取一件商品
Java程序：
1、定义对象所归属的类：商品类–Goods（属性: 商品的名称String name 商品对应的实际单价 int price）
2、模拟购入一批商品
多个Goods对象
3、

请猜测“公主电动车”的价格：1000
再大点！
再猜一次吧：5000
再小点！
再猜一次吧：2500
在小点！
再猜一次吧：2200
4次内没有猜对，下次努力吧！

参考实现步骤如下：
1.定义类QuessMachine，编写它的initial()方法预定义商品信息，根据产生的随机数字，选定一款竞猜的商品
2.编写QuessMachine类的guess()方法，如果猜测正确，返回“猜对了！”；如果偏大，返回“再小些”；如果偏小，返回“再大些！”
3.编写测试类模拟竞猜

package homework.XuanZuo;

public class Goods {
    String name;
    int price;

    public Goods(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public Goods() {
    }
}

package homework.XuanZuo;

import java.util.Scanner;
public class TestGoods {
    //随机出一个商品
    private static Goods init() {
        //1.创建3个商品
        Goods g1 = new Goods("公主电动车", 2000);
        Goods g2 = new Goods("王子洗衣机", 3000);
        Goods g3 = new Goods("白马微波炉", 500);
        //2.存入一个对象数组
        Goods [] gs={g1,g2,g3};
        //3.随机返回一个商品
        int index= (int) Math.floor(Math.random()*3);//0,1,2
        return gs[index];
    }

    //猜价格
    private static void guess(Goods goods) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入"+goods.name+"的价格：");
        int i=0;
        do {
            int X = sc.nextInt();
            if(goods.price==X){
                System.out.println(goods.name+"拿走吧！");
                return;
            }else if(goods.price>X){
                if(i<3)
                    System.out.println("再大点！");
                else
                    break;
            }else{
                if(i<3)
                    System.out.println("再小点！");
                else
                    break;
            }
            System.out.println("再猜一次吧：");
            i++;
        }while (i<4);
        System.out.println("4次内没有猜对，下次努力吧!");
    }

    public static void main(String[] args) {
        //1.随机出一个商品
        Goods g = init();
        //2.猜价格
        guess(g);
    }

}

Java学习顺序