Java面向对象编程题
Posted Terita
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java面向对象编程题相关的知识，希望对你有一定的参考价值。
目录
5.编写一个关于星期几的枚举WeekDay要求：枚举值：MON,TUE,WED,THR,FRI,SAT,SUN该枚举要有一个方法，调用该方法返回中文格式的星期几
6.异常：请定义main()方法，在main()中按以下顺序要求编写代码：
12.请定义main()方法，在main()中按以下顺序要求编写代码：
13.请定义main()方法，在main()中按以下顺序要求编写代码：
17.定义一个方法 能接受一个整数(这个整数大于3) 打印0到这个整数(包含)之间的所有的偶数
18.随机产生两个整数,随机数的范围均是[1,100],定义方法求这两个整数的和并打印和值
19.主方法中给定数组int[] arr= 20,10,40,30,50,60;定义一个方法可以接受这个给定的数组并返回这个数组中元素的最小值
20.定义一个方法,求出给定的数字在给定int型数组中出现的次数,如果一次没有出现则返回0
21.定义一个方法，查找指定数字在数组中出现的索引(若出现多次，多次打印)
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面试逐个突破：OOP（面向对象编程）精选面试108题（附答案）
互联网技术飞跃发展的背后，是无数工程师们利用编程算法，敲出一个个实现我们想法的程序。可以说，我们现在的生活，是被无数的编程包围着。再加上互联网行业的繁荣以及较高的福利薪酬，让很多人开始对编程感兴趣，并有意愿学习和转行。
JavaOOP面试题
1、什么是B/S架构？什么是C/S架构
2、Java都有哪些开发平台？
3、什么是JDK？什么是JRE?
4、Java语言有哪些特点
5、面向对象和面向过程的区别
6、什么是数据结构？
7、Java的数据结构有哪些？
8、什么是OOP?
9、类与对象的关系?
10、Java中有几种数据类型
11、标识符的命名规则。
12、instanceof关键字的作用
13、什么是隐式转换，什么是显式转换
14、Char类型能不能转成int类型？能不能转化成string类型，能不能转成double类型
15、什么是拆装箱？
16、Java中的包装类都是那些？
17、一个java类中包含哪些内容？
18、那针对浮点型数据运算出现的误差的问题，你怎么解决？
19、面向对象的特征有哪些方面?
20、访问修饰符 public,private,protected,以及不写（默认） 时的区别？
21、String 是最基本的数据类型吗？
22、flfloat f=3.4;是否正确？
23、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1; 有错吗？
24、重载和重写的区别
25、equals与==的区别
36、++i与i++的区别
37、程序的结构有哪些？
38、数组实例化有几种方式？
39、Java中各种数据默认值
40、Java常用包有那些？
41、Object类常用方法有那些？
42、java中有没有指针？
43、java中是值传递引用传递？
44、实例化数组后，能不能改变数组长度呢？
45、假设数组内有5个元素，如果对数组进行反序，该如何做？
46、形参与实参区别
47、构造方法能不能显式调用？
48、什么是方法重载？
49、构造方法能不能重写？能不能重载？
50、内部类与静态内部类的区别？
51、Static关键字有什么作用？
52、fifinal在java中的作用，有哪些用法?
53、StringString StringBuffffffffer 和 StringBuilder 的区别是什么？
54、String str=”aaa”,与String str=new String(“aaa”)一样吗？
55、讲下java中的math类有那些常用方法？
56、String类的常用方法有那些？
57、Java中的继承是单继承还是多继承
58、Super与this表示什么？
59、普通类与抽象类有什么区别？
60、什么是接口？为什么需要接口？
61、接口有什么特点？
62、抽象类和接口的区别?
63、Hashcode的作用
64、 Java的四种引用，强弱软虚
65、Java创建对象有几种方式？
66、有没有可能两个不相等的对象有相同的hashcode
67、拷贝和浅拷贝的区别是什么?
68、static都有哪些用法?
69、a=a+b与a+=b有什么区别吗?
70、fifinal、fifinalize()、fifinally
71、JDBC操作的步骤
72、在使用jdbc的时候，如何防止出现sql注入的问题。
73、怎么在JDBC内调用一个存储过程
74、是否了解连接池，使用连接池有什么好处？
75、你所了解的数据源技术有那些？使用数据源有什么好处？
76、&和&&的区别
77、静态内部类如何定义
78、什么是成员内部类
79、Static Nested Class 和 Inner Class的不同
80、什么时候用assert
81、Java有没有goto
82、数组有没有length()这个方法? String有没有length()这个方法
83、用最有效率的方法算出2乘以8等於几
84、flfloat型flfloat f=3.4是否正确?
85、排序都有哪几种方法？请列举
86、静态变量和实例变量的区别？
87、说出一些常用的类，包，接口，请各举5个
88、a.hashCode() 有什么用？与 a.equals(b) 有什么关系？
89、Java 中的编译期常量是什么？使用它又什么风险？
90、在 Java 中，如何跳出当前的多重嵌套循环？
91、构造器（constructor）是否可被重写（override）？
92、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？
93、是否可以继承 String 类？
94、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变
化后的结果，那么这里到底是值传递还是引用传递？
95、String 和 StringBuilder、StringBuffffer 的区别？
96、重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区
分？
97、char 型变量中能不能存贮一个中文汉字，为什么？
98、抽象类（abstract class）和接口（interface）有什么异同 ？
99、静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？
100、Java 中会存在内存泄漏吗，请简单描述。
101、抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法
102、是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？
103、如何实现对象克隆？
104、接口是否可继承（extends）接口？抽象类是否可实现（implements）接口？抽象类
是否可继承具体类（concreteclass）？
105、一个”.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？
106、Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？
107、内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？
108、Java 中的 fifinal 关键字有哪些用法？
由于篇幅原因，整整两万多字的详细答案无法上传，只粗略的展示了答案的截图，有需要的朋友见文末…………
面试答案参考：
由于篇幅原因，整整两万多字的详细答案无法上传，只粗略的展示了答案的截图，有需要的朋友：添加VX——13272413561（备注51免费获取哦）
附带资料：
Java高级架构面试知识点整理
1000道 互联网Java工程师面试题 485页
机会从来只会留给有准备的人，做好准备，随时出发。
获取方式：添加VX——13272413561（备注51免费获取哦）
以上是关于Java面向对象编程题的主要内容，如果未能解决你的问题，请参考以下文章