第三次Java做业--计科1501--李俊

（一）学习总结
1.什么是面向对象的封装性，Java中是如何实现封装性的？
在面向对象法则中为了不用对象直接访问类中的属性,被封装的属性必须经过setter和getter方法得到。面向对象的封装性不仅仅只是private关键字，用private关键字声明的属性或方法只能在其类的内部被调用。
例子：

private String name;
     public void tell(){ 
     System.out.println("姓名:"+getName());
     public String getName(){ return name; } 
     public void setName(String n){ name=n; }
 public class Text{
      public static void main(String args[]){
      Person per=new Person(); 
      per.setName("李丽");

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

不能经过编译，由于Private属性是私有的不能由对象直接访问，secret被封装了，想要取得里面的值必须经过方法。
（2） 不能执行，X的值不是静态属性，应该改成用Static关键字

public class Test{ 
    static 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;
    static int booknum;    // 声明静态变量
    static{
        booknum=1000;
    }                      //定义静态代码块对静态变量初始化
    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("图书总数为："+ totalBook.numbook()); 
        for(Book book:books){
            System.out.println(book.toString());
        }
    }   
}

4.什么是单例设计模式？它具备什么特色？用单例设计模式设计一个太阳类Sun。
Java中单例模式是一种常见的设计模式，单例模式主要介绍了三种：懒汉式单例、饿汉式单例、登记式单例。
　　单例模式有如下特色：
　　一、单例类只能有一个实例。
　　二、单例类必须本身建立本身的惟一实例。
　　三、单例类必须给全部其余对象提供这一实例。
选择单例模式就是为了不不一致状态，避免政出多头
懒汉式单例

public class Sun {
       private static Sun instance=null;     
        private Sun(){}  
       public synchronized static Sun getInstance(){  
            if(instance==null){  
                instance=new Sun();  
           }  
            return instance;  
       }      
    }

饿汉式单例

public class Esun {
    private Esun(){}
    private static final Esun es=new Esun();
    public static Esun getes(){
        return es;
    }
}

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';
    }
}

运行结果为 你好 World
程序中传递的虽是String类型的对象，由于字符串的内容一旦声明是不可改变的，改变的只是其内存地址的指向。若须要更改类中属性的内容能够将
char[] ch = { 'w','o','l','l','d' };改成
Demo d1=new Demo();
d1.temp="wolld";
6.其余须要总结的内容
内部类若是被外部所调用，必定要先产生外部类的实例化对象，以后再产生内部类的实例化对象。
外部类.内部类 内部类对象=外部类实例.new 内部类（）；
静态内部类：用static声明内部类；静态类内部只能访问外部的静态成员，不能访问外部的非静态成员；在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类，只有静态内部类才能够声明静态成员；建立静态内部类对象 外部类.内部类 内部类对象=new 外部类.内部类(); 若是方法中的参数想被内部类所访问，参数前必须加final关键字。
foreach输出

Public class NewDemo {
    Public stati cvoid main (String[] args){
        System.out.print("不传参数( fun()):");
        fun();
        System.out.print("传递1个参数( fun()):");
        fun(1);
        System.out.print("传递2个参数( fun()):");
        fun(1,2,3,4,5);
    }
    Public static void fun(int...arg){       //可变参数，能够接收任意多个参数
        for(intx:arg){             // 使用foreach输出
            System.out.print(x+",");
        }
    }
}

（二）实验总结

实验内容：
1.按照下列要求完成类的设计
（1）设计一个日期类，用于记录年、月、日，提供对日期处理的经常使用方法(日期输出格式xxxx-xx-xx）。
（2）设计一个职工类，该职工类至少具备下面的属性：职工号，姓名，性别，生日，工做部门，参加工做时间，设计相应的方法。
（3）设计一个部门类，包括下列属性：部门编号，部门名称，经理，设计相应方法。
（4）设计一个测试类，采用对象数组模拟一个拥有两个部门，10个职工的单位，实现对相关信息的查询功能。
程序设计思路：将日期类，职工类，部门类设置其内部属性为私有属性，利用setter和getter方法设置和取得。在测试类中实例化Employee对象，并经过构造方法赋值。在查询时采用了一对一关系，目标是实现按姓名和编号查询，经过构造函数设置内容。
遇到的问题：输出结果不是本身想要的，在输出语句调用了tell();输出的信息比较详细，

public void tell(){
        System.out.println("部门编号"+getNum()+"部门名称"+getCname()+"经理"+getManager());

2.设计一个计算工具类，要求：
（1）为用户提供几个常见的几何体面积和体积的算法（如球的体积和表面积，圆柱体的体积和表面积，圆锥体的体积和表面积）（能够学习使用static关键字）
（2）设计一个测试类，给出几个不一样的圆柱体，圆锥体，球体的尺寸，用计算工具类分别求它们体积的累加和与表面积的累加和。
（3）设计一个测试类，随机产生球，圆柱、圆锥体的尺寸，模拟考试，要求用户回答它们的体积和面积，并判断用户的回答是否正确
设计思路，建立三个类分别实现球，圆柱，圆锥的计算，用static关键字声明方法，以便在测试时能够把随机产生的尺寸做为参数而后调用计算类，在测试类中调用计算类的结果进行求和运算，输出结果。测试类中的判断用if...else...判断用户的回答是否正确。
（三）代码托管（https://git.oschina.net/hebau_cs15/hebau-cs01LJ1.git）
•码云commit历史截图
上传实验项目代码到码云，在码云项目中选择“统计-commits”，设置搜索时间段，搜索本周提交历史，并截图。