Java面向对象练习题

最新推荐文章于 2024-05-27 15:11:41 发布
最新推荐文章于 2024-05-27 15:11:41 发布
阅读量1.4w 收藏 255
点赞数 28
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43701330/article/details/87548872
版权

1.
在这里插入图片描述

import java.util.Scanner;
class Demo5_2{
	/*
	类
		StopWatch
		属性 startTime  endTime
		无参构造函数   初始化startTime
		行为 start()  将startTime重设为当前时间
			 stop() 将endTime设为当前时间
			 getElapsedTime() 记录过去了多少时间
	*/
	public static void main(String[] args){
		StopWatch s=new StopWatch();
		long start=s.start();
		System.out.println(start);
		if(s.ifStop()){
			long end=s.stop();
			System.out.println(end);
			System.out.println(s.getElapsedTime(start,end));
		}
	}
}
class StopWatch{
	long startTime;
	long endTime;
	
	public StopWatch(){
		this.startTime=System.currentTimeMillis();
	}
	public long start(){
		this.startTime=System.currentTimeMillis();
		return startTime;
	}
	public long stop(){
		this.endTime=System.currentTimeMillis();
		return endTime;
	}
	public long getElapsedTime(long startTime,long endTime){
		return (endTime-startTime);
	}
	public boolean ifStop(){
		Scanner scanner=new Scanner(System.in);
		if (scanner.nextBoolean()){
			return true;
		}else{
			return false;
		}
	}
	public long getStartTime(){
		return this.startTime;
	}
	public long getEndTime(){
		return this.endTime;
	}
}

2.
在这里插入图片描述

import java.util.Scanner;
class Demo5_3{
	public static void main(String[] args){
		Fan f=new Fan();
		Scanner scanner=new Scanner(System.in);
		while(true){
			int i;
			boolean flag=false;
			System.out.println("请输入0（关）或1（开）：");
			i=scanner.nextInt();
			if(i==1){
				flag=true;
				f.setOn(flag);
				System.out.println(f.toString(f.isOn()));
				break;
			}else if(i==0){
				System.out.println(f.toString(f.isOn()));
				break;
			}else {
				System.out.println("请重新输入:");
			}
		}
	}
}
class Fan{
	final static int SLOW=1;
	final static int MEDIUM=2;
	final static int FAST=3;
	private int speed=SLOW;
	private boolean on=false;
	private double radius=5;
	private String color="blue";
	public Fan(){
	
	}
	public void setSpeed(int speed){
		this.speed=speed;
	}
	public void setOn(boolean on){
		this.on=on;
	}
	public void setRadius(int radius){
		this.radius=radius;
	}
	public void setColor(String color){
		this.color=color;
	}
	public int getSpeed(){
		return this.speed;
	}
	public boolean isOn(){
		return this.on;
	}
	public double getRadius(){
		return this.radius;
	}
	public String getColor(){
		return this.color;
	}
	public String toString(boolean on){
		String s;
		if(on){
			s=this.speed+":"+this.color+":"+this.radius;
			return s;
		}else{
			s="Fan is off:"+this.color+":"+this.radius;
			return s;
		}
	}
}

3.
在这里插入图片描述

import java.util.Scanner;
class Demo5_4{
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		System.out.print("请输入a,b,c:");
		QuadraticEquation q=new QuadraticEquation(scanner.nextDouble(),scanner.nextDouble(),scanner.nextDouble());
		if(q.getDiscriminant()>0){
			double x1=q.getRoot1(q.getDiscriminant());
			double x2=q.getRoot2(q.getDiscriminant());
			System.out.println("x1="+x1);
			System.out.println("x2="+x2);
		}else if(q.getDiscriminant()==0){
			double x=q.getRoot2(q.getDiscriminant());
			System.out.println("x="+x);
		}else{
			System.out.println("The equation has no roots.");
		}
	}
}
class QuadraticEquation{
	private double a;
	private double b;
	private double c;
	public QuadraticEquation(){
		this(0,0,0);
	}
	public QuadraticEquation(double a,double b,double c){
		this.a=a;
		this.b=b;
		this.c=c;
	}
	public double getA(){
		return this.a;
	}
	public double getB(){
		return this.b;
	}
	public double getC(){
		return this.c;
	}
	public double getDiscriminant(){
		double delt=Math.pow(getB(),2)-4*getA()*getC();
		return delt;
	}
	public double getRoot1(double delt){
		double x1=(-getB()+getDiscriminant())/(2*getA());
		return x1;
	}
	public double getRoot2(double delt){
		double x2=(-getB()-getDiscriminant())/(2*getA());
		return x2;
	}
}

4.
在这里插入图片描述

import java.util.Scanner;
class Demo5_5{
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter row-col:");
		double[][] arr=new double[scanner.nextInt()][scanner.nextInt()];
		System.out.println("请输入矩阵:");
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				arr[i][j]=scanner.nextDouble();
			}
		}
		Location.locateLargest(arr);
	}
}
class Location{
	public int row;
	public int col;
	public double maxValue;
	public static void locateLargest(double[][] a){
		if(a==null){
			System.out.println("数组为空");
			return;
		}
		if(a.length==0){
			System.out.println("数组中没有元素");
			return;
		}
		Location l=new Location();
		l.maxValue=a[0][0];
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				if(a[i][j]>l.maxValue){
					l.row=i;
					l.col=j;
					l.maxValue=a[i][j];
				}
			}
		}
		System.out.print("The location of the largest is "+l.maxValue+" at "+"("+l.row+","+l.col+")");
	}
}

5.
在这里插入图片描述

class Demo5_6{
	public static void main(String[] args){
	Circle c1=new Circle(2.0,2.0,5.5);
	Circle c2=new Circle();
	System.out.println(c1.getArea());
	System.out.println(c2.getArea());
	System.out.println(c1.getPerimeter());
	System.out.println(c1.contains (3,3));
	System.out.println(c1.contains(new Circle(4,5,10.5)));
	System.out.println(c1.overlaps(new Circle(3,5,2.3)));
	}
}
class Circle{
	private Pointer center;
	private double radius;
	public Circle(){
		this(0,0,1);
	}
	public Circle(double x,double y){
		this.center=new Pointer(x,y);
	}
	public Circle(double x,double y,double radius){
		center=new Pointer(x,y);
		this.radius=radius;
	}
	public double getArea(){
		return Math.PI*Math.pow(this.radius,2);
	}
	public double getPerimeter(){
		return Math.PI*2*this.radius;
	}
	public double getRadius(){
		return this.radius;
	}
	public boolean contains(double x,double y){
		Pointer c=new Pointer(x,y);
		double distance=center.getDistance(c);
		if(distance>this.radius){
			return false;
		}else{
			return true;
		}
	}
	public boolean contains(Circle other){
		double distance=center.getDistance(other.center);
		if(distance>Math.abs(this.radius-other.radius)){
			return false;
		}else{
			return true;
		}
	}
	public boolean overlaps(Circle other){
		double distance=center.getDistance(other.center);
		if(distance<Math.abs(this.radius-other.radius)&&distance>(this.radius-other.radius)){
			return false;
		}else{
			return true;
		}
	}
}
class Pointer{
	private double x;
	private double y;
	public Pointer(){
		this(0,0);
	}
	public Pointer(double x,double y){
		this.x=x;
		this.y=y;
	}
	public double getDistance(Pointer c){
		double deltX=this.x-c.x;
		double deltY=this.y-c.y;
		return Math.sqrt(Math.pow(deltX,2)+Math.pow(deltY,2));
	}
	public double getX(){
		return this.x;
	}
	public double getY(){
		return this.y;
	}
}

6.
在这里插入图片描述

class Demo5_7{
	public static void main(String[] args){
		MyDate md=new MyDate();
		System.out.println(md.getYear());
		System.out.println(md.getMonth());
		System.out.println(md.getDay());
		
	}
}
class MyDate{
	private long year;
	private long month;
	private long day;
	private long days;
	private static int[] daysOfYear;
	private static int[] runYears={31,29,31,30,31,30,31,31,30,31,30,31};
	private static int[] pingYears={31,28,31,30,31,30,31,31,30,31,30,31};
	//静态代码块 类加载完毕后直接执行
	static{
		daysOfYear=new int[50];//1970-1971...
		for(int i=1970;i<daysOfYear.length+1970;i++){
			if(i%4==0&&i%100!=0||i%400==0){
				daysOfYear[i-1970]=366;
			}else{
				daysOfYear[i-1970]=365;
			}
		}
	}
	public MyDate(){
		this.year=calcuYear(System.currentTimeMillis());
		this.month=calcuMonth();
		this.day=days+1;
	}
	public MyDate(long times){
		this.year=calcuYear(times);
		this.month=calcuMonth();
		this.day=days+1;
	}
	private long calcuMonth(){
		int index=0;
		int[] daysOfMonth;
		if(year%4==0&&year%100!=0||year%400==0){
			daysOfMonth=runYears;
		}else{
			daysOfMonth=pingYears;
		}
		while(true){
			if(days<daysOfMonth[index]){
				break;
			}else{
				days=days-daysOfMonth[index];
				index++;
			}
		}
		return index+1;
	}
	private long calcuYear(long times){
		days=times/1000/60/60/24;
		int index=0;
		while(true){
			if(days<daysOfYear[index]){
				break;
			}else{
				days=days-daysOfYear[index];
				index++;
			}
		}
		return 1970+index;
	}
	public long getYear(){
		return this.year;
	}
	public long getMonth(){
		return this.month;
	}
	public long getDay(){
		return this.day;
	}
}

7.
在这里插入图片描述

class Demo5_8{
	public static void main(String[] args){
		RegularPolygon r=new RegularPolygon(6,4);
		RegularPolygon r1=new RegularPolygon(10,4,5.6,7.8);
		RegularPolygon r2=new RegularPolygon();
		System.out.println(r.getPerimeter());
		System.out.println(r.getArea());
		System.out.println(r1.getPerimeter());
		System.out.println(r1.getArea());
		System.out.println(r2.getPerimeter());
		System.out.println(r2.getArea());
	}
}
class RegularPolygon{
	private int n;
	private double side;
	private Pointer center;
	public RegularPolygon(){
		this(3,1,0,0);
	}
	public RegularPolygon(int n,double side){
		this(n,side,0,0);
	}
	public RegularPolygon(int n,double side,double x,double y){
		this.n=n;
		this.side=side;
		this.center=new Pointer(x,y);
	}
	public int getN(){
		return this.n;
	}
	public double getSide(){
		return this.side;
	}
	public Pointer getCenter(){
		return this.center;
	}
	public double getPerimeter(){
		return this.n*this.side;
	}
	public double getArea(){
		return (this.n*Math.pow(this.side,2))/(4*Math.tan(Math.PI/this.n));
	}
}
class Pointer{
	private double x;
	private double y;
	public Pointer(){
		this(0,0);
	}
	public Pointer(double x,double y){
		this.x=x;
		this.y=y;
	}
	public double getX(){
		return this.x;
	}
	public double getY(){
		return this.y;
	}
}

8.Arrays工具类

class ArraysDemo{
	public static void main(String[] args){
		int[] arr=new int[]{5,6,2,3,4,1,8,9,7};
		System.out.println(MyArrays.toString(arr));
		MyArrays.sort(arr);
		System.out.println(MyArrays.toString(arr));
		System.out.println(MyArrays.binarySearch(arr,4));
		System.out.println(MyArrays.binarySeachUpper(arr,4));
		//System.out.println(MyArrays.toString(arr));
	}
}
class MyArrays{
	public static void sort(int[] a){
		if(a==null){
			System.out.println("数组为空");
			return;
		}
		if(a.length==0){
			System.out.println("数组中没有元素");
			return;
		}
		for(int i=1;i<a.length;i++){
			int e=a[i];
			int j;
			for(j=i;j>0&&a[j-1]>e;j--){
				a[j]=a[j-1];
			}
			a[j]=e;
		}
	}
	public static int binarySearch(int[] a,int key){
		if(a==null){
			System.out.println("数组为空");
			return -1;
		}
		if(a.length==0){
			System.out.println("数组中没有元素");
			return -1;
		}
		if(isSort(a)){
			int min=0;
			int max=a.length-1;
			int mid=(min+max)/2;
			while(a[mid]!=key){
				if(a[mid]>key){
					max=mid-1;
				}else if(a[mid]<key){
					min=mid+1;
				}
				mid=(min+max)/2;
				if(min>max){
					System.out.println("找不到");
					return -1;
				}
			}
			return mid;
		}
		System.out.println("找不到");
		return -1;
	}
	private static boolean isSort(int[] a){
		for(int i=0;i<a.length-1;i++){
			if(a[i]>a[i+1]){
				return false;
			}
		}
		return true;
	}
	public static int[] copy(int[] a,int newLength){
		int[] b=new int[newLength];
		for(int i=0;i<Math.min(a.length,b.length);i++){
			b[i]=a[i];
		}
		return b;
	}
	public static int binarySeachUpper(int[] a,int key){
		if(a==null){
			System.out.println("数组为空");
			return -1;
		}
		if(a.length==0){
			System.out.println("数组中没有元素");
			return -1;
		}
		int[] b=copy(a,a.length);
		int[] indexs=new int[b.length];
		for(int i=0;i<indexs.length;i++){
			indexs[i]=i;
		}
		for(int i=1;i<b.length-1;i++){
			int e=b[i];
			int index=indexs[i];
			int j;
			for(j=i;j>0&&b[j-1]>e;j--){
				b[j]=b[j-1];
				indexs[j]=indexs[j-1];
			}
			b[j]=e;
			indexs[j]=index;
		}
		int index=binarySearch(b,key);
		return b[index];
	}
	public static String toString(int[] a){
		if(a.length==0){
			return "["+"]";
		}
		String s="[";
		for(int i=0;i<a.length;i++){
			if(i==a.length-1){
				s+=a[i]+"]";
			}else{
				s+=a[i]+",";
			}
		}
		return s;
	}
}

9.吃鸡

import java.util.Arrays;
class ChiJi{
	public static void main(String[] args){
		Player p1=new Player("小明");
		Player p2=new Player("老王");
		Clips clips=new Clips();
		for(int i=1;i<=20;i++){
			p1.zhuangDan(clips,new Bullent());
		}
		Gun gun=new Gun();
		p1.takeGun(gun);
		p1.shangTang(clips);
		for(int i=1;i<=30;i++){
			p1.kaiQiang(p2);
			if(p2.HP<=0){
				break;
			}
		}
		System.out.println("死亡");
		System.out.println(p2.HP);
	}
}
/*
类	玩家 Player
	属性 昵称 name
		 血量 HP
		 枪 gun
	行为 捡枪（枪）
		 装弹（弹夹，子弹）
		 上膛（弹夹）
		 开枪（玩家）
		 掉血（伤害值）
*/
class Player{
	String name;
	int HP;
	Gun gun;
	public Player(String name){
		this.name=name;
		this.HP=100;
		this.gun=null;		
	}
	public void takeGun(Gun gun){
		this.gun=gun;
	}
	public void zhuangDan(Clips clips,Bullent bullent){
		clips.loding(bullent);
	}
	public void shangTang(Clips clips){
		gun.takeClips(clips);
	}
	public void kaiQiang(Player enemy){
		gun.shoot(enemy);
	}
	public void diaoXue(int damage){
			HP-=damage;
	}
}
/*
类	枪
	属性 弹夹 clips
	行为 装弹夹=Player上膛（弹夹）
		 开枪(玩家)
*/
class Gun{
	Clips clips;
	public void takeClips(Clips clips){
		this.clips=clips;
	}
	public void shoot(Player enemy){
		Bullent bullent=clips.out();
		if(bullent==null){
			System.out.println("放了 一个空枪");
		}else{
			bullent.hit(enemy);
		}
	}

}
/*
类  弹夹
	属性 子弹 bullent
	行为 装弹（子弹）
		 出弹（）
*/
class Clips{
	Bullent[] bullents=new Bullent[0];
	int maxSize=30;
	public void loding(Bullent bullent){
		if(bullents.length>=maxSize){
			System.out.println("弹夹已满");
		}else{
			bullents=Arrays.copyOf(bullents,bullents.length+1);
			bullents[bullents.length-1]=bullent;
		}
	}
	public Bullent out(){
		Bullent bullent;
		if(bullents.length>0){
			bullent=bullents[bullents.length-1]; 
			bullents=Arrays.copyOf(bullents,bullents.length-1);	
			return bullent;
		}else{
			System.out.println("没有子弹了！！！");
			return null;
		}
	}

}
/*
类	子弹
	属性 伤害值 damage
	行为 
		命中 hit(玩家)
*/
class Bullent{
	int damage=10;
	public void hit(Player enemy){
		enemy.diaoXue(damage);
	}
}

10.接口

class InterfaceDemo{
	public  static void main(String[] args){
		Button bt_login=new Button();
		//局部内部类（匿名实现子类的匿名对象）
		bt_login.doSomething(new Task(){
			public void doWhat(){
				System.out.println("登录....");
			}
		});
	}
}
class Button{
	public void  doSomething(Task task){
		task.doWhat();
	}
}
interface Task{
	public abstract void doWhat();
}

**11.内部类 **

class InsideDemo{
	public static void  main(String[] args){
		A a=new A();
		A.B b=a.new B();
		b.show();
		System.out.println(a.num);
		System.out.println(b.num);
	}
}
class  A{
	int num=1;
	class B{
		int num=2;
		public void show(){
			System.out.println("B ......");
			System.out.println(A.this.num);
		}
	}
}

12.抽象类

class AbstractDemo{
	public static  void main(String[] args){
		Animal a=new Dog();
		a.eat();
		Animal b=new Cat();
		b.eat();
	}
}
abstract class Animal{
	public abstract void eat();
}
class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

13.代理模式

class DaiLiDemo{
	public static void main(String[] args){
		Wang w=new Wang();
		w.setP("Ma");
		w.happy();
	}
}
interface BadWoman{
	void happy();
}
class  Wang implements BadWoman{
	BadWoman b;
	public void setP(String name){
		if(name.equals("Ma")){
			b=new Ma();
		}else if(name.equals("Pan")){
			b=new Pan();
		}
	}
	public void happy(){
		b.happy();
	}
}
class Ma implements BadWoman{
	public void happy(){
		System.out.println("Ma happy!");
	}
}
class Pan implements BadWoman{
	public void happy(){
		System.out.println("Pan happy!");
	}
}

14.单例模式

class DanLiDemo{
	public static void main(String[] args){
		A a=A.setA();
		A b=A.setA();
		System.out.println(a==b);
		B b1=B.setB();
		B b2=B.setB();
		System.out.println(b1==b2);
	}
}
//饿汉模式
class A{
	public static A a=new A();
	public static A setA(){
		return a;
	}
}
//饱汉模式
class  B{
	public static B b=null;
	public static B setB(){
		if(b==null){
			b=new B();
		}
		return b;
	}
}

15.静态内部类

class StaticInsideDemo{
	public static void  main(String[] args){
		A a=new A();
		System.out.println(a.num);
		System.out.println(A.B.num);
		new A.B().show();
	}
}
class  A{
	int num=1;
	static class B{
		static int num=2;
		public void show(){
			System.out.println("B......");
		}
	}
}
長安꧔ꦿ
关注
  • 28
    点赞
  • 踩
  • 255
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Java面向对象基础练习题
08-06
适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
对象的练习题
g234567582的博客
10-20 122
对象的练习题
JAVA面向对象参考练习题
life_boy的博客
08-30 354
1. (秒表) 设计一个名为Stopwatch的类，该类包含：（System.currentTimeMillis()） 1）具有访问器方法的私有数据域startTime和 endTime。 2）一个无参构造方法，使用当前时间来初始化startTime。 3）一个名为start()的方法,将startTime重设为当前时间。 4）一个名为stop(的方法,将endTime设置为当前时间。 5）一个名为getElapsedTime()的方法，以毫秒为单位返回秒表记录的流逝时间。
面向对象综合训练
最新发布
2301_80709894的博客
05-27 779
本篇章主要展示了面向对象知识板块的一些练习题目及细小知识的补充和本人在本次编程练习中出现的一些报错的解决方法。在了解了面向对象的基础知识并进行一些简单练习后，一定要自己独立动手练习代码，为以后的进阶打好基础。
Java EE - 面向对象基础、string、ArrayLIst练习题
小马测试之路的博客
09-13 1893
常见APi String、Array练习题
Python 类与对象的练习题
cc576795555的博客
10-28 1万+
1、创建员工类Employee，属性有姓名name、能力值ability、年龄age（能力值为100-年龄），功能有doWork（），该方法执行一次，该员工的能力值-5，创建str方法，打印该员工的信息 2、创建老板类Boss，属性有金钱money,员工列表employeeList（存储员工类对象），工作量work,功能有雇佣员工addEmployee()，雇佣后将员工添加至列表中，雇佣一人mon...
【Java期末复习】《面向对象程序设计》练习库
weixin_61639349的博客
02-20 1万+
计算圆的面积，其中PI取3.14，圆半径为负数时应抛出异常，输出相应提示 设计一个名为StudentOf2019EE的类，表示2019电子信息工程专业的学生。类包含:String类型私有成员变量name，表示学生的姓名。构造一个Rectangle类表示矩形 ， 该类实现了Comparable接口。该类有两个私有的double型成员变量width和height，表示矩形的宽度和高度 2、简单加法计算器的实现 House类 矩形类创建一个Box类，求其体积 6-1 求圆面积自定义异常类
java面向对象练习题-经典
08-23
Java面向对象练习题经典 Java面向对象练习题是Java编程语言中非常重要的一部分，这些练习题涵盖了Java语言的基础知识，包括Java基本数据类型、运算符、控制结构、方法、类和对象、继承、多态、抽象类和接口等方面。...
Java面向对象之继承练习题.doc
08-04
刚开始学，需要简单题目加深对概念的理解
Java面向对象编程练习题.pdf
05-22
Java面向对象编程练习题 本资源摘要信息涵盖了 Java 面向对象编程的基础知识，通过三个练习题，展示了 Java 编程语言的基本概念和应用。 练习题 01: 类的成员变量 本练习题展示了 Java 中类的成员变量的概念。类 ...
Java面向对象试题.pdf
08-28
Java面向对象试题
Java 面向对象 练习题与答案
12-23
Java 面向对象 练习题与答案
Java面向对象编程题
Terita的博客
09-20 1万+
Java面向对象编程题
Java编程练习题：面向对象练习
weixin_51612062的博客
07-26 3709
Java编程练习题：面向对象练习：1. (LeetCode 第169题)给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数大于 n/2 的元素。2. 综合案例（用户博客管理系统）3.（抽象类）定义一个抽象的"Role"类 有姓名 年龄 性别等成员变量。4.（抽象类）品尝饮料...
Java基础——面向对象综合练习
weixin_52297290的博客
05-28 496
需求:​ 格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。举例：​ 程序运行之后结果为：​ 姓名为:乔峰 血量为:100​ 姓名为:鸠摩智 血量为:100​ 乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。​ 鸠摩智举起拳头打了鸠摩智一下，造成了XX点伤害，乔峰还剩下XXX点血。​ 乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。
每日作业 - JavaSE第7天
FreeSpider
10-19 2195
知识点 面向对象 题目1（训练） 定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。 请定义出手机类，类中要有空参、有参构造方法，set/get方法。 定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。 调用对象的两个功能，打印效果如下： 正在使用价格为3998元黑色的小米手机打电话.......
Java面向对象程序设计综合练习3（填空题）
大家一起入坑
06-21 963
R4-1R4-2 BDER4-3hasNext()1 分next()1 分R4-4 21 分31 分41 分11 分31 分R4-5给出以下代码： 程序运行结果为（一行一空）：4 PLUS 2 = 62 分4 MINUS 2 = 22 分4 TIMES 2 = 82 分4 DIVIDE 2 = 22 分R4-6集合按照存储结构的不同可分为单列集合和双列集合，单列集合的根接口是（ ），双列集合的根接口是（ ）。Collection1 分Map1 分R4-7请写出以下程序运行结果： OK2 分f
Java面向对象基础练习题（含答案超详细）
热门推荐
weixin_49199821的博客
12-13 1万+
第1题 案例： 声明一个日期类MyDate，包含属性：年、月、日 声明一个Test02测试类，并在main方法中，创建3个日期对象，一个是你的出生日期，一个是我们开班 的日期，一个是今年过年的日期，并打印显示 系统预定义的日期类型。jdk1.8+提供了2套日期类型 java.util.Date public class Date implements java.io.Serializable,Cloneable, Comparable<Date>{ private...
Java学习----面向对象习题练习
hanxuya的博客
07-22 1178
猜数字游戏，计算圆的面积和周长，输入半径值，请定义一个交通工具Vehicle的类，定义一个类Calculate1，实现加、减两种运算，然后编写一个派生类Calculate2，实现乘除两种算法。
JAVA面向对象练习题
09-29
JAVA面向对象练习题可以包括以下几个方面的内容： 1. 类和对象的创建和使用：包括定义类、创建对象、调用对象的方法、访问对象的属性等。 2. 封装和继承：包括定义类的成员变量和方法的访问修饰符、继承父类的属性和方法等。 3. 多态和接口：包括定义接口、实现接口、使用多态进行方法的重写和重载等。 4. 异常处理：包括定义异常类、捕获和处理异常、使用try-catch语句等。 5. 集合框架：包括使用ArrayList、HashSet等集合类进行元素的添加、删除、查找等操作。 6. 文件操作：包括读取和写入文件、创建文件、文件的复制和删除等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值