1、定义长方形类，含：

属性：宽、高（整型）；

方法：求周长、面积；

构造方法3个：（1）无参——宽、高默认值为1；（2）1个参数——宽、高均为参数值；（3）2个参数——宽、高各为参数值。

要求：进行测试。

代码如下：

长方形的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package Test1;
 
public class Rectangle {
    //定义长宽属性
    private int iWidth;
    private int iHeight;
    //构造器1
    public Rectangle(){
        this.iHeight = 1;
        this.iWidth = 1;
    }
    //构造器2
    public Rectangle(int iIndex){
        this.iWidth = iIndex;
        this.iHeight = iIndex;
    }
    //构造器3
    public Rectangle(int iWidth, int iHeight){
        this.iHeight = iHeight;
        this.iWidth = iWidth;
    }
    //求周长
    public int getLength(){
        return 2*(this.iHeight+this.iWidth);
    }
    //求面积
    public int getSquare(){
        return this.iHeight*this.iWidth;
    }
 
}
 
测试类：
package Test1;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Rectangle oRec1 = new Rectangle();
        System.out.println("默认长方形的周长为："+oRec1.getLength());
        System.out.println("默认长方形的面积为："+oRec1.getSquare());
 
        Rectangle oRec2 = new Rectangle(2);
        System.out.println("一个参数长方形的周长为："+oRec2.getLength());
        System.out.println("一个参数长方形的面积为："+oRec2.getSquare());
 
        Rectangle oRec3 = new Rectangle(2,3);
        System.out.println("两个参数长方形的周长为："+oRec3.getLength());
        System.out.println("两个参数长方形的面积为："+oRec3.getSquare());
 
    }
 
}

运行结果：

默认长方形的周长为：4

默认长方形的面积为：1

一个参数长方形的周长为：8

一个参数长方形的面积为：4

两个参数长方形的周长为：10

两个参数长方形的面积为：6

2、定义圆类，它有一个变量radius(半径)。从键盘输入数据，通过构造方法传递给radius，编程计算并输出圆的周长和面积（确保输入的数据不为负数）。

要求：进行测试。

代码如下：

圆的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package Test2;
 
public class Circle {
    private double radius;
 
    public Circle(double dRadius){
        this.radius = dRadius;
    }
 
    public double getLength(){
        return 2*Math.PI*this.radius;
    }
 
    public double getArea()
    {
        return Math.PI*this.radius*this.radius;
    }
 
}
 
 
测试类：
package Test2;
import java.util.Scanner;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        double iRadius;
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入圆的半径：");
        iRadius = sc.nextDouble();
        if(iRadius < 0){
            System.out.println("你输入的半径有误!");
        }
        else{
            Circle oCir = new Circle(iRadius);
            System.out.println("圆的周长为："+oCir.getLength());
            System.out.println("圆的面积为："+oCir.getArea());
        }
 
 
    }
 
}

运行结果：

正数时：

请输入圆的半径：1

圆的周长为：6.283185307179586

圆的面积为：3.141592653589793

负数时：

请输入圆的半径：-1

你输入的半径有误!

3、定义长方体类，定义求底面积、体积的方法。（可利用上述定义的长方形类）

要求：进行测试。

代码如下：

长方体类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
        package Test3;
 
import Test1.Rectangle;
 
public class RecV extends Rectangle{
    int iLong;
 
    public RecV(int iWidth, int iHeight, int iLong){
        super(iWidth,iHeight);
        this.iLong = iLong;
    }
 
    public int getBtmArea(){
        return this.getSquare();
    }
 
    public int getVolume(){
        return this.getSquare()*this.iLong;
    }
 
 
}
 
测试类：
package Test3;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        RecV oRecV = new RecV(1,2,3);
        System.out.println("长方体的底面积为:"+oRecV.getBtmArea());
        System.out.println("长方体的体积为："+oRecV.getVolume());
 
    }
 
}

运行结果：

长方体的底面积为:2

长方体的体积为：6

4、定义球类，定义求体积的方法。（可利用上述定义的圆类）

要求：进行测试。

代码如下：

球的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package Test4;
import Test2.Circle;
public class Bool extends Circle{
    public Bool(double dRadius) {
        super(dRadius);
        // TODO Auto-generated constructor stub
    }
 
    public double getBoolVolume(){
        return (4/3)*Math.PI*Math.pow(this.radius, 3.0);
    }
}
 
测试类：
    package Test4;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        Bool oBool = new Bool(1);
        System.out.println("球的体积为："+oBool.getBoolVolume());
 
    }
 
}

运行结果：

球的体积为：3.141592653589793

5、定义一个计算器类，包括加、减、乘、除运算。

要求：进行测试。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package Test5;
 
public class Calculator {
    private int iFirstNum;
    private int iSecondNum;
 
    public Calculator(int iFirst, int iSecond){
        this.iFirstNum = iFirst;
        this.iSecondNum = iSecond;
    }
 
    public int getAdd(){
        return this.iFirstNum + this.iSecondNum;
    }
 
    public int getSub(){
        return this.iFirstNum - this.iSecondNum;
    }
 
    public int getMul(){
        return this.iFirstNum * this.iSecondNum;
    }
 
    public void getDev(){
        if(this.iSecondNum ==0){
            System.out.print("分子不能为零！");
        }
        else
        {
            System.out.print(this.iFirstNum/this.iSecondNum);
        }
    }
 
}
 
测试类：
package Test5;
 
public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calculator oCal = new Calculator(4,2);
        System.out.println("两数之和为 ："+oCal.getAdd());
        System.out.println("两数之差为："+oCal.getSub());
        System.out.println("两数之积为："+oCal.getMul());
        System.out.print("两数之商为：");
        oCal.getDev();
    }
 
}

运行结果：

两数之和为 ：6

两数之差为：2

两数之积为：8

两数之商为：2

7、编写程序使用复数类Complex验证两个复数 2+2i 和3+3i 相加产生一个新的复数5+5i 。复数类Complex满足如下要求：

（1）属性：RealPart : int型，代表复数的实数部分；ImaginPart : int型，代表复数的虚数部分

（2）方法：

Complex( ) : 构造方法，将复数的实部和虚部都置0

Complex( int r , int i ) : 构造方法，形参 r 为实部的初值，i为虚部的初值。

Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。

String toString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

（3）进行测试。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package Test7;
 
public class Complex {
 
    private int iRealPart;
    private int iImaginPart;
 
    public Complex(){
        iRealPart = 0;
        iImaginPart = 0;
    }
 
    public Complex(int r, int i){
        iRealPart = r;
        iImaginPart = i;
    }
 
    public Complex complexAdd( Complex a ){
        this.iRealPart += a.iRealPart;
        this.iImaginPart += a.iImaginPart;
        return this;
    }
 
    public String toString(){
        return this.iRealPart+"+"+this.iImaginPart+"i";
    }
 
 
}
 
 
测试类：
package Test7;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //复数实例化
        Complex oFirstNum = new Complex();
        Complex oFirstNum1 = new Complex(2,3);
        Complex oSecondNum = new Complex(3,4);
 
        oFirstNum.complexAdd(oSecondNum);
        System.out.println("1。复数之和为："+oFirstNum.toString());
 
        oFirstNum1.complexAdd(oSecondNum);
        System.out.println("2.复数之和为："+oFirstNum1.toString());
    }
 
}

运行结果：

1。复数之和为：3+4i

2.复数之和为：5+7i

8、试编写Java代码实现一个计数器类Computer其中包括：

域value ：用来保存计数器的当前值；

方法increment()： 计数器加一；

方法decrement() ：计数器减一；

方法reset()：计数器清零。

请编写并调试程序。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package Test8;
 
public class Computer {
    private int value;
 
    public Computer(){
        this.value = 0;
    }
 
    public void increment(){
        this.value++;
    }
 
    public void decrement(){
        this.value--;
    }
 
    public void reset(){
        this.value = 0;
    }
 
    public int getValue(){
        return this.value;
    }
 
}
 
测试类：
package Test8;
 
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        Computer oCount = new Computer();
 
        System.out.println("计数器的初始值为：" + oCount.getValue());
 
        oCount.increment();
        oCount.increment();
        oCount.increment();
        System.out.println("加三后的值为：" + oCount.getValue());
 
        oCount.decrement();
        System.out.println("减一后的值为：" + oCount.getValue());
 
        oCount.reset();
        System.out.println("初始化后的值为：" + oCount.getValue());
 
    }
 
}

运行结果：

计数器的初始值为：0

加三后的值为：3

减一后的值为：2

初始化后的值为：0

Java面向对象练习的更多相关文章

  1. JAVA面向对象

    JAVA面向对象 对象   我们生活中能看到能摸到的一切事物都是对象.在程序中模拟出生活中的所有东西万物皆对象   只要是对象--属性和行为(方法)   属性   对象有什么   例如:学生有姓名.学 ...

  2. 理解JAVA - 面向对象(object) - 属性，方法

    理解JAVA - 面向对象(object) - 属性,方法 多态的体现:    向上造型,父类接收子类对象:向上造型:    从父类角度看不到子类独有的方法:面向对象,人类认知世界的方式:生活中每天都 ...

  3. Java面向对象㈠ -- 封装

    Java的面向对象有三大特征:封装.继承.多态.这里主要对封装进行讲解. 封装可以理解为隐藏一个类的成员变量和成员函数,只对外提供需要提供的成员函数. Java的封装主要通过访问权限控制符:priva ...

  4. 谈谈Java面向对象的三大特性

    Java面向对象的三大特性就是指封装.继承.多态了. 一.封装: 概念:封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式. (举例:笔记本电脑就是一个封装体,Java语言中最小的封装体就是函数 ...

  5. Java面向对象：接口

    Java面向对象之接口 什么是接口:接口是一种规范和标准,他们可以约束类的行为,是一些方法特征的集合 语法: [修饰符] interface 接口名 extends 父接口1,夫接口2....... ...

  6. 实验二 Java面向对象程序设计

    实验二 Java面向对象程序设计 实验内容 1. 初步掌握单元测试和TDD 2. 理解并掌握面向对象三要素:封装.继承.多态 3. 初步掌握UML建模 4. 熟悉S.O.L.I.D原则 5. 了解设计 ...

  7. java基础1.0：:Java面向对象、面向对象封装、抽象类、接口、static、final

    一.前言 一直以来都是拿来主义,向大神学习,从网上找资料,现在就把自己在工作中和学习中的所理解的知识点写出来,好记星不如烂笔头,一来可以作为笔记自己温习,二来也可以给走在求学之路的同学们一点参考意见, ...

  8. 20145212《Java程序设计》实验报告二 《 Java面向对象程序设计》

    20145212 实验二< Java面向对象程序设计> 实验内容 单元测试 三种代码 伪代码 百分制转五分制: 如果成绩小于60,转成"不及格" 如果成绩在60与70之 ...

  9. 20145213《Java程序设计》实验二Java面向对象程序设计实验报告

    20145213<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装,继承,多态 初步掌握UML建模 熟悉S.O. ...

  10. 20145206《Java程序设计》实验二Java面向对象程序设计实验报告

    20145206<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S.O. ...

随机推荐

  1. cocospods 最新安装教程

    Terminator 终端原来 安装 cocoa pods  终端命令 :sudo gem install cocoapods  #已经无效系统更新后的 cocoa pods 终端命令 : sudo ...

  2. 为什么要用elasticsearch－理解加深中

    首先的概念 基于Lucene 分布式实时文件存储 实时的分析搜索引擎 能达到实时搜索 优势的地方 1.横向可扩展性:只需要增加一台服务器,做一点儿配置,启动一下ES进程就可以并入集群: 2.分片机制提 ...

  3. Ant环境变量配置

    Ant环境变量配置 1.新建系统变量ANT_HOME    变量名: ANT_HOME    变量值: D:\biancheng\apache-ant-1.7.1 2.修改PATH    变量值最后面 ...

  4. C++构造函数/析构函数 设置成private的原因

    C++构造函数/析构函数 设置成private的原因 标签(空格分隔): c/c++ 将构造函数,析构函数声明为私有和保护的,那么对象如何创建? 已经不能从外部调用构造函数了,但是对象必须被构造,应该 ...

  5. Python之路【第五篇】python基础 之初识函数（一）和文件管理

    转载请注明出处http://www.cnblogs.com/wupeiqi/articles/5453708.html 函数 一.背景                                 ...

  6. PHP中include()与require()的区别说明

    require 的使用方法如 require("MyRequireFile.php"); .这个函数通常放在 PHP 程序的最前面,PHP 程序在执行前,就会先读入 require ...

  7. Daily Scrum02 12.16

    鉴于近期数据库大作业提交到了关键时期,大家的时间都十分的紧张,因而,我们决定全团队成员交替作业,不在每日每个成员都分配任务,而只需要每个成员保证每两天一次的工作量,以此方式给大家腾出去完成自己的事情. ...

  8. 【http代理报文】通过发包实现代理请求网页内容

    工作中,我们难免需要通过TCP/IP协议发送报文来直接请求网页内容(比如爬虫工具),有同学问如何通过HTTP代理来请求网页,其实我们只需要把报文稍稍修改下,发送给代理服务器即可实现. 基础不过关的朋友 ...

  9. Webpack教程

    打开链接:Webpack教程

  10. 玩转JavaScript OOP[1]——复杂类型

    概述 在JavaScript中,我们可以使用函数.数组.对象,以及日期.正则等一些内置类型的实例,它们都是复杂类型的表现.从本质上讲,这些复杂类型都是Object类型.本篇将主要介绍三种Object类 ...