精华内容
下载资源
问答
  • java面向对象练习题
    2021-02-26 19:06:54

    java面向对象练习题及答案

    精品文档2016全新精品资料-全新公文范文-全程指导写作 –独家原创 PAGE21 / NUMPAGES21 java面向对象练习题及答案 请定义一个交通工具的类,其中有: 属性:速度,体积等等 方法:移动),设置速度),加速speedUp,减速speedDown等等. 最后在测试类Vehicle中的main中实例化一个交通工具对象,并通过方法给它初始化speed,size的值,并且通过打印出来。另外,调用加速,减速的方法对速度进行改变。 public class Vehicle { private double speed; private double size; public Vehicle{} public Vehicle{ this.speed=speed; this.size=size; } public void setSpeed{ this.speed=speed; } public double getSpeed{ return speed; } public void setSize{ this.size=size; } public double getSize{ return size; } public double speedUp{ return ; } public double speedDown{ return ; } public static void main { Vehicle h=new Vehicle; System.out.println); System.out.println); System.out.println); System.out.println); } 练习题】构造方法 编写Java程序,模拟简单的计算器。 定义名为Number的类,其中有两个整型数据成员n1和n2,应声明为私有。编写构造方法,赋予n1和n2初始值,再为该类定义加、减、乘、除等公有成员方法,分别对两个成员变量执行加、减、乘、除的运算。 在main方法中创建Number类的对象,调用各个方法,并显示计算结果。 public class Numbei { public static void main { private double n1; private double n2; public Numbei{} public Numbei{} public double addition{} public double subtration{ } public double multiplication{ } public double division{ } return; return; return; return ; this.n1=n1; this.n2=n2; } } System.out.println); System.out.println); System.out.println); System.out.println); 构造方法: 编写Java程序,用于显示人的姓名和年龄。 定义一个人类,该类中应该有两个私有属性,姓名和年龄。定义构造方法,用来初始化数据成员。再定义显示方法,将姓名和年龄打印出来。 在main方法中创建人类的实例,然后将信息显示。 public class Person { private static String name; private static int age; public Person{} public Person{} public void setName{ } public String getName{ } public void setAge{ } public int getAge{ } public String disply{ return name; return age; this.age=age; return name; =name; this.age=age; =name; public int disp

    更多相关内容
  • 适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
  • 绝对经典
  • java
  • Java面向对象编程练习题答案

    热门讨论 2014-03-26 09:30:49
    关于Java面向对象的编程练习题以及答案解析。
  • 刚开始学,需要简单题目加深对概念的理解
  • Java面向对象试题

    万次阅读 多人点赞 2019-03-19 15:58:05
    1、 请创建一个Animal动物类,要求有方法eat()方法,方法输出一条语句“吃东西”。...在Test类中向上转型创建b对象,调用eat方法。然后向下转型调用eat()方 法、fly()方法。 评分标准: 正确写出Ani...

    目录

    一、第一题

    请创建一个Animal动物类,要求有方法eat()方法,方法输出一条语句“吃东西”。 创建一个接口A,接口里有一个抽象方法fly()。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”,重写eat()方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象,调用eat方法。然后向下转型调用eat()方 法、fly()方法。

    评分标准:
    正确写出Animal类10分
    正确定义接口A 10分
    Bird类继承Animal类实现接口A 10分
    向上转型创建对象b调用eat()方法正确输出 10分
    向下转型调用eat()方法、fly()方法正确输出 10分。
    

    答案:

    Animal.java
    image.png
    A.java
    image.png
    Bird.java
    image.png
    Bird.java
    image.png


    二、第二题

    编写一个Person抽象类,要求含有姓名(name)年龄(age)两个私有属性以及吃饭(eat) 和睡觉(sleep)两个抽象方法,并写出带参构造方法,创建学生(student)和工人(worker) 两个类,继承Person类,学生类多出了私有属性学号和学习方法(输出我爱学习),工 人类多出了私有属性工号和工作方法(输出我爱工作),在主函数中创建学生和工人类 的实例对象,使用构造方法赋值,并输出所有属性和方法(共50分,能够定义类5分, 正确书写子父类构造方法1分,set get写对10分,方法重写10分,正确创建对象10 分,能运行5分)

    显示结果如下:
    姓名:李四,年龄:18,学号:1024
    食堂吃饭
    我爱学习
    姓名:张三,年龄:20,工号:1025
    自己做饭
    在家躺着睡觉
    我爱工作

    Person.java
    image.png
    Student.java
    image.png
    image.png
    Worker.java
    image.png
    Mains.java
    image.png

    三、第三题

    利用继承,来描述,人,老师,学生之间的关系
    1)老师含有属性:name,age,subject,含有方法:eat,teach,toString
    2)学生含有属性:name,age,class,含有方法:eat,study,toString
    3)利用继承的思想,从老师和学生中抽象出人,并创建Test进行调用并输出(System.out)

    判分标准:
    1)创建类Person,含有公有属性:name姓名,age年龄。含有方法void eat(String something);方法中打印输出“我爱吃XXX”。含有构造方法,带两个参数,分别是name和age,并利用this关键字传值到成员变量中 	。(10分)
    2)创建类Student,含有属性:class班级,含有方法,void study(String subject);方法打印输出:我热爱学习subject。创建包含三个参数的构造方法,分别是name,age,class,利用super实现父类构造方法传值。重写toString方法,打印输出:我的名字是XX,我的年龄是XX,我的班级是XX(10分)
    3)创建类Teacher,含有属性:subject,含有方法,void teach();方法打印输出:我教授的是subject。创建包含三个参数的构造方法,分别是name,age,subject,利用super实现父类构造方法传值。重写toString方法,打印输出:我的名字是XX,我的年龄是XX(10分)
    4)创建Test测试类,创建Student对象,并调用带3个参数的构造方法,自己赋值,然后依次调用study方法,eat方法,toString方法(20分)
    5)创建Teacher对象,并调用带3个参数的构造方法,自己赋值,然后依次调用teach方法,eat方法,toString方法(10分)
    

    Person.java
    image.png
    image.png
    Student.java

    image.png
    Teacher.java

    image.png
    Test.java
    image.png

    四、第四题

    需求:首先定义一个抽象类Animal,抽象类中定义一个抽象方法play()抽象方法,创建 一个猫Cat类,继承Animal并重写play方法输出“我是猫,我玩老鼠”,创建一个狗类, 继承Animal并重写play方法输出“我是狗,我玩球”。最后编写测试类TestDemo,通 过多态创建猫,通过多态创建狗,并调用猫对象的play方,狗对象的play方法

    效果如图:
    	我是猫,我玩老鼠		
    	我是狗,我玩球
    评分标准
    1)创建Animal抽象类,并定义抽象方法play.(10)
    2)创建Dog类继承Animal类,重写play方法。(10)
    3)创建Cat类继承Animal类,重写play方法。(10)
    4)编写测试类,通过多态创建猫对象,狗对象(15)
    

    Animal.java
    image.png
    Cat.java
    image.png
    Dog.java
    image.png
    Test.java
    image.png

    五、第五题

    请创建一个Car抽象类,要求有brand(品牌)属性,并且要求封装私有化,写出属性的 set、get方法。抽象类Car构造方法中也可以对brand属性赋值,写出一个抽象方法run ()。创建一个跑车类SportsCar继承抽象类Car。实现Car抽象方法输出一条语句“超 级跑车”,在本类中写出一个自己的方法price(),输出一条语句“售价100w”。在测 试类Test类中创建跑车对象car1,用构造器赋值品牌属性,输出属性,调用run()、 price()方法。创建跑车car2,用set方法赋值属性,输出属性,调用run()、price ()方法。

    评分标准:
    1)正确写出抽象类Car ,封装属性,写出抽象方法10分
    2)封装属性,写出set、get、抽象方法 10分
    3)正确继承Car类写出SportsCar类和并实现run() 方法。10分
    4)创建car1、car2对象并调用方法10分
    5)成功正确输出 10分
    显示结果如下:
    	法拉利
    	超级跑车
    	售价100w
    	兰博基尼
    	超级跑车
    	售价100w
    

    Car.java
    image.png
    SportsCar.java
    image.png
    Test.java
    image.png

    六、第六题

    完成那个USB接口的例子,分别定义USB接口,两个方法start,stop。两个子类:Flash和Print,重写两个方法,方法中随便输出两句话。定义计算机类Computer,有一个plugin方法,有一个USB类型的参数,用来调用start和stop。在主方法中实例化Computer类,调用plugin方法,分别传递Flash和Print的对象,通过向上转型,完成功能。

    注意:因为从键盘输入我们还没有学习,所以上面若提到使用键盘输入,改为在程序中随意定义几个值(如果会键盘输入那就使用键盘输入)

    USB.java
    image.png
    Print.java
    image.png
    Flash.java
    image.png
    Computer.java
    image.png
    Mains.java
    image.png

    七、第七题

    (1)请创建一个Car抽象类,要求有brand(品牌)属性,并且要求封装私有化,写出属性的 set、get方法。抽象类Car构造方法中对brand属性赋值,写出一个抽象方法run()。(2)创建一个跑车类SportsCar继承抽象类Car。实现Car抽象方法输出一条语句“超级跑车”,在本类中写出一个自己的方法price(),输出一条语句“售价100w”。(10分)
    (3)定义测试类Test类,并创建跑车对象car1,用构造器赋值品牌属性,使用setter方法输出属性值,再调用run()、 price()方法。 (10分)
    (4)创建跑车car2,向上转型到Car,使用setter方法为brand赋值属性
    ,输出属性值,调用run()方法。(10分)

    Car.java

    package kaoshi_1;
    
    public abstract class Car {
    	private String brand;
    
    	public String getBrand() {
    		return brand;
    	}
    
    	public void setBrand(String brand) {
    		this.brand = brand;
    	}
    	
    	public Car(String brand) {
    		this.brand=brand;
    	}
    	
    	public Car() {
    		
    	}
    	public abstract void run();
    }
    
    

    SportCar.java

    package kaoshi_1;
    
    public class SportCar extends Car {
    
    	public void run() {
    		System.out.println("超级跑车");
    	}
    	public SportCar(String brand) {
    		super(brand);
    	}
    	public void price() {
    		System.out.println("售价100w");
    	}
    	public SportCar() {
    		
    	}
    }
    
    

    Test.java

    package kaoshi_1;
    
    public class Test {
    	public static void main(String[] args) {
    		SportCar car1 = new SportCar("奥迪A6");
    		System.out.println(car1.getBrand());
    		car1.run();
    		car1.price();
    		
    		Car car2 = new SportCar();
    		car2.setBrand("玛莎拉蒂");
    		System.out.println(car2.getBrand());
    		car2.run();
    	}
    }
    
    

    image.png

    八、第八题

    (1)定义一个Flower花作为父类
    属性:颜色 价格
    属性要进行封装(即为每条私有属性写set,get方法)
    定义无参构造方法,和传两个参数的有参构造方法一个。
    方法:显示详细信息的方法showInfo (15分)
    (2)定义一个Rose玫瑰花类继承Flower类
    玫瑰花自己的属性:产地(要求对产地属性进行封装 私有化属性)
    重写父类中的显示详细信息的方法showInfo,在重写的showInfo方法中通过super调用父类的showInfo方法;并显示产地信息。
    再定义一个方法warn警告显示:不要摘玫瑰花,小心扎手! (15分)
    (3)定义测试类Test完成:(10分)
    ①实例化Flower类,调用构造方法赋值,并调用方法,输出:
    花的颜色是白色,价格是10元
    ②实例化玫瑰花类,调用方法,输出:
    花的颜色是紫色,价格是30元
    产地是大理
    不要摘玫瑰花,小心扎手!

    Flower.java

    package kaoshi_1;
    
    public class Flower {
    	private String color;
    	private String price;
    	public String getColor() {
    		return color;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	public String getPrice() {
    		return price;
    	}
    	public void setPrice(String price) {
    		this.price = price;
    	}
    	public Flower() {
    		
    	}
    	public Flower(String color,String price) {
    		this.color=color;
    		this.price=price;
    	}
    	public void showInfo() {
    		System.out.println("花的颜色是"+this.color+",价格是"+this.price+"元");
    	}
    }
    
    

    Rose.java

    package kaoshi_1;
    
    public class Rose extends Flower {
    	private String address;
    	
    	public String getAddress() {
    		return address;
    	}
    	public void setAddress(String address) {
    		this.address = address;
    	}
    	public void showInfo() {
    		super.showInfo();
    		System.out.println("产地是"+this.address);
    	}
    	public void warn() {
    		System.out.println("不要摘玫瑰花,小心扎手!");
    	}
    	public Rose() {
    		
    	}
    	public Rose(String color,String price,String address) {
    		super(color,price);
    		this.address=address;
    	}
    }
    
    

    Test2.java

    package kaoshi_1;
    
    public class Test2 {
    	public static void main(String[] args) {
    		Flower f=new Flower("白色","10");
    		f.showInfo();
    		
    		Rose r=new Rose("紫色","30","大理");
    		r.showInfo();
    		r.warn();
    	}
    }
    
    

    image.png

    九、第九题

    (1)首先定义一个程序员的接口Programmer,接口中定义一个抽象方法ACode(); (10分)
    (2)创建一个Student类,实现接口Programmer并实现ACode()方法,ACode()方法可输出输出“程序员在敲代码”, Student类有年龄,姓名,班级,性别私有属性(封装),各个属性的set,get方法,写空参构造方法,和一个有参构造方法包含这四个属性。 (10分)
    (3)定义测试类,在main方法中创建一个Student对象,将自己的年龄,姓名,班级,性别,赋值给这个对象,并在控制台打印出对象的各个属性。调用所有的方法。(10分)

    效果如图:

    程序员在敲代码
      姓名:孙悟空  性别:女  年龄:19  班级:三年级二班 
    

    Programmer.java

    package kaoshi_1;
    
    public interface Programmer {
    	public abstract void ACode();
    }
    
    

    Student.java

    package kaoshi_1;
    
    public class Student implements Programmer {
    	private int age;
    	private String name;
    	private String clas;
    	private String sex;
    	public void ACode() {
    		System.out.println("程序员在敲代码");
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getClas() {
    		return clas;
    	}
    	public void setClas(String clas) {
    		this.clas = clas;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public Student() {
    		
    	}
    	public Student(int age,String name,String clas,String sex) {
    		this.age=age;
    		this.name=name;
    		this.clas=clas;
    		this.sex=sex;
    	}
    }
    
    

    Test3.java

    package kaoshi_1;
    
    public class Test3 {
    
    	public static void main(String[] args) {
    		Student s=new Student(19,"孙悟空","三年级二班","女");
    		s.ACode();
    		System.out.println("姓名:"+s.getName()+",性别"+s.getSex()+",年龄:"+s.getAge()+",班级:"+s.getClas());
    	}
    }
    

    image.png

    展开全文
  • 第1 案例: 声明一个日期类MyDate,包含属性:年、月、日 声明一个Test02测试类,并在main方法中,创建3个日期对象,一个是你的出生日期,一个是我们开班 的日期,一个是今年过年的日期,并打印显示 系统预...

    第1题

    案例:

    声明一个日期类MyDate,包含属性:年、月、日

    声明一个Test02测试类,并在main方法中,创建3个日期对象,一个是你的出生日期,一个是随机定义的日期,一个是今年过年的日期,并打印显示

    系统预定义的日期类型。jdk1.8+提供了2套日期类型

    java.util.Date
    
    public class Date implements java.io.Serializable,Cloneable,
    Comparable<Date>{
        private transient long fastTime;  //具体的日期是采用从1970-1-1 0:0:0 到指定日期的毫秒值进行存储。  年-1900  月-1
    }

    自定义类

    public class MyDate{  //默认继承于java.lang.Object类,不需要import语句导入。
        int year;   //成员属性  范围限定词默认为package,只是同包可见
        int month;
        int date;
        public void setYear(int year){  //方法名称命名的规则为小写字母开头,大写字母分词
            this.year = year;  
        }
        public String toString(){
            return year + "年" + month + "月" + date + "日";
        }
    }

    测试类

    public class Test02{
        public static void main(String[] args){
            MyDate d1 = new MyDate();
            d1.year = 1972;
            d1.month = 4;
            d1.date = 30;
            System.out.println(d1.toString());
        }
    }

    第2题

    案例:

    声明公民类Citizen,包含属性:姓名,生日,身份证号,其中姓名是String类型,生日是MyDate类型,身份证号也是String类型。

    声明Test03测试类,在main方法中创建你们家庭成员的几个对象,并打印信息。

    public class Citizen{
        protected String name;
        public MyDate birth;
        private String ID;
    ​    
        //私有属性添加get/set方法访问
        public String getID() {
            return ID;
        }
    ​
        public void setID(String iD) {
            ID = iD;
        }
    ​
        public String toString() {
            return "家庭成员 " + "姓名:" + name + " 出生日期:" + birth + " 身份证号:" + this.ID;
        }
    }

    测试类

    public class Test03 {
        public static void main(String[] args) {
            Citizen citizen  = new Citizen();
            citizen.name = "张三";
            MyDate mydate = new MyDate();
            mydate .setYear(2021);
            mydate .setMonth(03);
            mydate .setDate(06);
            citizen.birth = d1;
            citizen.setID("123456789");
            System.out.println(citizen.toString());
        }
    ​
    }

    第3题

    案例:

    声明一个日期类MyDate,包含属性:年、月、日,并在MyDate类中声明几个方法:

    1、boolean isLeapYear():判断当前日期的是闰年吗?

    2、void set(int y, int m, int d):修改年,月,日为新日期

    3、void puls(int years, int months, int days):加上years年,months月,days天后的日期

    并在测试类Test04的main方法中创建对象,并调用测试

    public class MyDate{
        private int year;
        private int month;
        private int date;
        
        //判断当前日期是否是闰年
        public boolean isLeapYear(){
            if(year % 4 == 0 && year / 100 !=0)
                return ture;
            else if(year % 400 == 0)
                return true;
            else
                return false;
        }
        
        //修改年,月,日为新日期
        public void set(int y,int m, int d){
            year = y;
            month = m;
            date = d;  
        }
        //加上years年,months月,days天后的日期
        public void puls(int years, int months, int days){
            this.year += years;
            this.date += days;
            this.month += months;
            if (this.month > 12) {
                this.year++;
                this.month -= 12;
            }
            //这里得判断加完的月份值是否超过12,天数是否超过本月的天数
            //如果超过则月份和天数做出相应的变化
            //2月有闰年的存在  所以需要单独进行判断
            //特殊12月  如果超出则需要对年进行修稿
            while (true) {
                if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10) {
                    if (date > 31) {
                        date -= 31;
                        month++;
                    } else
                        break;
                } else if (month == 4 || month == 6 || month == 9 || month == 11) {
                    if (date > 30) {
                        date -= 30;
                        month++;
                    } else
                        break;
                } else if (month == 2) {
                    //调用当前类中的方法  判断是否是闰年
                    if (isLeapYear()) {
                        if (date > 28) {
                            date -= 28;
                            month++;
    ​
                        } else
                            break;
                    } else if (date > 29) {
                        date -= 29;
                        month++;
                    } else
                        break;
                } else if (month == 12) {
                    if (date > 31) {
                        date -= 31;
                        month = 1;
                        year++;
                    }
                }
            }
        }
    }

    测试类

    public class Test04 {
    	public static void main(String[] args) {
    		MyDate date = new MyDate();
             //调用方法 修改年,月,日为新日期
    		date.set(2001, 3, 6);
    		System.out.println(date);
             // 判断是否为闰年
             System.out.println(date.isLeapYear());
    		//加上years年,months月,days天后的日期
             date.puls(20, 9, 3);
    		System.out.println(date);
    	}
    
    }

    第4题

    案例:

    声明一个三角形类Triangle,包含属性:a,b,c,表示三条边,包含几个方法:

    1、boolean isRightTriangle():判断是否是一个直角三角形

    2、boolean isIsoscelesTriangle():判断是否是一个等腰三角形

    3、boolean isEquilateralTriangle():判断是否是一个等边三角形

    4、double getArea():根据三条边,用海伦公式求面积

    5、double getLength():求周长

    并在测试类Test05的main方法中调用测试

    public class Triangle {
        private double a;
        private double b;
        private double c;
    ​
        // 判断是否为直角三角形
        public boolean isRightTriangle() {
            // 首先判断值的合法性
            if (a > 0 && b > 0 && c > 0) {
                // 判断是否构成三角形
                if (a + b > c && a + c > b && b + c > a) {
                    // 判断是否为直角三角形
                    if (a * a == b * b + c * c || b * b == a * a + c * c || c * c == a * a + b * b) {
                        return true;
                    }
                }
            }
            return false;
        }
    ​
        // 判断是否为等腰三角形
        public boolean islsoscelesTriangle() {
            // 判断值的合法性
            if (a > 0 && b > 0 && c > 0) {
                // 判断是否能构成三角形
                if (a + b > c && a + c > b && b + c > a) {
                    // 判断是否为等腰三角形
                    if (a == b || b == c || a == c) {
                        return true;
                    }
                }
            }
            return false;
    ​
        }
        
        //判断是否为等边三角形
        public boolean isEquilateralTriangle() {
            // 判断值的合法性
            if (a > 0 && b > 0 && c > 0) {
                // 判断是否能构成三角形
                if (a + b > c && a + c > b && b + c > a) {
                    // 判断是否为等边三角形
                    if (a == b && b == c) {
                        return true;
                    }
                }
            }
            return false;
        }
        
        //计算三角形的周长
        public double getLength() {
            // 判断值的合法性
            if (a > 0 && b > 0 && c > 0) {
                // 判断是否能构成三角形
                if (a + b > c && a + c > b && b + c > a) {
                    return (a + b + c);
                }
            }
            return -1;
        }
        
        //计算三角形的面积(利用海伦公式)
        public double getArea() {
            // 判断值的合法性
            if (a > 0 && b > 0 && c > 0) {
                // 判断是否能构成三角形
                if (a + b > c && a + c > b && b + c > a) {
                    double p = (a + b + c) / 2;
                    double q = (p * (p - a) * (p - b) * (p - c));
                    return Math.sqrt(q);
                }
            }
            return -1;
        }
        
        //私有类外访问  添加get/set方法
        public double getA() {
            return a;
        }
    ​
        public void setA(double a) {
            this.a = a;
        }
    ​
        public double getB() {
            return b;
        }
    ​
        public void setB(double b) {
            this.b = b;
        }
    ​
        public double getC() {
            return c;
        }
    ​
        public void setC(double c) {
            this.c = c;
        }
    ​
    }

    测试类

    public class Test05 {
        public static void main(String[] args) {
            Triangle triangle  = new Triangle();  //调用无参构造器
             // 私有属性通过set方法修改值  get方法获取
            triangle.setA(3.); 
            triangle.setB(4.);
            triangle.setC(5.);
             //通过对象名.方法名调用方法
            System.out.println("是否为等边三角形:"+triangle.isEquilateralTriangle());
            System.out.println("是否为等腰三角形:"+triangle.islsoscelesTriangle());
            System.out.println("是否为直角三角形:"+triangle.isRightTriangle());
            System.out.println("面积为:"+triangle.getArea());
            System.out.println("周长为:"+triangle.getLength());
        }
    ​
    }

    第5题

    工具类的概念和static方法

    定义对象的目标是为了封装数据和数据相关操作,同一个类属的对象相互堵路

    public class A{
     public void pp(){}
    }
    /*  在测试类中
     *  正常调用方法pp: new A().pp();
     *  不能  A.pp();
     *  在类A内部可以直接调用
     */
    public class A{
        public void pp() {}
        public void cc() {
            pp();   //允许方法之间相互调用
        }
    }
    ​

    工具类中只有操作,没有数据的封装,则可以定义访问为static静态的。静态方法不需要创建对象在进行调用

    public class A{
        public static void pp(){}
    }
    /*
     * 在测试类中
     * 通过 A.pp()进行调用  也可以使用new A().pp();  但是不建议
     */

    案例:

    声明一个数学计算工具类MathTools,包含如下方法:

    1、int add(int a, int b):求a+b

    2、int subtract(int a,int b):求a-b

    3、int mutiply(int a, int b):求a*b

    4、int divide(int a, int b):求a/b

    5、int remainder(int a, int b):求a%b

    6、int max(int a, int b):求a和b中的最大值

    7、int min(int a, int b):求a和b中的最小值

    8、boolean equals(int a, int b):判断a和b是否相等

    9、boolean isEven(int a):判断a是否是偶数

    10、boolean isPrimeNumer(int a):判断a是否是素数

    11、int round(double d):返回d的四舍五入后的整数值

    public class MathTools {
        // 如果没有定义构造器 系统默认提供无参构造器
        // 如果自定义构造器 那么应该提供无参构造器(建议做法)
        public MathTools() {
        }
    ​
        // a+b
        public static int add(int a, int b) {
            int c = a + b;
            return c;
        }
    ​
        // a-b
        public static int subtract(int a, int b) {
            int c = a - b;
            return c;
        }
    ​
        // a*b
        public static int mutiply(int a, int b) {
            int c = a * b;
            return c;
        }
    ​
        // a%b
        public static int remainder(int a, int b) {
            int c = a % b;
            return c;
        }
    ​
        // a和b中的最大值
        public static int Max(int a, int b) {
            int c = Math.max(a, b);
            return c;
        }
    ​
        // a和b中的最小值
        public static int Min(int a, int b) {
            int c = Math.min(a, b);
            return c;
        }
    ​
        // 判断a和b是否相等
        public static boolean equals(int a, int b) {
            if (a == b) {
                return true;
            }
            return false;
        }
    ​
        // 判断a是否是偶数
        public static boolean isEven(int a) {
            if (a % 2 == 0) {
                return true;
            }
            return false;
        }
    ​
        // 返回四舍五入后的整数值
        public static int round(double a) {
            // 传入的参数为double类型 所以需要进行窄化操作
            int c = (int) Math.round(a);
            return c;
        }
    ​
        // a/b
        public static int Divide(int a, int b) {
            int c = a / b;
            return c;
        }
    ​
        // 判断a是否是素数
        public boolean isPrimeNumber(int a) {
            int count = 0;
            for (int i = 2; i < a; i++) {
                if (a % i == 0) {
                    count++;
                    break;
                }
            }
            if (count == 0)
                return true;
            else
                return false;
        }
    }
     
    

    声明一个Test06测试类,并在main方法中调用测试

    public class Test06 {
        public static void main(String[] args) {
            new MathTools();
            // 调用方法 判断是否为素数
            boolean res = MathTools.isPrimeNumber(13);
            System.out.println(res);
            // 两数和
            int sum = MathTools.add(2, 3);
            System.out.println(sum);
            // 四舍五入
            int digital = MathTools.round(18.2);
            System.out.println(digital);
        }
    }

    第6题

    案例:练习排序算法和折半查找法以及System.arrayCopy方法

    声明一个数组管理工具类MyArrays,包含如下方法:

    1、void sort(int[] arr):可以为任意一维整型数组arr实现从小到大排序

    2、int indexOf(int[] arr, int value):可以在任意一维整型数组arr中查找value值的下标,如果不存在返回-1

    3、int[] copy(int[] arr, int len):可以实现从任意一维数组arr中复制一个新数组返回,新数组的长度为len,从arr[0]开始复制

    import java.util.Arrays;
    ​
    public class MyArrays {
        // 定义方法 利用冒泡排序对数组进行排序(自然排序)
        public static void sort(int[] arr) {
            for (int i = 1; i < arr.length; i++) {
                for (int k = 0; k < arr.length - i; k++) {
                    if (arr[k] > arr[k + 1]) {
                        int temp = arr[k + 1];
                        arr[k + 1] = arr[k];
                        arr[k] = temp;
                    }
                }
            }
        }
    ​
        // 在任意一维整型数组arr中查找value值的下标,如果不存在返回-1
        public static int indexOf(int[] arr, int value) {
            sort(arr); // 折半查找的前提是有序的  所以调用冒泡排序对数组进行排序
            return binarySearch(arr, value, 0, arr.length - 1);//利用折半查找的方法寻找value值的下标
        }
    ​
        // 折半查找
        public static int binarySearch(int[] arr, int target, int begin, int end) {
            if (begin > end)
                return -1;
            int mid = (begin + end) / 2;
            if (arr[mid] < target) {
                begin = mid + 1;
            } else if (arr[mid] > target) {
                end = mid - 1;
            } else
                return mid;
            return binarySearch(arr, target, begin, end); // 调用自身
        }
    ​
        // 实现从任意一维数组arr中复制一个新数组返回,新数组的长度为len,从arr[0]开始复制
        public static int[] copy(int[] arr, int len) {
            int[] res = new int[len];
            int newLen = Math.min(len, arr.length);
            System.arraycopy(arr, 0, res, 0, newLen);
            return res;
        }
    ​
        // 输出数组
        public static void showArray(int[] arr) {
            System.out.println(Arrays.toString(arr));
        }
    }

    声明一个Test07测试类,并在main方法中调用测试

    import java.util.Arrays;
    import java.util.Random;
    ​
    public class Test07 {
    ​
        public static void main(String[] args) {
            Random random = new Random();
            // 生成[10,20)以内的随机数(int类型)
            int[] arr = new int[random.nextInt(10) + 10];
            // 生成随机数组
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int) (Math.random() * 100);
            }
            new MyArrays();
            // 调用静态方法 冒泡排序
            MyArrays.sort(arr);
            // 调用方法输出数组
            MyArrays.showArray(arr);
            int[] arr1 = new int[] { 6, 2, 1, 3, 8, 4, 56, 7, 9 };
            // 调用方法 寻找value=56的下标
            int temp = MyArrays.indexOf(arr1, 56);
            System.out.println("数组中56的下标为:" + temp);
            // 实现数组的复制
            int[] res = MyArrays.copy(arr, 10);
            System.out.println("复制后的数组为:" + Arrays.toString(res));
        }
    ​
    }

    第7题

    案例:

    声明一个常识工具类DateCommonsTools,包含如下方法:

    1、String getWeekName(int week):根据星期值,返回对应的英语单词

    2、String getMonthName(int month):根据月份值,返回对应的英语单词

    3、int getTotalDaysOfMonth(int year, int month):返回某月的总天数

    4、int getTotalDaysOfYear(int year):获取某年的总天数

    5、boolean isLeapYear(int year):判断某年是否是闰年

    public class DateCommonsTools {
    //根据星期值,返回对应的英语单词
        public String getWeekName(int week) {
    ​
            String[] arr = new String[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Staurday", "Sunday" };
            if (week < 7 && week > 0)
                return arr[week];
            else
                return "输入有误!";
        }
    ​
    //根据月份值,返回对应的英语单词
        public String getMonthName(int month) {
            String[] arr = new String[] { "January", "February", "March", "April", "May", "June", "July", "Auguet",
                    "September", "October", "November", "December" };
            if (month > 0 && month < 13)
                return arr[month];
            else
                return "";
        }
    ​
    //返回某年某月的总天数
        public int getTotalDaysOfMonth(int year, int month) {
            int res = 0;
            if (month > 0 && month < 32) {
                switch (month) {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    res = 31;
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    res = 30;
                    break;
                case 2:
                    if (isLeapYear(year))
                        res = 28;
                    else
                        res = 29;
                    break;
                default:
                    System.out.println("输入有误!");
                }
            }
            return res;
        }
    ​
    //获取某年的总天数
        public int getTotalDaysOfYear(int year) {
            if (isLeapYear(year))
                return 366;
            else
                return 356;
        }
    ​
    //判断是否为闰年
        private static boolean isLeapYear(int year) {
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
                return true;
            else
                return false;
    ​
        }
    }

    声明一个Test08测试类,并在main方法中调用测试

    public class Test08 {
        public static void main(String[] args) {
            new DateCommonsTools();
            String WeekName = DateCommonsTools.getWeekName(2);
            System.out.println(WeekName);
            String MonthName = DateCommonsTools.getMonthName(10);
            System.out.println(MonthName);
            int MonthNum = DateCommonsTools.getTotalDaysOfMonth(2020, 2);
            System.out.println(MonthNum);
            int YearNum = DateCommonsTools.getTotalDaysOfYear(2020);
            System.out.println(YearNum);
        }
    ​
    }

    展开全文
  • java面向对象测试含答案
  • Java面向对象试题.pdf

    2021-08-28 20:17:42
    Java面向对象试题
  • Java面向对象练习题

    千次阅读 多人点赞 2019-08-29 11:10:22
    学了面向对象,我们来做几道基础 // 1、定义一个点类Point,包含2个成员变量x、y分别表示x和y坐标,2个 // 构造器Point()和Point(int x0,y0),以及一个movePoint // (int dx,int dy)方法实现点的位置移动,创建两...

    学了面向对象,我们来做几道基础题

    面向对象基础

    1、定义一个点类Point,包含2个成员变量x、y分别表示x和y坐标,2个构造器Point()和Point(int x0,y0),以及一个movePoint(int dx,int dy)方法实现点的位置移动,创建两个Point对象p1、p2,分别调用movePoint方法后,打印p1和p2的坐标。

    代码演示

    public class Point {
    	
    	//成员变量
    	private double x;
    	private double y;
    	
    	//每一个类都带有一个默认的无参构造函数
    	public Point() {
    		super(); //表示父类的构造函数
    		
    		/*
    		 * 	1.构造函数与类名完全一致
    		 * 	2.不能带有返回值类型
    		 * 	3.不需要return语句
    		 * 
    		 * 	作用:创建对象
    		 */
    	}
    	public Point(int x0,int y0) {
    		this.x=x0;
    		this.y=y0;
    	}
    	
    	public void movePoint(int dx,int dy) {
    		this.x+=dx;
    		this.y+=dy;
    	}
    	
    	public static void main(String[] args) {
    		Point p1 = new Point (2,4);
    		p1.movePoint(2, 4);
    		System.out.println("p1坐标为:"+p1.x+","+p1.y);
    		
    		Point p2 = new Point (5,8);
    		p2.movePoint(50, 120);
    		System.out.println("p2坐标为:"+p2.x+","+p2.y);
    	}
    

    2、定义一个矩形类Rectangle:
    2.1 定义三个方法:getArea()求面积、getPer()求周长,showAll()分别在控制台输出长、宽、面积、周长。
    2.2 有2个属性:长length、宽width
    2.3 通过构造方法Rectangle(int width, int length),分别给两个属性赋值
    2.4 创建一个Rectangle对象,并输出相关信息

    代码演示

    public class Rectangle {
    	
    	int length;
    	int width;
    	
    	
    	/*
    	 * 	static
    	 * 	1.修饰变量:直接通过类名来访问
    	 * 	2.修饰方法:也可以通过类名来访问
    	 * 	3.修饰代码块:加载类的时候优先执行,并只执行一次
    	 * 
    	 * 	非静态方法可以访问静态方法和变量
    	 * 	静态方法不可以访问非静态方法和变量
    	 */
    	
    	public int getArea() {
    		int area=length*width;
    		return area;
    	}
    	
    	public int getPer() {
    		return (length+width)*2;
    	}
    	
    	public void showAll() {
    		int l=this.length;
    		int w=this.width;
    		int a=length*width;
    		int p=(length+width)*2;
    		System.out.println("长:"+l+","+"宽:"+w+","+"面积:"+a+","+"周长:"+p);
    	}
    	
    	public Rectangle (int length,int width) {
    		this.length=length;
    		this.width=width;
    	}
    	
    	public static void main(String[] args) {
    		Rectangle r=new Rectangle(5,5);
    		r.showAll();
    	}
    

    设计一个类Student,该类包括姓名、学号和成绩。设计一个方法,按照成绩从高到低的顺序输出姓名、学号和成绩信息。

    代码演示

    public class Student {
    
    	String name;
    	int empno;
    	int grade;
    	
    	public Student(String name,int empno,int grade) {
    		this.name=name;
    		this.empno=empno;
    		this.grade=grade;
    	}
    	
    	public static void sort(Student[] s) {
    		for(int i=1;i<s.length;i++) {
    			for(int j=0;j<s.length-i;j++) {
    				if(s[j].grade < s[j+1].grade) {
    					Student t;
    					t=s[j];
    					s[j]=s[j+1];
    					s[j+1]=t;
    				}
    			}
    		}
    	}
    	
    	public static void main(String[] args) {
    		
    		Student s1=new Student("小明", 1, 80);
    		Student s2=new Student("小红", 2, 90);
    		Student s3=new Student("小王", 3, 99);
    		
    		Student[] arr = {s1,s2,s3};
    		
    		sort(arr);
    		
    		for(Student is:arr) {
    			System.out.println(is.name+"\t"+is.empno+"\t"+is.grade);
    		}
    		
    	}
    

    在这里插入图片描述

    面向对象高级特性

    1、创建一个球员类,并且该类最多只允许创建十一个对象。提示利
    用static 和封装性来完成。

    类的说明:
    在这里插入图片描述
    代码演示:

    
    public class Players {
    	private static int sum;
    	
    	public Players() {
    		super();
    		System.out.println("创建了一个对象!");
    	}
    
    	public static Players create() {
    		Players players=null;
    		if(sum>=11) {
    			System.out.println("创建的对象以超过11个!");
    		}else {
    			players=new Players();
    			sum++;
    		}
    		return players;
    	}
    	
    	public static void main(String[] args) {
    		Players[] players=new Players[11];
    		for(int i=0;;i++) {
    			Players p=Players.create();
    			if(p==null) {
    				break;
    			}else {
    				players[i]=p;
    			}
    		}
    		
    	}
    }
    
    

    结果:
    在这里插入图片描述

    2、设计2个类,要求如下:
    2.1 定义一个汽车类Vehicle,
    2.1.1 属性包括:汽车品牌brand(String类型)、颜色color(String类型)和速度speed(double类型)。
    2.1.2 至少提供一个有参的构造方法(要求品牌和颜色可以初始化为任意值,但速度的初始值必须为0)。
    2.1.3 为属性提供访问器方法。注意:汽车品牌一旦初始化之后不能修改。
    2.1.4 定义一个一般方法run(),用打印语句描述汽车奔跑的功能
    2.1.5 在main方法中创建一个品牌为“benz”、颜色为“black”的汽车。
    2.2 定义一个Vehicle类的子类轿车类Car,要求如下:
    2.2.1 轿车有自己的属性载人数loader(int 类型)。
    2.2.2 提供该类初始化属性的构造方法。
    2.2.3 重新定义run(),用打印语句描述轿车奔跑的功能。
    2.2.4 在main方法中创建一个品牌为“Honda”、颜色为“red”,载人数为2人的轿车。

    代码演示:

    //Vehicle 类
    public class Vehicle {
    	private String brand;
    	private String color;
    	private double speed;
    	
    	
    	
    	public String getBrand() {
    		return brand;
    	}
    //	public void setBrand(String brand) {
    //		this.brand = brand;
    //	}
    	public String getColor() {
    		return color;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	public double getSpeed() {
    		return speed;
    	}
    	public void setSpeed(double speed) {
    		this.speed = speed;
    	}
    	public Vehicle() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	public Vehicle(String brand, String color) {
    		super();
    		this.brand = brand;
    		this.color = color;
    		this.speed = 0;
    	}
    	public void run() {
    		System.out.println("汽车奔跑");
    	
    	}
    	public static void main(String[] args) {
    		Vehicle v = new Vehicle("benz", "black");
    		System.out.println("品牌:"+v.brand+"\n颜色:"+v.color+"\n速度:"+v.speed);
    		v.run();
    	}
    }
    
    
    
    //Car 类
    public class Car extends Vehicle{
    	int loader;
    
    	public Car(String brand,String color,int loader) {
    		super(brand,color);
    		this.loader=loader;
    	}
    	
    	public void run() {
    		System.out.println("品牌:"+getBrand()+"\r颜色:"+getColor()+"\r载人数:"+loader);
    		System.out.println("轿车奔跑");
    	}
    	
    	public static void main(String[] args) {
    		Car c=new Car("Honda","red",2);
    		c.run();
    	}
    }
    

    结果:
    在这里插入图片描述
    在这里插入图片描述

    更多内容,等待后续更新!

    展开全文
  • Word 资料 OOP考试 考试时间120分钟 考试总分100分 选择(不定项选择(2分/*37 = 74分) 类AB的定义如下 class A { private int a = 100; A) { System.out.print"A; System.out.println(a; } } class B extends ...
  • java面向对象试题

    2011-06-17 23:15:22
    java面向对象试题 java面向对象试题 java面向对象试题 java面向对象试题
  • JAVA面向对象基础测试-继承-封装-多态等测试.docx
  • Java-面向对象 练习题

    千次阅读 2022-01-30 11:11:11
    面向对象 题目1(训练) 定义手机类,手机有品牌(brand),价格(price)和颜色(color)三个属性,有打电话call()和sendMessage()两个功能。 请定义出手机类,类中要有空参、有参构造方法,set/get方法。 定义测试类...
  • Java面向对象试题.doc

    2022-06-11 03:14:07
    Java面向对象试题
  • java面向对象试题.pdf

    2021-09-30 17:43:12
    java面向对象试题.pdf
  • java面向对象试题.doc

    2021-09-29 19:25:38
    java面向对象试题.doc
  • 题目:实现一个宠物商店,在商店中有多种(由用户数量确定)宠物,试表示出此种关系,并要求可以根据宠物的关键字查找到相应的宠物信息。所需的宠物信息自行设计。 代码: package one; interface Pet{ ...
  • Java面向对象试题集.pdf
  • Java面向对象编程练习题答案0.pdf
  • Java 面向对象练习题之斗地主游戏

    千次阅读 2022-03-30 20:44:40
    题目: 参考斗地主的游戏规则,完成一个发牌的功能(54张牌,...import java.util.*; /** * 斗地主 */ public class Game { //需要有一个属性.或者说是一个变量来存储54张牌 private HashMap<Integer,Str.
  • Java面向对象基础编程练习题

    千次阅读 2021-09-11 18:07:13
    Java面向对象基础编程练习题 1、编写 Car 类,属性有品牌(brand)和颜色(Color), 定义 show 方法,打印所有属性。 package com.wang.task10201001.pojo; /* * 1、编写 Car 类,属性有品牌(brand)和颜色...
  • Java 面向对象 练习题与答案

    热门讨论 2010-12-23 19:52:21
    Java 面向对象 练习题与答案
  • 1.以下Java程序运行的结果是: A public class Tester{ public static void main(String[] args){ Integer var1=new Integer(1); Integer var2=var1; doSomething(var2); System.out.print(var1.intValue()); ...
  • java面向对象试题[归类].pdf
  • java面向对象练习题

    2021-03-05 23:31:08
    java面向对象练习题1定义了一个函数来接收一年并确定它是否是闰年什么是闰年?可以除以4而不是100,或者可以除以400,那么今年是闰年2年,使用do-while重写猜谜游戏(希望比老师更完美)3定义了一个接收数组的函数,...
  • Java 面向对象编程 练习题 专题 1 初识 Java 一填空题 1自从 Sun 推出 Java以来按应用范围可分为三个版本 分别是SE EE ME 2环境变量的设置 若 JDK 安装在 D:JDK则应设置 Path为 classpath为 3Java源文件的扩展名为用...
  • Java面向对象编程练习题(28题集)

    千次阅读 多人点赞 2021-03-16 19:18:44
    练习题】01.类的成员变量 猜数字游戏一个类A有一个成员变量v有一个初值100。定义一个类对A类的成员变量v进行猜。如果大了则提示大了小了则提示小了。等于则提示猜测成功。 import java.util.*; public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,711
精华内容 8,684
关键字:

java面向对象练习题