Java第三次作业——面向对象基础（封装）

（一）学习总结

1.什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明。

面向对象的封装就是把对象的数据和方法封装在一起构成一个类，用setter和getter来完成。

例如：

public int getYear() {
    return year;
}
public void setYear(int year) {
    this.year = year;
}
public int getMonth() {
    return month;
}
public void setMonth(int month) {
    this.month = month;
}
public int getDay() {
    return day;
}
public void setDay(int day) {
    this.day = day;
}

2.阅读下面程序，分析是否能编译通过？如果不能，说明原因。

（1）

class A{
private int secret = 5;
}
public class Test{
public static void main(String args[]){
    A a = new A();
    System.out.println(a.secret++);
}
}

不能，没有对serect用setter、getter封装

（2）

public class Test{
int x = 50;
static int y = 200;
public static void method(){
    System.out.println(x+y);
}
public static void main(String args[]){
    Test.method();
}
}

不能，x为非静态，应将其改为静态修饰符

3 . 使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从1000开始，每产生一个对象，则编号自动递增（利用静态变量和构造方法实现）。下面给出了测试类代码和Book类的部分代码，将代码补充完整。

class Book{
     int bookId;
     String bookName;
      double price;
// 声明静态变量

//定义静态代码块对静态变量初始化

//构造方法

 public String getBookName() {
    return bookName;
}
public void setBookName(String bookName) {
    this.bookName = bookName;
}
public double getPrice() {
    return price;
}
public void setPrice(double price) {
    this.price = price;
}  
//定义方法求图书总册数

//重写toString方法

}
public class Test{
  public static void main(String args[]){ 
    Book[] books = {new Book("c语言程序设计",29.3),
                    new Book("数据库原理",30),
                    new Book("Java学习笔记",68)};
    System.out.println("图书总数为："+ Book.totalBook()); 
    for(Book book:books){
        System.out.println(book.toString());
    }
}   
}

完整的程序为：

class Book{
      int bookId;
     String bookName;
     double price;
     static int booknum;// 声明静态变量
static{
  booknum=1000;
     } //定义静态代码块对静态变量初始化

public Book(){
    
}
public Book(String bookName,double price){
    this.bookName=bookName;
    this.price=price;
    bookId=booknum;
    booknum++;
}//构造方法

 public String getBookName() {
    return bookName;
}
public void setBookName(String bookName) {
    this.bookName = bookName;
}
public double getPrice() {
    return price;
}
public void setPrice(double price) {
    this.price = price;
}  
public static int totalBook(){
    int num=0;
    num=booknum-1000;
    return num;
}//定义方法求图书总册数
public String toString() {
    return "图书编号为：" + bookId + ", 图书名为：" + bookName + ", 图书价格为：" + price;
}
//重写toString方法 
}
public class Test{
  public static void main(String args[]){ 
    Book[] books = {new Book("c语言程序设计",29.3),
            new Book("数据库原理",30),
            new Book("Java学习笔记",68)};
    System.out.println("图书总数为："+ Book.totalBook()); 
    for(Book book:books){
     System.out.println(book.toString());
    }
}   
}

4.什么是单例设计模式？它具有什么特点？用单例设计模式设计一个太阳类Sun。

单例设计模式需要保证在整个程序运行期间针对该类只存在一个实例对象。

class Sun{
    private static Sun instance=new Sun();
    private Sun(){
    
    }
    public static Sun getInstance(){
        return instance;
    }
}
public class Test{
    public static void main(String []args){
        Sun s1=Sun.getInstance();
        Sun s2=Sun.getInstance();
        System.out.println(s1==s2);
    }
}

5.理解Java参数传递机制，阅读下面的程序，运行结果是什么？说明理由。

public class Test {
String str = new String("你好  ");
char[] ch = { 'w','o','l','l','d' };
public static void main(String args[]) {
    Test test = new Test();
    test.change(test.str, test.ch);
    System.out.print(test.str);
    System.out.print(test.ch);
}
public void change(String str, char ch[]) {
    str = "hello";
    ch[0] = 'W';
}
}

运行结果：你好 Wolld

str地址没有改变，只是传递了值，指向的仍是“你好”，ch[0]='W',传递了地址。

6.其他需要总结的内容。

一个方法不能修改一个基本数据类型的参数

一个方法可以改变一个对象的参数状态

一个方法不能让对象参数引用一个新的对象

静态方法用static修饰的成员方法可通过类名直接调用，但不能调用类的非static属性和方法

（二）实验总结

1.程序设计思路：设计一个日期类，用于记录年、月、日，日期输出格式为xxxx-xx-xx，然后设计一个职工类，对职工的属性进行定义：职工号，姓名，性别，生日，工作部门，参加工作时间。生日及参加工作时间调用日期类方法。设计一个部门类，定义属性：部门编号，部门名称，经理。设计一个测试类，用对象数组建两个部门，10个职工，每个部门有五个职工。

问题1：

public Employee(int no,String name,String sex,Date birth,String dept,Date start){
    this.no=no;
    this.name=name;
    this.sex=sex;
    this.birth=birth;
    this.dept=dept;
    this.start=start;
}

原因：职工表里调用日期类不知道应该怎么调用

解决方案：通过问老师及同学，知道了可以直接定义来调用定义生日和参加工作时间为Date。

private Date birth;
private Date start;

问题2：

Employee emp1[] = new Employee[]{
            new Employee(001,"张三","男",new Date (1995,01,12),"技术部",new Date(2014,10,30)),
            new Employee(002,"李四","男",new Date (1991,02,11),"技术部",new Date(2012,05,30)),
            new Employee(003,"李莉","女",new Date (1993,10,15),"技术部",new Date(2015,06,25)),
            new Employee(004,"王强","男",new Date (1987,03,10),"技术部",new Date(2010,03,30)),
            new Employee(005,"赵华","女",new Date (1989,05,12),"技术部",new Date(2011,07,01)),
    };
    Employee emp2[] = new Employee[]{
            new Employee(006,"马强","男",new Date (1988,07,18),"人事部",new Date(2011,10,12)),
            new Employee(007,"王红","女",new Date (1992,11,20),"人事部",new Date(2017,03,30)),
            new Employee(010,"陈飞","男",new Date (1994,06,19),"人事部",new Date(2014,04,30)),
            new Employee(011,"李琦","女",new Date (1995,01,15),"人事部",new Date(2014,04,01)),
            new Employee(012,"张辉","男",new Date (1985,11,12),"人事部",new Date(2008,10,01)),
    };

原因：不知道应该怎么用对象数组

解决方案：刚开始写的直接是数组形式的，后来同学告诉才知道那不是对象数组，又看了老师的课件，得以改正。

2.设计一个计算工具类，要求：

程序设计思路：先设计一个计算类，定义方法来求球的体积和表面积，圆柱体的体积和表面积，圆锥体的体积和表面积，在设计一个测试类给出几个不同的圆柱体，圆锥体，球体的尺寸，用计算工具类分别求它们体积的累加和与表面积的累加和。再设计一个测试类，随机产生球，圆柱、圆锥体的尺寸，用户输入它们的体积和表面积面积，若用户回答正确，输出xxx的xx回答正确，若错误，输出xxx的xx回答错误，并输出正确答案。

问题1：

public double area(){
    c=r * r * Math.PI * 4;
    return c;
}
public double area1(){
    cc=r * Math.PI * 2 * (l+r);
    return cc;
}
public double area2(){
    zc=r * Math.PI * (l+r);
    return zc;
}
public double volume(){
    s=r * r * r * Math.PI * 4 / 3.0;
    return s;
}
public double volume1(){
    cs=r * r * Math.PI * h;
    return cs;
}
public double volume2(){
    zs=r * r * Math.PI * h / 3.0;
    return zs;
}

原因：不知道在计算类里应该怎么进行计算

解决方案：后来通过问同学知道在类里可以定义方法来计算表面积体积，就在计算类里定义了方法。

问题2：

Random rand=new Random();
    double banjing= Gongju.round(rand.nextDouble(),2);
    double gao= Gongju.round(rand.nextDouble(),2);
    double mu= Gongju.round(rand.nextDouble(),2);
    Gongju gongju=new Gongju(banjing,mu,gao);

原因：在产生随机数是不知道应该怎么写

解决方案：刚开始以为有三个随机数，这三个随机数应该在一条语句里，后来问了同学，知道了应该写三条语句。

3.用面向对象编程思想完成评分系统

程序设计思路：创建一个类，定义属性：编号，姓名，得分，最终得分，写出方法分别计算最高分，最低分，最终得分。在测试类中完成打分功能，每位选手打分完毕后输出：去掉一个最高分xx,去掉一个最低分xx最终得分xxx，所有打分完之后，按成绩降序输出。

问题1：

Scanner in=new Scanner(System.in);
    System.out.println("请输入分数");
    for(int i=0;i<pingfen.length;i++){
        System.out.println("输入第"+(i+1)+"个人的分数");
        for(int j=0;j<score.length;j++){
            score[j]=in.nextInt();
            
    }
        p[i]=Pingfen.grade(score);
        System.out.println("去掉一个最高分："+ Pingfen.max(score) +", 去掉一个最低分："+ Pingfen.min(score) +
                "，"+ (i+1) +"号选手最终得分："+Pingfen.grade(score));

原因：不知道应该用哪个数组把最大最小值调用过来

解决方案：在试过多次以后，及同学的帮助，直接调用最终成绩就是已经把那些调用了

（三）[代码托管]（https://git.oschina.net/hebau_cs15/Java-CS02yyh）

码云commit历史截图

转载于:https://www.cnblogs.com/yang-yonghui/p/6664357.html