Java 基础 第七天

于 2015-05-06 18:40:28 发布
阅读量230 收藏
点赞数
分类专栏： Java 编程语言 文章标签： 面向对象 基本概念 四大支柱
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangzihao123com/article/details/45539231
版权

Java 基础

面向对象-1

  1. 基本概念

    • 对象：①一切皆为对象；②每个对象都是唯一的；③对象都属于某个类；④对象都有属性和行为。
    • 类：类是将一类对象共同的特征抽取出来的结果，是对象的蓝图和模板。

  2. 四大支柱

    • 抽象（abstraction）：寻找共性。定义类的过程就是一个抽象的过程，需要做数据抽象和行为抽象。
    • 封装（encapsulation）：隐藏一切可以隐藏的复杂繁琐的实现细节，只提供清晰简单的接口（界面）。
    • 继承（inheritance）：从已有的类创建新类的过程。提供继承信息的类叫父类（超类、基类），得到继承信息的类叫子类（派生类、衍生类）。
    • 多态（polymorphism）：执行相同的行为却做了不同的事情（产生了不同的结果）。

  3. 定义类

  4. 创建和使用对象

  5. 发现问题域中的类

    从问题描述中找名词和动词，名词会成为类或者对象的属性，动词会成为对象的方法。

类的结构

public class 类名 {
    // 属性（数据抽象）

    // 构造器

    // 方法（行为抽象）
}

创建和使用对象的语法

    类型 变量名 = new 构造器([参数列表]);
    变量名.方法([参数列表]);

练习1：写一个类，模拟数字时钟。

package com.lovoinfo;

import java.util.Calendar;

/**
 * 时钟
 * @author jackfrued
 *
 */
public class Clock {
    private int hour;       // 时
    private int minute;     // 分
    private int second;     // 秒

    /**
     * 构造器
     */
    public Clock() {
        Calendar cal = Calendar.getInstance();
        hour = cal.get(Calendar.HOUR_OF_DAY);
        minute = cal.get(Calendar.MINUTE);
        second = cal.get(Calendar.SECOND);
    }

    /**
     * 构造器
     * @param hour 时
     * @param minute 分
     * @param second 秒
     */
    public Clock(int hour, int minute, int second) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }

    /**
     * 走字
     */
    public void go() {
        second += 1;
        if(second == 60) {
            second = 0;
            minute += 1;
            if(minute == 60) {
                minute = 0;
                hour += 1;
                if(hour == 24) {
                    hour = 0;
                }
            }
        }
    }

    /**
     * 显示时间
     * @return 返回当前时间
     */
    public String display() {
        String str = "";
        if(hour < 10) {
            str += "0";
        }
        str += hour + ":";
        if(minute < 10) {
            str += "0";
        }
        str += minute + ":";
        if(second < 10) {
            str += "0";
        }
        str += second;
        return str;
    }

    /**
     * 调整小时
     * @param up true表示上调, false表示下调
     */
    public void setHour(boolean up) {
        if(up) {
            hour = (hour + 1) % 24;
        }
        else {
            hour -= 1;
            if(hour == -1) {
                hour = 23;
            }
        }
    }

    /**
     * 调整分钟
     * @param up true表示上调, false表示下调
     */
    public void setMinute(boolean up) {
        if(up) {
            minute = (minute + 1) % 60;
        }
        else {
            minute -= 1;
            if(minute == -1) {
                minute = 59;
            }
        }
    }

    /**
     * 调整秒
     * @param up true表示上调, false表示下调
     */
    public void setSecond(boolean up) {
        if(up) {
            second = (second + 1) % 60;
        }
        else {
            second -= 1;
            if(second == -1) {
                second = 59;
            }
        }
    }
}

package com.lovoinfo;

public class Test03 {

    public static void main(String[] args) throws Exception {
        Clock c = new Clock();
        while(true) {
            System.out.println(c.display());
            Thread.sleep(1000);
            c.go();
        }
    }
}

练习2：计划修一个圆形的游泳池，半径尚未确定，游泳池的外围修建宽度为3m的环形过道，过道的外围修建一圈围墙，已知围墙的造价为5元/m，过道的造价为18元/m^2^，写一个程序，输入游泳池的半径，计算出过道和围墙的造价。

package com.lovoinfo;

// 1. 定义类（数据抽象[属性]、行为抽象[方法]、构造器）
/**
 * 圆
 * @author jackfrued
 *
 */
public class Circle {
    private double radius;  // 半径

    /**
     * 构造器
     * @param radius 半径
     */
    public Circle(double radius) {
        this.radius = radius;
    }

    /**
     * 获得周长
     * @return 圆的周长
     */
    public double circumference() {
        return 2 * Math.PI * radius;
    }

    /**
     * 获得面积
     * @return 圆的面积
     */
    public double area() {
        return Math.PI * radius * radius;
    }
}
package com.lovoinfo;

import java.util.Scanner;

public class Test01 {

    private static final double FUNIT = 5.5;    // 围墙的单位造价
    private static final double CUNIT = 18;     // 过道的单位造价

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入游泳池的半径: ");
        double r = sc.nextDouble();

        // 2. 创建对象
        Circle c1 = new Circle(r);
        Circle c2 = new Circle(r + 3);

        // 3. 让对象发生行为（对象调用方法）求解问题
        System.out.printf("围墙的造价为: ￥%.2f元\n",
                c2.circumference() * FUNIT);
        System.out.printf("过道的造价为: ￥%.2f元\n",
                (c2.area() - c1.area()) * CUNIT);

        sc.close();
    }
}

练习3：学生类和老师类。

package com.lovoinfo;

/**
 * 人（父类）
 * @author jackfrued
 *
 */
public class Person {
    protected String name;  // 姓名
    protected int age;      // 年龄

    /**
     * 构造器
     * @param name 姓名
     * @param age 年龄
     */
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 吃饭
     */
    public void eat() {
        System.out.println(name + "在吃饭");
    }

    /**
     * 睡觉
     */
    public void sleep() {
        System.out.println(name + "在睡觉");
    }

    /**
     * 玩耍
     */
    public void play() {
    }
}

package com.lovoinfo;

/**
 * 学生（人的子类）
 * @author jackfrued
 *
 */
public class Student extends Person {
    private String grade;   // 年级

    /**
     * 构造器
     * @param name 姓名
     * @param age 年龄
     * @param grade 年级
     */
    public Student(String name, int age, String grade) {
        super(name, age);   // 调用父类构造器
        this.grade = grade;
    }

    /**
     * 学习
     * @param courseName 课程名称
     */
    public void study(String courseName) {
        System.out.println(name + "在学习" + courseName);
    }

    /**
     * 玩耍（对父类中的play方法进行重新实现[重写]）
     */
    public void play() {
        System.out.println(name + "在玩LOL");
    }

    @Override
    public String toString() {
        return name + " - " + age + " - " + grade;
    }

}
package com.lovoinfo;

/**
 * 老师（人的子类）
 * @author jackfrued
 *
 */
public class Teacher extends Person {
    private String title;   // 职称

    /**
     * 构造器
     * @param name 姓名
     * @param age 年龄
     * @param title 职称
     */
    public Teacher(String name, int age, String title) {
        super(name, age);
        this.title = title;
    }

    /**
     * 授课
     * @param courseName 课程名称
     */
    public void teach(String courseName) {
        System.out.println(name + "正在教" + courseName);
    }

    /**
     * 玩耍（对父类中的play进行重新实现[重写]）
     */
    public void play() {
        System.out.println(name + "在打麻将");
    }

    @Override
    public String toString() {
        return name + " - " + age + " - " + title;
    }
}

练习4：编程模拟银行账户及其操作。

package com.lovoinfo;

/**
 * 银行账户
 * @author jackfrued
 *
 */
public class Account {
    private String cardNumber;  // 卡号
    private String password;    // 密码
    private double balance;     // 余额

    /**
     * 构造器
     * @param cardNumber 卡号
     * @param password 初始密码
     */
    public Account(String cardNumber, String password) {
        this.cardNumber = cardNumber;
        this.password = password;
        this.balance = 0.0;
    }

    /**
     * 验证密码
     * @param thyPassword 输入的密码
     * @return 验证通过返回true否则返回false
     */
    public boolean verify(String thyPassword) {
        return password.equals(thyPassword);
    }

    /**
     * 取款
     * @param money 取款金额
     * @return 取款成功返回true否则返回false
     */
    public boolean withdraw(double money) {
        if(money > 0 && money <= balance) {
            balance -= money;
            return true;
        }
        return false;
    }

    /**
     * 存款
     * @param money 存款金额
     * @return 存款成功返回true否则返回false
     */
    public boolean deposit(double money) {
        if(money > 0) {
            balance += money;
            return true;
        }
        return false;
    }

    /**
     * 转账
     * @param other 转入账户
     * @param money 转出金额
     * @return 转账成功返回true否则返回false
     */
    public boolean transfer(Account other, double money) {
        if(this.withdraw(money)) {  // 如果当前账户扣款成功才能向转入账户存钱
            boolean flag = other.deposit(money);
            if(!flag) { // 如果向转入账户存钱不成功则应返还转出金额
                this.deposit(money);
            }
            return flag;
        }
        return false;
    }

    /**
     * 查询余额
     * @return 账户余额
     */
    public double getBalance() {
        return balance;
    }

    /**
     * 获得卡号
     * @return 卡号
     */
    public String getCardNumber() {
        return cardNumber;
    }

    /**
     * 修改密码
     * @param newPassword 新密码
     */
    public void changePassword(String newPassword) {
        this.password = newPassword;
    }
}

练习5：双色球随机选号程序。

package com.lovoinfo;

/**
 * 球
 * @author jackfrued
 *
 */
public class Ball {
    private int number;     // 数字
    private boolean used;   // 是否被使用过

    /**
     * 构造器
     * @param number 球上面的数字
     */
    public Ball(int number) {
        this.number = number;
        // this.used = false;
    }

    /**
     * 球是否被使用过
     * @return 使用过返回true否则返回false
     */
    public boolean isUsed() {
        return used;
    }

    /**
     * 设置球有没有被使用过
     * @param used true表示使用过false表示没有使用过
     */
    public void setUsed(boolean used) {
        this.used = used;
    }

    /**
     * 获得球上的号码（如果号码小于10前面要补0）
     * @return 号码补0后的字符串
     */
    public String getNumber() {
        return number < 10? "0" + number : "" + number;
    }

    /**
     * 获得球上的号码
     * @return 号码的数字
     */
    public int getNum() {
        return number;
    }
}
package com.lovoinfo;


/**
 * 双色球选号机
 * @author jackfrued
 *
 */
public class LotteryMachine {
    private Ball[] redBalls = new Ball[33];     // 33个红球 
    private Ball[] blueBalls = new Ball[16];    // 16个蓝球

    // 装入红色球和蓝色球
    public void load() {
        for(int i = 0; i < redBalls.length; i++) {
            redBalls[i] = new Ball(i + 1);  // 创建一颗球
        }

        for(int i = 0; i < blueBalls.length; i++) {
            blueBalls[i] = new Ball(i + 1);
        }
    }

    // 摇出6个红色球
    public Ball[] getRedBalls() {
        Ball[] rBalls = new Ball[6];
        for(int i = 0; i < rBalls.length; i++) {
            Ball currentBall = null;
            do {
                int index = (int) (Math.random() * redBalls.length);
                currentBall = redBalls[index];
            } while(currentBall.isUsed());
            rBalls[i] = currentBall;
            currentBall.setUsed(true);
        }

        for(int i = 1; i < rBalls.length; i++) {
            for(int j = 0; j < rBalls.length - i; j++) {
                if(rBalls[j].getNum() > rBalls[j + 1].getNum()) {
                    Ball temp = rBalls[j];
                    rBalls[j] = rBalls[j + 1];
                    rBalls[j + 1] = temp;
                }
            }
        }

        return rBalls;
    }

    // 摇出1个蓝色球
    public Ball getBlueBall() {
        return blueBalls[(int) (Math.random() * blueBalls.length)];
    }

    // 产生一个随机号码
    public String generateRandomNumber() {
        load(); // 装入红色球和蓝色球
        Ball[] myRedBalls = getRedBalls();  // 摇出6个红色球
        Ball myBlueBall = getBlueBall();    // 摇出1个蓝色球

        String myNumber = "";
        for(int i = 0; i < myRedBalls.length; i++) {
            myNumber += myRedBalls[i].getNumber() + " ";
        }
        myNumber += "|";
        myNumber += " " + myBlueBall.getNumber();
        return myNumber;
    }
}
package com.lovoinfo;

import java.util.Scanner;

public class Test06 {

    public static void main(String[] args) {
        LotteryMachine lm = new LotteryMachine();

        Scanner sc = new Scanner(System.in);
        System.out.print("机选几注: ");
        int n = sc.nextInt();

        for(int i = 1; i <= n; i++) {
            System.out.println(lm.generateRandomNumber());
        }

        sc.close();
    }
}
yangzihao123com
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
07_Java基础语法_第7天（练习）_讲义
02-16
07_Java基础语法_第7天（练习）_讲义
OOP
猪猪神功屁
04-20 5424
OOP:Object Oriented Programming,面向对象的程序设计。所谓“对象”在显式支持面向对象的语言中，一般是指类在内存中装载的实例，具有相关的成员变量和成员函数（也称为：方法）。面向对象的程序设计完全不同于传统的面向过程程序设计，它大大地降低了软件开发的难度，使编程就像搭积木一样简单，是当今电脑编程的一股势不可挡的潮流。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展...
oop
Evennn的专栏
05-04 521
面向对象入门
《java基础入门》第三版 第七章作业.doc
09-20
《java基础入门》第三版 第七章作业.doc
java基础第七章内部类与异常类.doc
09-30
java基础第七章内部类与异常类.doc
Java基础入门第三版-黑马练习题
12-08
Java基础入门第三版——黑马练习题 第 1 章 Java 开发入门，第 2 章 Java 编程基础，第 3 章 面向对象（上） ，第 4 章 面向对象（下），第 5 章 异常 ，第 6 章 Java API ，第 7 章 集合类，第 8 章 泛型，第 9 章 ...
Java基础入门教程 第1章 Java 简介（共31页）.ppt
12-04
Java基础入门教程 第7章 Java中的异常处理（共26页）.ppt Java基础入门教程 第8章 文件流的输入输出操作（共37页）.ppt Java基础入门教程 第9章 Java的高级特性（共32页）.ppt jdk api 1.7.chm JDK_API_1_6_zh_...
王博外文文献.pdf
05-23
王博外文文献.pdf
基于 Go+Echo 开发的多房间实时通讯系统。.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： 简洁性：Go语言的语法简单直观，易于学习和使用。它避免了复杂的语法特性，如继承、重载等，转而采用组合和接口来实现代码的复用和扩展。 高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理机制，能够减少运行时错误和内存泄漏等问题。它还支持编译时检查，可以在编译阶段就发现潜在的问题。 标准库：Go语言的标准库非常丰富，包含了大量的实用功能和工具，如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现，而无需花费太多时间在底层功能的实现上。 跨平台：Go语言支持多种操作系统和平台，包括Windows、Linux、macOS等。它使用统一的构建系统（如Go Modules），可以轻松地跨平台编译和运行代码。 开源和社区支持：Go语言是开源的，具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之，Go语言是一种简单、高效、安全、并发的编程语言，特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言，并且需要处理大量的并发请求和数据，那么Go语言可能是一个不错的选择。
Qt调用Sqlite数据库
最新发布
05-23
使用Qt自带的库来使用Sqlite数据库,实现增删查改功能； Sqlite 数据库作为 Qt 项目开发中经常使用的一个轻量级的数据库，可以说是兼容性相对比较好的数据库之一，尤其是在一些嵌入式设备中，由于其小巧简洁而大量使用；
java程序设计基础第七版课后答案
12-13
《Java程序设计基础》第七版是一本经典的Java编程教材，它包含了大量的课后习题，供学生巩固所学知识。针对这些课后习题，我会分情况进行回答。 对于大部分课后习题，由于涉及的题目较多，我无法一一列举并提供详细...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值