方法

  • 今日目标:
  • 1.方法的理解和语法格式:
  • 2.为什么有的方法有参数,有的没有?
  • 3.参数分形参和实参(参数的分类)
  • 4.方法的返回值
  • 5.方法的调用和传参
  • 6.构造方法(day09)
  • 对象数组
  • 7.方法的重载
  • 8.成员变量和局部变量
  • 作业:


今日目标:

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;),只是定义类型,取名字,不赋值。

实参:实际参数,在调用一个方法时,方法名后面的小括号中,就是实参。

格式:(参数值或一个同类型的变量)

补充:方法的状态:方法编写完成后,没有调用的状态叫作方法的声明,被其它方法调用时,叫调用状态。

案例:

榨苹果汁,吃饭,跑步,说话(背诗歌),睡觉,玩手机,看书。

方法调用时是实参,定义时是形参,形参和实参的关系,实参是给形参赋值的。

java IKAnalyzer 使用_实例方法


java IKAnalyzer 使用_java_02

4.方法的返回值

1.返回值指的是:根据实际的业务需求,对某一功能用程序实现后,需要有一定的产出。

比如:榨一杯苹果汁,最后会产出一杯苹果汁。这个时候就有人会问:参数和返回值之间好像有着某种联系?

其实,这两者之间没有任何必然的联系。也就是说,一个方法,可以有参数,也可以没有参数,可以有参数,没有返回值,也可以有参数,也有返回值…

打个比方:盖房子需要木头,水泥,砖块。这些都是“盖房子”这个方法的参数,但是产出只有一个——房子。再打个比方,“种水稻”这个方法需要的参数有:种子,化肥,除草剂,产出的是大米。可天有不测风云,万一闹灾荒,可能颗粒无收,这个时候,没有产出。当然,我们希望的是每年风调雨顺,国泰民安。再比如,“学习”这个方法,需要的参数是:时间,精力,和思考。可最终是否学业有成,还得看个人在这个过程中是否用心了,有可能学业有成,知识高产出,也有可能中途放弃,或误入歪门邪道,最终没有产出。我们还是祝愿所有的学员能够学员有成!

2.返回值类型定义在方法名的前面,分两种:

有返回值:基本数据类型,和引用数据类型(也就是类和接口)(选做最后一题)

无返回值:void

3.返回值用关键字return 表示。

java IKAnalyzer 使用_System_03

类的成员:属性和方法

java IKAnalyzer 使用_java_04


java IKAnalyzer 使用_System_05


可变形参和数组的区别

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]);
        }
    }

java IKAnalyzer 使用_实例方法_06


java IKAnalyzer 使用_System_07


java IKAnalyzer 使用_java IKAnalyzer 使用_08

java IKAnalyzer 使用_静态方法_09


理解静态和实例

java IKAnalyzer 使用_java_10

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
    }
}

java IKAnalyzer 使用_静态方法_11

java IKAnalyzer 使用_java_12

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

5.方法的调用和传参

1.调用:方法分静态和非静态,同一个类中,静态方法直接调用静态方法,

静态方法调用非静态,要先创建对象,然后再调用。因为静态方法是属于类的,非静态属于对象的。

不同的类中:调用静态方法,直接是类名.方法名();调用非静态:创建对象,再调用。同一个类中:

java IKAnalyzer 使用_java_13


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.实例方法 中 调用 静态方法  类名.静态方法() ,可以省略类名
     */
}

java IKAnalyzer 使用_java IKAnalyzer 使用_14


java IKAnalyzer 使用_静态方法_15

不同类中

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");
    }
}

java IKAnalyzer 使用_System_16

java IKAnalyzer 使用_java_17

6.构造方法(day09)

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

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

注意:如果开发人员编写了有参构造,那么虚拟机就不会默认生成无参构造。如果仍要使用无参构造,需要手动编写。

案例:以girlfriend类为例,从无参构造演化到有参构造。

java IKAnalyzer 使用_实例方法_18


无参构造只能创建对象构造方法快捷键:alt+Insert(或者鼠标右键选择Generate)
点击Constructor

java IKAnalyzer 使用_实例方法_19


选择即可

java IKAnalyzer 使用_实例方法_20


构造方法一

java IKAnalyzer 使用_实例方法_21

对象数组

java IKAnalyzer 使用_实例方法_22


java IKAnalyzer 使用_实例方法_23

java IKAnalyzer 使用_System_24


java IKAnalyzer 使用_实例方法_25

构造方法二

java IKAnalyzer 使用_静态方法_26


java IKAnalyzer 使用_System_27


java IKAnalyzer 使用_System_28

成员属性与构造方法的个数: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(“张三”);

java IKAnalyzer 使用_System_29


java IKAnalyzer 使用_实例方法_30


java IKAnalyzer 使用_静态方法_31

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

8.成员变量和局部变量

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

作业:

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

java IKAnalyzer 使用_System_32

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

java IKAnalyzer 使用_java_33

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

(注:构造学员对象时,使用无参构造方法)

java IKAnalyzer 使用_实例方法_34

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);
        }
    }
}

java IKAnalyzer 使用_静态方法_35

java IKAnalyzer 使用_java_36


java IKAnalyzer 使用_java_37

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();
        }*/
    }
}

java IKAnalyzer 使用_java IKAnalyzer 使用_38

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

java IKAnalyzer 使用_实例方法_39

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

java IKAnalyzer 使用_静态方法_40

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;
    }

}

java IKAnalyzer 使用_System_41

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

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);
    }
}

java IKAnalyzer 使用_java_42

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;
    }
}

java IKAnalyzer 使用_System_43

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;
    }
}

java IKAnalyzer 使用_System_44

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));
    }
}

java IKAnalyzer 使用_实例方法_45

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+"次");

    }
}

java IKAnalyzer 使用_java_46

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;
            }
        }

    }

}

java IKAnalyzer 使用_System_47

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

java IKAnalyzer 使用_实例方法_48

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;
    }

}

java IKAnalyzer 使用_java IKAnalyzer 使用_49

选做
.
现有电视商品价格竞猜活动,活动的规则:随机出现一个商品名,用户猜测它的价值,如果在规定次数内猜对,便可获得此商品。模拟竞猜活动,运行结果如下所示: (选作)
分析: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 IKAnalyzer 使用_java IKAnalyzer 使用_50