《Java技术》第三次作业

《Java技术》第三次作业

（一）学习总结

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

把对象的全部成员属性和全部成员方法结合在一起，形成一个不可分割的独立单位（即对象）信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界，只保留有限的对外接口是指与外部发生联系。

（1）属性封装：private 属性类型 属性名称；

（2）方法封装：private 方法返回值 方法名称（参数列表）{}；

（3）只要是被封装的属性，必须通过setter和getter方法设置和取得；

（4）当构造方法没有设置成私有的权限，用户就可以使用构造方法创建对象并为私有属性赋初值。

class Sun{
    private String name;
    public Sun(){
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public void tell(){
        System.out.println("name:"+getName());
    }
}

public class Test5 {
    public static void main(String args[]){
        Sun sun=new Sun();
        sun.setName("太阳");
        sun.tell(); 
    }
}

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++);
    }
}

编译不能通过，class A对属性secret进行了封装，所以主方法里的字段 A.secret 不可视。

修改：

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

（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定义static属性，成为静态属性，xy才能进行相加操作。

修改：

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

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

class Book{
    int bookId;
    String bookName;
    double price;
    // 声明静态变量
    private static int bookSum;
    //定义静态代码块对静态变量初始化
    static{
        bookSum=1000;
    }
    //构造方法
    public Book(String bookName, double price) {
        this.bookName = bookName;
        this.price = price;
        bookId = bookSum;
        bookSum++;
    }
    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 totalBook=bookSum - 1000;
        return totalBook;  
    }

    //重写toString方法
    public String toString() {
        return "编号：" + bookId + " 书名：" + this.bookName + " 价格：" + this.price;
    }
    
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。

Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。

单例模式分为饿汉模式和饱汉模式
单例设计模式的特点：

（1）单例类只能有一个实例。

（2）单例类必须自己创建自己的唯一实例。

（3）单例类必须给所以其他对象提供这一实例。

饿汉式

public class Sun {  
    // 定义一个私有的构造方法
    private Sun() {   
    }  
    // 将自身的实例对象设置为一个属性,并加上Static和final修饰符
    private static final Sun instance = new Sun(); 
    // 静态方法返回该类的实例
    public static Sun getInstance() {  
    return instance;  
    }  
}

饱汉式

public class Sun {
// 定义私有构造方法（防止通过 new Sun()去实例化）
    private Sun() {   
    }   
// 定义一个Sun类型的变量（不初始化，注意这里没有使用final关键字）
    private static Sun instance;   
// 定义一个静态的方法（调用时再初始化Sun，但是多线程访问时，可能造成重复初始化问题）
    public static Sun getInstance() {   
     if (instance == null)   
        instance = new Sun();   
    return instance;   
    }   
} 

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

Java参数传递机制：
参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址，若方法里没有改变这个副本的地址，而是改变了地址中的值，那么在方法内的改变会影响到传入的参数；如果在方法中改变了副本的地址，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。

public class Test {
    String str = new String("你好  ");
    char[] ch = { 'w','o','r','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';
    }
}

运行结果：你好 World

因为change方法中的str和ch[]，str传递的是值，ch[]传递的是地址，传递地址的发生了变化，传递值得没有发生变化。

6.总结

用数组对象存储数据

Person per[]=new Person(){
    new Person(........),
    new Person(........),
};

（二）实验总结

1.员工信息查询

• 程序设计思路：

  （1）新建日期类、员工类、部门类,所有属性用private封装。一个部门有一个或零个经理：应该在部门中保存经理信息；一个部门有多名员工：在部门中保存多名员工信息；一个员工属于一个部门，在员工类中保存部门信息。

  （2）在主方法里设置取得数据：声明两个部门并分别实例化对象；用对象数组存储员工信息；设置部门和部门经理的关系；通过对数组读取设置员工和部门的关系；

  （3）最后输出员工的信息。

• 实验问题分析：

  问题1：在数组对象里有十个员工对象，需要把前五个放入部门1，把后五个放入部门2。

  解决方案：

  for(int i=0;i<emps.length-5;i++){
  emps[i].setDept(dept1);
  }
  for(int j=emps.length-5;j<emps.length;j++){
  emps[j].setDept(dept2);
  }

2.计算工具类

• 程序设计思路：

  （1）新建类，对属性private进行封装，在类中定义几何体的体积和表面积的方法，并返回主方法里。

  （2）在主方法里，用对象数组储存几何体的尺寸，而几何体的体积和表面积通过类里的方法得到，再用for循环输出对象数组的数据。直接用输出语句输出不同几何体的体积和和表面积和

  （3）通过while循环控制用户是否继续猜数，还是退出；用if判断用户想要猜哪种几何体的体积和表面积；在内循环里的if操作中，用用户输入的体积和表面积和通过调用计算类里体积和表面积进行比较。

• 实验问题分析：

  问题1：对于保留小数，不熟悉。

  解决方案：

  public static double round(double d,int len){
  BigDecimal b1=new BigDecimal(d);
  BigDecimal b2=new BigDecimal(2);
  return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue();
  }

3.评分系统

• 程序设计思路：

  （1）创建选手类，用private对编号和姓名进行封装，在类中定义普通方法求得最高分、最低分、最终得分，并返回其值。

  （2）在主方法里，用对象数组对选手的编号和姓名实例化进行存储，用外层循环控制选手的个数，内层循环控制每位选手的评分，输出选手的得分信息，再把选手的最终得分存入数组，用Arrays.sort()进行降序排序。

• 实验问题分析

  问题1：不会用对象排序。

  解决方案：

  public int compareTo(Competitor c){
  if(this.finalgrade>c.finalgrade){
  return 1;
  }
  else if(this.finalgrade<c.finalgrade){
  return -1;
  }
  else{
  return 0;
  }

  }

（三）代码托管

• 码云commit历史截图
  

转载于:https://www.cnblogs.com/li-yumeng/p/6664900.html