java 第三次作业

java第三次作业

张鹏 计科1501班

---

1.什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明。
封装性是面向对象方法所遵循的一个重要原则，它有两方面含义：
(1).指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位（即对象）中；
(2).指“信息屏蔽”，把不需要让外界知道的信息隐藏起来，有些对象属性以及行为允许外界知道或使用，但不允许更改，而另一些属性和行为，则不允许外界知道，或只允许使用对象的功能，而尽可能的隐蔽对象的功能而实现细节。
封装性在程序设计中表现为，把描述对象属性的变量及实现对象功能的方法合在一起，定义为一个程序单位，而且保证外界不能任意更改内部的属性值，也不能任意调动其内部的功能方法。

在JAVA开发的标准规定中，封装属性的设置和取得依靠setter及getter方法完成
*setter：设置属性的值
例如：

public void setCname(String cname){
        this.cname=cname;
    }

*getter：调用该属性的值
例如：

public String getCname(){
        return this.cname;
    }

private修饰符：只能被该类自身访问
例如：

class Employee{
    private int cno;
    private String cname;
    private String sex;
    private Date date;
    ```````
}

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

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

不能通过编译，因为类中的属性通过private进行了封装，此属性只能在该类中使用，而主类中直接调用，所以不可编译。如若想调用不同类中属性，则应使用set或get调用该属性。

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{
    private int bookId;
    private String bookName;
    private double price;
    public Book(){}
    
   static int books;         // 声明静态变量   
   static{
       books=1000;     
   }                       //定义静态代码块对静态变量初始化
    
   public Book(String bookName,double price){
        this.bookName=bookName;     
        this.price=price;
        books++;
    }                           //构造方法
    public int getBookId() {
        return bookId;
    }
    public void setBookId(int bookId) {
        this.bookId = bookId;
    }  
     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(){
        return books-1000;
    }
                        //定义方法求图书总册数
    public String toString(){
        return "书名："+this.bookName+"\t"+"价格："+this.price;
    }
    //重写toString方法
    
}
public class te{
    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。
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
优点
一、实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
二、灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程
缺点
一、开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
二、可能的开发混淆
使用单例对象(尤其在类库中定义的对象)时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中(例如基于.NET Framework的语言)，只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中(如 C++)，其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。
饿汉式

//饿汉式单例类，在类初始化时，已经自行实例化。
public class Sun{
       private Sun(){}
       private static final Sun su=new Sun();      //静态工厂方法
       public static Sun getinstance(){
            return su;
        }
}

懒汉式

//懒汉式单例类，在第一次调用的时候实例化自己
public class Sun{
       private Sun(){}
       private static Sun su=null;       //静态工厂方法
       public static Sun getinstance(){
           if(su==null){
               su=new Sun();
            }
            return su;
       }
}

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”
ch[]储存到栈内存内，他的地址被change引用，首元素ch[0]被改变为‘W’；而使用String声明的字符串不可更改，顾还是“你好”。
6.其他总结
对对像进行升序或降序排序用到了comparable接口
建立方法使两两之间需要进行比较的值进行比较，分别返回1、-1、0。程序如下：

   public int compareTo(Person o) { 
         if (this.age > o.age) { 
               return 1;   
         } else if (this.age < o.age) { 
            return -1; 
       } else { 
            return 0; 
      } 
   } 
} 
Arrays.sort(per);     //使用sort方法对对象进行排序

（二）实验总结

1.按照下列要求完成类的设计
（1）设计一个日期类，用于记录年、月、日，提供对日期处理的常用方法(日期输出格式xxxx-xx-xx）。
（2）设计一个职工类，该职工类至少具有下面的属性：职工号，姓名，性别，生日，工作部门，参加工作时间，设计相应的方法。
（3）设计一个部门类，包括下列属性：部门编号，部门名称，经理，设计相应方法。
（4）设计一个测试类，采用对象数组模拟一个拥有两个部门，10个职工的单位，实现对相关信息的查询功能。
程序设计思路：通过建立Date（生日）、Employee（员工）、Dept（部门）三个类以及再深入建立其三个类之间的关联，在主类test中对其三类及其之间的关联进行引用即可。
问题1：

dept1.setEmps(new Employee[]{emps1,emps3});
dept2.setEmps(new Employee[]{emps2,emps4,emps5});

原因：以为把新创建的员工分别放入相应所属的部门就能达到查询其部门的目的。
解决方案：把新创建的员工依次输入相应所属的部门。

emps1.setDept(dept1);
emps2.setDept(dept2);
emps3.setDept(dept1);
emps4.setDept(dept2);
emps5.setDept(dept2);

2.设计一个计算工具类，要求：
（1）为用户提供几个常见的几何体面积和体积的算法（如球的体积和表面积，圆柱体的体积和表面积，圆锥体的体积和表面积）（可以学习使用static关键字）
（2）设计一个测试类，给出几个不同的圆柱体，圆锥体，球体的尺寸，用计算工具类分别求它们体积的累加和与表面积的累加和。
（3）设计一个测试类，随机产生球，圆柱、圆锥体的尺寸，模拟考试，要求用户回答它们的体积和面积，并判断用户的回答是否正确
程序设计思路：通过建立Qiu、Yuanzhu、Yuanzhui三个基本类，通过建立get方法，返回其表面积以及体积，然后通过判断其为哪一种立体图形，调用相应类的get方法依次求得其表面积以及体积和，然后进行输出；然后另一个测试类通过判断其要产生的立体图形随机产生其所需要的值，调用相应类中的get方法返回其表面积以及体积，然后与人为猜的值作比较。
3.用面向对象编程思想完成评分系统
程序设计思路：依次使用循环输入选手的得分以及选手编号和姓名，再通过建立xuanshou类和Comparable接口对各个选手信息进行降序输出。
问题1：

System.out.println("请输入第"+(j+1)+"位 选手编号以及姓名！");
no=in.nextLine();
na=in.nextLine();

原因：在打回车的时候，把回车赋值给了no，然后把学号以及姓名都给了na，导致在姓名那一齐输出编号以及姓名，而no那是空值。
解决方案：

System.out.println("请输入第"+(j+1)+"位 选手编号以及姓名！");
no=in.next();
na=in.next();

in.next()函数在输入的时候遇到空格会自动断开，因而赋值到相应的变量上。

（三）代码托管

*码云commit历史截图

转载于:https://www.cnblogs.com/zhangpengblogs/p/6671818.html