Java面向对象编程题

1.面向对象练习：设计小狗类

需求：

抽象形成一个小狗类Dog
属性：名字name 年龄age 品种kind 主人host 价格price
功能：

跑run：无参，打印：小狗Dog跑的老快了~
吃eat：参数int n，打印：小狗今晚要吃n根肉骨头
睡觉sleep：参数double num，打印：小狗睡了num个小时
玩play：参数String host，返回值 String “飞盘”，打印：小狗与主人host玩的很开心
叫bark：打印：小狗喜欢汪汪叫，封装此方法，玩play()的时候才bark()

创建本类的2个对象，并给两个对象的所有属性并查看名字name 年龄age 品种kind 主人host 价格price 哮天犬 999 猎狗二郎神 10000 罗小黑 5 神奇犬大自然 999.99

public class TestDog {
public static void main(String[] args) {
//5.1创建Dog类的第1个对象
Dog d1 = new Dog();
//5.2修改d1对象的属性值
d1.setName("哮天犬");
d1.setAge(999);
d1.setKind("猎狗");
d1.setHost("二郎神");
d1.setPrice(10000);
//5.3打印查看d1对象的属性值
System.out.println(d1.getName());
System.out.println(d1.getAge());
System.out.println(d1.getKind());
System.out.println(d1.getHost());
System.out.println(d1.getPrice());
    //6.1创建Dog类的第2个对象
     Dog d2 = new Dog();
     //6.2修改d2对象的属性值
     d2.setName("罗小黑");
     d2.setAge(5);
     d2.setKind("神奇犬");
     d2.setHost("大自然");
     d2.setPrice(999.99);
     //6.3打印查看d2对象的属性值
     System.out.println(d2.getName());
     System.out.println(d2.getAge());
     System.out.println(d2.getKind());
     System.out.println(d2.getHost());
     System.out.println(d2.getPrice());

    //7.调用dog类的5个方法
     d1.run();
     d1.eat(5);
     d1.sleep(8.8);
     //方式一：只调用play()的功能
     d1.play(d1.getHost());
     //方式二：不仅调用play()的功能还接收了返回值飞盘交给r保存
     String r = d1.play(d1.getHost());
     System.out.println(r);
     //方式三：调用play()的功能，并直接打印了play()的返回值飞盘
     System.out.println(d1.play(d1.getHost()));
 }
}
//1.定义小狗类
class Dog{
//2.定义5个属性
//3.1使用private修饰所有的属性
private String name;//姓名
private int age;//年龄
private String kind;//品种
private String host;//主人
private double price;//价格
//4.1添加小狗类功能1
public void run(){
System.out.println("小狗Dog跑的老快了~");
}
//4.2添加小狗类功能2
public void eat(int n){
System.out.println("小狗今晚要吃"+n+"根肉骨头");
}
//4.3添加小狗类的功能3
public void sleep(double num){
System.out.println("小狗今晚睡了"+num+"个小时");
}
//4.4添加小狗类的功能4
public String play(String host){
System.out.println("小狗与主人"+host+"玩的很开心");
bark();//在本类的公共方法中调用被封装的方法的功能
return "飞盘";
//bark();//遇到return时已经结束本方法了，return后不可以直接写代码
}
//4.5添加小狗类的功能5
private void bark(){
System.out.println("小狗喜欢汪汪叫");
}
//3.2添加被封装属性的公共的get与set方法
 public String getName() {
     return name;
 }
 public void setName(String name) {
     this.name = name;
 }
 public int getAge() {
     return age;
 }
 public void setAge(int age) {
     this.age = age;
 }
 public String getKind() {
     return kind;
 }
 public void setKind(String kind) {
     this.kind = kind;
 }
 public String getHost() {
     return host;
 }
 public void setHost(String host) {
     this.host = host;
 }
 public double getPrice() {
     return price;
 }
 public void setPrice(double price) {
     this.price = price;
 }
}

2.封装百分制分数

封装百分制分数，和它对应的五档分制分数

public class Score {
//成员变量
int score;
char level;
//构造方法
public Score(int score) {
this.score = score;
//计算五档分数，保存到成员变量level
this.level = setLevel(score);
}
private char setLevel(int s) {
     char r = 0;
     switch(s/10) {
     case 10:case 9:
         r = 'A';break;
     case 8:case 7:
         r = 'B';break;
     case 6:
         r = 'C';break;
     case 5:case 4:case 3:case 2:
         r = 'D';break;
     case 1:case 0:
         r = 'E';break;
     }
     return r;

}

public String toString() {
     return score+", "+level;
 }
}

//测试类：

public class TestScore {
public static void main(String[] args) {
/*
A [90,100]
B [70,90)
C [60,70)
D [20,60)
E [0,20)
*/
Score s = new Score(54);
System.out.println(s.toString());
}
}

3.打印图形

设计一个可以随机打印形状的代码

//形状类 ---父类

public class Shape {
public void draw() {
//无意义代码
//在子类中要重写draw()方法
System.out.println("图形形状");
}
public void clear() {
System.out.println("\n\n\n");
}
}

//圆形类---子类

public class Circle extends Shape {
@Override
public void draw() {
System.out.println("打印一个圆形 O");
}
}

//方块类---子类

public class Square extends Shape {
@Override
public void draw() {
System.out.println("打印一个方形口");
}
}

//直线类---子类

public class Line extends Shape {
@Override
public void draw() {
System.out.println("打印一条直线 ————");
}
public void length() {
     System.out.println("一米多。。。");
 }
}

//测试类---随机生成图形

import java.util.Random;
import java.util.Scanner;

public class TestShape {
public static void main(String[] args) {
System.out.println("按回车继续");
while(true) {
int r = new Random().nextInt(4);
switch(r) {
case 0: f(new Shape()); break;
case 1: f(new Line()); break;
case 2: f(new Square()); break;
case 3: f(new Circle()); break;
}
}
}
/*
  * Shape
  *   - Line
  *   - Square
  *   - Circle
  */
 static void f(Shape s) {
     System.out.println("----------------");
     new Scanner(System.in).nextLine();
     s.draw();
     //向上转型后，只能调用父类定义的通用成员
     //子类特有成员不能调用
     //s.length();
     //s对象的真实类型是 Line 类型
     if(s instanceof Line) {
         //向下转型成Line类型，才能调用它特有的方法
         Line line = (Line) s;
         line.length();
     }
     new Scanner(System.in).nextLine();
     s.clear();
 }
}

4.设计士兵类

设计士兵与武器AK47类，并完成前进、进攻、发射子弹、装载子弹的功能

士兵类

封装：

士兵相关的属性数据、逻辑运算方法，

```
封装成一个士兵“类”组件
```

*/
import java.util.Random;
public class Soldier {
//成员变量，属性变量
int id; //默认值0
int blood = 100;
AK47 a;//默认 null 值

//成员方法
 public void go() {
     //this是一个特殊引用
     //引用“当前对象”的地址
     //当前对象：谁调用就是谁
     //可以省略，缺省存在
     System.out.println(this.id+"号士兵前进");
 }

public void attack() {
     if(blood == 0) {
         System.out.println("这是"+id+"号士兵的尸体");
         return;//方法结束
     }
     System.out.println(id+"号士兵进攻");
     if(a != null) {
         a.fire();//调用枪发射子弹
     }
     //模拟进攻掉血
     //随机的减血量
     int d = new Random().nextInt(10);
     blood -= d;    
     if(blood < 0) {//不允许负数血量
         blood = 0;
     }
     System.out.println("血量："+blood);
     //血量是0
     if(blood == 0) {
         System.out.println(id+"号士兵阵亡");
     }
 }

}

武器类

import java.util.Random;
/*
封装：
AK47武器相关的属性数据、运算代码，
封装成一个“类”组件
*/
public class AK47 {
int bullets = 100;
public void fire() {
if(bullets == 0) {
System.out.println("没有子弹");
return;
}
//随机产生发射子弹数量
int r = new Random().nextInt(10);
//要发射的数量，比现有子弹多
if(r > bullets) {
r = bullets;//有多少发多少
}
bullets -= r;
for(int i=0;i<r;i++) {
System.out.print("突");
}
System.out.println("~");
if(bullets == 0) {
System.out.println("弹夹空了");
}
}
public void load() {
     bullets = 100;
     System.out.println("弹夹已装满");
 }
}

测试类

public class Test1 {
public static void main(String[] args) {
//新建 Soldier 士兵对象
//内存地址，保存到变量s1
Soldier s1 = new Soldier();
Soldier s2 = new Soldier();
//用s1引用第一个士兵对象
//为它的id赋值
s1.id = 9527;
s2.id = 9528;
//用s1找到第一个士兵对象
//让第一个士兵执行go()方法代码
s1.go();
s2.go();
//新建 AK47 对象，保存到s1.a
s1.a = new AK47();
s2.a = new AK47();
s2.attack();
s2.attack();
s2.attack();
s2.attack();
}
}

测试类

import java.util.Scanner;

public class Test2 {
public static void main(String[] args) {
//新建AK47对象，地址存到变量a
AK47 a = new AK47();
System.out.println("按回车射击，输入load装载子弹");
while(true) {
String s = new Scanner(System.in).nextLine();
if(s.equals("load")) {
a.load();
continue;
}
a.fire();
}
}
}

5.编写一个关于星期几的枚举WeekDay

要求：枚举值：MON,TUE,WED,THR,FRI,SAT,SUN
该枚举要有一个方法，调用该方法返回中文格式的星期几

import org.junit.Test;

public class Work{
@Test
public void test(){
//6.1拿到指定的枚举名
System.out.println(WeekDay.MON);//MON
//6.2拿到指定的枚举名对应的值
System.out.println(WeekDay.MON.getValue());//星期一
}
}
//1.定义枚举类
enum WeekDay {
//2.定义枚举类中的枚举与其对应的值
MON("星期一"), TUE("星期二"), WES("星期三"), THR("星期四"), FRI("星期五"), SAT("星期六"), SUN("星期日");
//3.定义枚举类中的私有属性
private String day;
//4.定义枚举类的构造函数
private WeekDay(String day) {
this.day = day;
}
//5.定义枚举类的方法，并获取枚举对应的值
public String getValue(){
return this.day;
}
}

6.异常：请定义main()方法，在main()中按以下顺序要求编写代码：

分别从控制台接收两个整数
计算"第一个数 / 第二个数"的结果，并打印；
为了防止第二个数为0导致异常，请在计算时使用异常处理 - 当出现异常时，向用户打印：第二个数不能为0!

public class Test {
public static void main(String[] args) {
//分别从控制台接收两个整数
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数:");
int num1 = scanner.nextInt();

    //为了防止第二个数为0导致异常，请在计算时使用异常处理。当出现异常时，向用户打印：第二个数不能为0！！
     System.out.print("请输入第二个数:");
     int num2 = scanner.nextInt();
     //计算“第一个数 / 第二个数”的结果，并打印；
     try {
         int div = num1/num2;
         System.out.println("第一个数/第二个数="+div);
     } catch (ArithmeticException e) {
         if(num2==0) {
             System.out.println("第二个数不能为0");
         }
     }
 }

}

7.接收用户输入的数字,判断在此范围内质数的个数

import java.util.Scanner;

public class CountPrimeNumber {
public static void main(String[] args) {
System.out.println("输入整数n，求n内质数的数量");
int n = new Scanner(System.in).nextInt();

    count(n);
 }

public static void count(int n) {
     if(n<2) {
         System.out.println("没有质数");
         return;
     }
     if(n==2) {
         System.out.println("有1个质数");
         return;
     }
     //定义计数变量
     int count = 1;//已知有一个质数
     outer:   //从3到n寻找质数
     for(int i=3; i<=n ;i++) {
         //判断i是否是质数
         double max = 1+ Math.sqrt(i);
         for(int j=2; j<max; j++) {//在2到<max，找能把i整除的数
             if(i%j == 0) {//i被j整除，i不是质数
                 //跳到i++，继续判断下一个i值
                 continue outer;//跳到外部outer的位置
             }
         }
         //内层j循环结束，i是质数
         count++;
     }
     System.out.println(n+"内质数的数量："+count);
 }

}

8.生成一个顺序数组,将这个数组的元素打乱顺序后输出

import java.util.Arrays;
import java.util.Random;

public class ShuffleArray {
public static void main(String[] args) {
//调用f()方法，从方法获取一个int[]数组
int[] a = f();
//遍历打印数组数据
for(int i=0; i<a.length; i++) {
System.out.println(a[i]);
}
System.out.println("\n\n----------------");

    //把a数组，传递到 shuffle() 方法打乱顺序
     shuffle(a);
     //打印乱序后的数组
     System.out.println(Arrays.toString(a));
 }

public static int[] f() {
     //新建int[]数组，长度5
     //再把它的内存地址存到变量 a
     int[] a = new int[5];
     //遍历访问5个位置，填入1,2,3,4,5
     for(int i=0; i<a.length; i++) {
         a[i] = i+1;
     }
     //返回数组，把数组返回到调用位置
     //本质是把数组地址返回去
     return a;
 }

public static void shuffle(int[] a) {
     /*
      *        j
      * [4, 2, 3, 1, 5]
      *     i
      *
      * *) i循环遍历数组
      * *) 随机定位下标j与i交换
      */
     for (int i = 0; i < a.length; i++) {
         //随机下标j，范围：[0, a.length)
         int j = new Random().nextInt(a.length);
         int t = a[i];
         a[i] = a[j];
         a[j] = t;
     }
 }

}

9.异常：找出以下程序中存在的问题，并修改1

public static void method() throws RuntimeException, NullPointerException {
throw new RuntimeException("method Exception");
}

public static void main(String args[]) {
try {
//监视代码
method(); //当try块中的代码有异常时，会交给catch来处理
 } catch (Exception e) {//catch拿到try抛出的异常时，会进行异常类型的匹配，只有异常类型匹配成功了，说明当前catch才具备处理该异常的能力
     
     //什么时异常类型匹配成功？
     //两个异常类型型相同 、 catch块中书写的异常类型是try块异常的父类型
     
     //示例：
       //try块中发生NullPointerException异常，catch块中书写的是Exception
       //catch块中可以匹配成功
     
     
     e.printStackTrace();
 } catch (RuntimeException re) {
     re.printStackTrace();
 }
}

//程序中存在的问题：
main方法中在捕获RuntimeException类型变量re的地方会编译错误，因为Exception是RuntimeException 的父类，method方法执行的异常都会被第一个catch 块捕获，所以会报编译时错误。

说明：method方法后面throws列出的异常类型是不分先后顺序的，所以method方法是没问题的

/*** 修改后的程序 ***/
public static void method() throws RuntimeException, NullPointerException {
throw new RuntimeException("method Exception");
}

public static void main(String args[]) {
try {
method();
} catch (RuntimeException e) {
e.printStackTrace();
} catch (Exception re) {
re.printStackTrace();
}
}

10.找出以下程序中存在的问题，并修改2

public class Father {
public void sayHello() throws IOException
{
throw new IOException("Father IOException");
}
}

public class Son extends Father {
public void sayHello() throws Exception
{
throw new Exception("Son Exception");
}
}
//程序中存在的问题：
在编译时子类的sayHello方法时会出现编译异常，因为在java中重写方法抛出的异常不能是原方法抛出异常的父类，这里sayHello方法在父类中抛出了IOException，所有在子类中的sayHello方法只能抛出IOExcepition 或是其子类，但不能是其父类

/*** 修改后的程序 ***/
public class Father {
public void sayHello() throws IOException
{
throw new IOException("Father IOException");
}
}
public class Son extends Father {
//结论：子类重写父类方法时，只要保证和父类中的方法一模一样，就可以避免语法上的问题
public void sayHello() throws IOException
{
throw new IOException("Son Exception");
}
}

11.找出以下程序中存在的问题，并修改3

public static void method() {
//抛出一个异常对象
throw new RuntimeException();//运行时异常
}

public static void main(String args[]) {
//在main方法中，使用捕获，来处理方法抛出的异常
try{
method();
}catch(IOException e) {//IOException是编译时异常
e.printStackTrace();
}
}

//程序中存在的问题：
在编译时，在IOException时会出现编译错误，因为IOException是编译期异常，而method方法中并没有抛出IOException,所以会编译报错。

/*** 修改后的程序 ***/
将IOException改为RuntimeException或及其子类，则不会出现编译报错。
public static void method() {
throw new RuntimeException();
}
public static void main(String args[]) {
try{
method();
}catch(RuntimeException e) {
e.printStackTrace();
}
}

总结：

在书写多重的catch块时要保证异常类型的优先级书写顺序，要保证子类靠前父类靠后的原则
在java中重写方法抛出的异常不能是原方法抛出异常的父类
如果方法没有抛出受检查类型异常则在调用方法的地方就不能主动添加受检查类型异常捕获，但是可以添加运行时异常或者Exception捕获

12.请定义main()方法，在main()中按以下顺序要求编写代码：

分别从控制台接收两个整数
计算"第一个数 / 第二个数"的结果，并打印；
为了防止第二个数为0导致异常，请在计算时使用异常处理
当出现异常时，向用户打印：第二个数不能为0!

public class Test1 {
public static void main(String[] args) {
//分别从控制台接收两个整数
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数:");
int num1 = scanner.nextInt();

    //为了防止第二个数为0导致异常，请在计算时使用异常处理。当出现异常时，向用户打印：第二个数不能为0！！
     System.out.print("请输入第二个数:");
     int num2 = scanner.nextInt();
     //计算“第一个数 / 第二个数”的结果，并打印；
     try {
         int div = num1/num2;
         System.out.println("第一个数/第二个数="+div);
     } catch (ArithmeticException e) {
         if(num2==0) {
             System.out.println("第二个数不能为0");
         }
     }
 }

}

13.请定义main()方法，在main()中按以下顺序要求编写代码：

定义一个String[]数组如下： String[] arr = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
请用户输入一个整数1–7的值：
根据用户输入，从数组中取出对应的星期名称，例如：用户输入：1 程序提示：星期一
为了防止用户输入小于1或者大于7的值，请使用异常处理从数组中取出对应的"星期名称"，在异常处理中打印：输入错误!

public class Test2 {
    public static void main(String[] args) {
        String[] arr = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
        System.out.print("请输入一个1-7的值:");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        
        
        //从数组中取出对应的星期几
        try{
            String week = arr[num - 1];
            System.out.println(week);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("输入错误！！");
        }
    }
}

14.异常练习

定义一个"年龄异常类"：AgeException，使其继承自RuntimeException，并添加无参、String参数的构造方法；
定义一个"性别异常类"：SexException，使其继承自RuntimeException，并添加无参、String参数的构造方法；
定义一个Student类，属性：姓名、性别、年龄。
在性别的set方法中判断是否是男/女，如果不是则抛出：性别异常
在年龄的set方法中判断年龄是否是15–50之间，如果不是则抛出：年龄异常
编写测试类，创建一个Student对象，并在try{}中调用setXxx()方法为对象属性赋值，在catch()中打印年龄错误。

AgeExeption

public class AgeException extends RuntimeException{
    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }
}

SexException

public class SexException extends RuntimeException{
    public SexException() {
    }

    public SexException(String message) {
        super(message);
    }
}

Student

public class Student {
    private String name;
    private String sex;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        if(!sex.equals("男")&&!sex.equals("女")){
            throw new SexException("性别异常");
        }
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<15||age>50) {
            throw new AgeException("年龄异常");
        }
        this.age = age;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        try{
            student.setAge(100);
        } catch (AgeException e) {
            System.out.println(e.getMessage());
        }
    }
}

15.异常练习2

写一个方法实现用户登录，传入用户名和密码
如果用户名错误，就抛出自定义登录异常(LoginException)，异常信息为用户名不存在。
如果密码错了就也抛出登录异常,异常信息为密码错误
如果用户名和密码都对了,输出: 欢迎xxx

说明：正确用户名和密码都是admin

//编译时异常
public class LoginException extends Exception {
    public LoginException() {
        super();
    }

    public LoginException(String message) {
        // 一定要调用父类的构造方法
        super(message);
    }
}

public class TestDemo {
    // a)提供一个用于登陆的方法login(String name,String pwd),在放方法中
    public static void login(String name, String pwd) throws LoginException {
        // i.如果用户名错误,就抛出自定义登陆异常(LoginException),异常信息为用户名不存在
        if (!"admin".equals(name)) {
            throw new LoginException("用户名:" + name + "不存在");
        }
        // ii.如果密码错了就也抛出登陆异常,异常信息为密码错误.
        if (!"admin".equals(pwd)) {
            throw new LoginException("密码错误");
        }
        // iii.如果能来到下面,就说明用户和密码都是对的,输出: 欢迎xxx
        System.out.println("欢迎" + name);
    }

    public static void main(String[] args) {
        try {
            // i.调用login方法,传入错误用户名,运行程序,报运行时异常,然后注释这行代码
             login("admin", "123456");
            
            // ii.调用login方法,传入正确用户名,错误的命名,运行程序,报运行时异常,然后注释这行代码
            // login("admin", "123");
            // iii.调用login方法,传入正确的用户名和密码
           //ogin("admin", "admin");
        } catch (LoginException e) {
            e.printStackTrace();
        }
    }
}

16.模拟注册用户，按照以下要求实现相关功能：

提示用户在控制台输入手机号码，并接收
判断该手机号码是否是11位，是否都是数字，其余可以不做判断，如果不符合任意一项，则提示用户"注册用户失败"
将手机号的后四位获取出来输出到控制台上

提示：使用异常解决验证手机号是数字的问题

public class Test {
    public static void main(String[] args) {
        //接收键盘录入的手机号
        System.out.println("请录入手机号：");
        String phone = new Scanner(System.in).next();

        //手机号是否为11位、手机号是否为纯数字
        if(phone!=null && phone.length()==11 && validate(phone)){

            System.out.println("手机号末尾4位数字："+phone.substring(7));

        }else {
            System.out.println("注册用户失败!");
        }
    }

    //验证手机号是否为纯数字
    public static boolean validate(String phone) {
        try {
            //String -> long
            long num = Long.parseLong(phone);
            /*如果字符串不是纯数字，转换为long类型时，会引发异常*/
        } catch (Exception e) {
            //String转long类型发生异常时，不是数字，就返回false
            return false;
        }
        //当String转long类型没有任何问题，说明是数字，返回true
        return true;
    }
}

17.定义一个方法能接受一个整数(这个整数大于3) 打印0到这个整数(包含)之间的所有的偶数

例如：接受的数字是6则调用完方法打印出来的偶数是 0 2 4 6
接受的数字是 5则调用完方法打印出来的偶数是 0 2 4
操作步骤描述
1.创建一个测试类,在测试类中创建上述方法
2.定义一个无返回值,有参数的方法
3.在方法内部把符合条件的数字打印
4.在主方法中调用这个方法,并传入数字15进行测试

import java.util.Scanner;

/*
1 定义一个方法 能接受一个整数(这个整数大于3) 打印0到这个整数(包含)之间的所有的偶数*/
public class Test {
     public static void  method()
     {
         Scanner scanner=new Scanner(System.in);
         System.out.println("请输入要接收的数据");
         int num= scanner.nextInt();//键盘录入数据
         int i=0;
         if(num>3&&num%2==0)//判断大于3的偶数
         {
             /*循环输出*/
             while (i<=num)
             {
                 System.out.print(i+"\t");
                 i+=2;//每次自增2

             }
         }

         /*循环输出*/
         else if(num>3&&num%2==1)
         {
             while (i<=num)
             {
                 System.out.print(i+"\t");
                 i+=2;
             }
         }

     }
     public static void main(String[] args) {
           method();
    }
}

18.随机产生两个整数,随机数的范围均是[1,100],定义方法求这两个整数的和并打印和值

1.创建一个测试类
2.在主方法中使用随机数产生两个范围是[1,100]的随机数
3.定义一个求两个整数和的方法
4.在主方法中调用这个求和方法得到结果值,并打印

import java.util.Random;

public class Test {
    public  static void method()
    {
        Random random=new Random();//导入Random类，用于产生随机数
        int num1=random.nextInt(100)+1;//定义随机数num1
        System.out.println("随机数num1="+num1);
        int num2=random.nextInt(100)+1;//定义随机数num2
        System.out.println("随机数num2="+num2);
        System.out.println("num1+num2="+(num1+num2));//这两个整数的和并打印和值

    }
    public static void main(String[] args) {
        method();//调用方法
    }
}

19.主方法中给定数组int[] arr= {20,10,40,30,50,60};定义一个方法可以接受这个给定的数组并返回这个数组中元素的最小值

创建一个测试类,在测试类中写该方法
定义一个方法可以接收一个整型的一维数组
在方法内部求出数组元素的最小值,并把这个最小值返回
在主方法中调用上述方法传递数组arr,得到数组中元素的最小值并打印

public class Test {

    public static void method(int[] arr)//定义method()方法并设置形参,传入数组arr

    {
        int min=arr[0];//定义最小值min并且把 数组元素第一个值arr[0]赋值给min
        for(int i=1;i< arr.length;i++)
        {

            /*if里面的表达式用于找出最小值*/
           if(min>arr[i])
           {
               min=arr[i];
           }
        }
        System.out.println("arr数组里面的最小值："+min);
    }
    public static void main(String[] args) {
        int[] arr= {20,10,40,30,50,60};
          method(arr);//调用并接收数组arr
    }
}

20.定义一个方法,求出给定的数字在给定int型数组中出现的次数,如果一次没有出现则返回0

如:给定数字3 求出3在数组 int[] arr = {3,4,3,5,7,9};中出现的次数

public class Test{
    public  static void method2(int[] array)//定义数组
    {
        int[] result={};//定义一个空数组，下面可以用于赋值
        for(int i=0;i< array.length;i++)
        {
            result=method(array,array[i]);//将每个数组元素arraty[i]以及出现的次数存储在result[] 数组里面
            System.out.println("指定数字:"+result[0]+"在数组中的出现次数是:"+result[1]);//输出结果
        }

    }

    public static int[] method(int[] arr,int num)//定义形参:数组arr和数字num
    {
        int count=0;//定义conut变量用于统计次数
        for(int i=0;i< arr.length;i++)
        {
            if(num==arr[i])
            {
                count++;//次数
            }

        }
        int[] result={num,count};//定义一个数组result用于存储，指定数字num和该数字出现的次数
        return result;//返回数组
    }

    public static void main(String[] args) {
        int[] arr = {3,4,3,5,7,9};//定义数组arr
        method2(arr);

    }
}

21.定义一个方法，查找指定数字在数组中出现的索引(若出现多次，多次打印)

如: 数组{1,2,3,2} 要查找的数是2 则方法内部会打印索引值 1 3
数组{1,2,3,2} 要查找的数是5 则方法每部会打印 “数组中没有这个数字”

public class Test {
    public static  int arrlen(int a,int[] arr)
    {
        int  count=0;
        if(arr.length==0)
        {
            System.out.println("数组里面没有该数字");
        }

        for (int i = 0; i < arr.length; i++) {
            if(a==arr[i])
            {
                System.out.println("指定数字在数组里面的位置是:"+i);
                count++;
            }
        }
        return count;//该数字出现的个数
    }
    public static void main(String[] args) {
           int[] arr={2,4,6,7,10,10,330,5};
           int a=10;
           //arrlen(a,arr);
           int len=arrlen(a,arr);
        System.out.println("该数字出现的次数是:"+len);

    }
}

22.方法练习

1.键盘录入一个整数(正数或者负数都可以,但是符号位不算有效的数字位)
2.定义一个方法,该方法的功能是计算该数字是几位数字,并将位数返回
3.在main方法中打印该数字是几位数
4.演示格式如下:
(1)演示一:
请输入一个整数:1234
控制台输出:1234是4位数字
(2)演示二:
请输入一个整数:-34567
控制台输出:-34567是5位数字

/*(1)演示一:
        请输入一个整数:1234
        控制台输出:1234是4位数字
        (2)演示二:
        请输入一个整数:-34567
        控制台输出:-34567是5位数字
 */
import java.util.Scanner;
public class Test {
    public  static  void method()

    {
         Scanner scanner=new Scanner(System.in);
          int s=0;//定义一个变量s，为了把s传给后面的键盘录入数据num
          int count=0;//定义该变量用于判断数据num是几位数
          System.out.println("请输入一个数:");
           int num=scanner.nextInt();//定义键盘录入数据
          /* (1)If语句用于判断在正数的情况*/
               if(num>0)
               {
                   s=num;
                   while(num!=0)
                   {
                      num=num/10;
                       count++;
                   }
                   System.out.println("控制台输出:"+s+"是"+count+"位数");
               }

               /*(2)If语句用于判断在负数的情况*/
               else  if(num<0)
               {
                   s=num;
                   num=-num;
                   while(num!=0)
                   {
                       num=num/10;

                       count++;
                   }
                   System.out.println("控制台输出:"+s+"是"+count+"位数");
               }

             /*(3)当输入数据是0的时候*/
               else
               {
                   System.out.println("输入数据是一位数:"+0);
               }

      }

    public static void main(String[] args) {
        method();
    }
}

标签： java 前端数据库

本文转载自: https://blog.csdn.net/Terita/article/details/126960160
版权归原作者 Terita 所有，如有侵权，请联系我们删除。