java实验三
（一）学习总结
1.什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明。
---封装性是面向对象的第一大特性，所谓的封装性就是指对外部不可见的。
在Java中实现封装性就用到了private，封装格式为：
属性封装：private 属性类型 属性名称；
方法封装：private 方法返回值 方法名称（参数列表）{}
而所需的封装属性的设置和取得就定依靠setter及getter方法完成。
class Person{
private String name;
public void print(){
System.out.println("姓名:"+getName());
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
}
public class Text{
public static void main(String arg[]){
Person per=new Person();
per.setName("李四");
per.print();
}
}
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++);
}
}
---不能编译。原因：在A类中对secret进行了封装，而在Test类中不能对已经封装的内容进行调用，修改，执行。
---应该将private去掉。
（2）
public class Test{
int x = 50;
public static void method(){
System.out.println(x+y);
}
public static void main(String args[]){
Test.method();
}
}
---不能编译。原因：x没有定义为静态属性即非static属性，在“public static void main(String args[])”中不可以调用。
---修改：static int x = 50;
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());
}
}
}
4.什么是单例设计模式？它具有什么特点？用单例设计模式设计一个太阳类Sun。
---就是在设计一个类时，需要保证在整个程序运行期间针对该类只存在一个实例对象。
---优点：
由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显了。
由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。
单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。
---缺点：
单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。
单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能用mock的方式虚拟一个对象。
单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。
class Sun{
private static Sun instance = new Sun() ;
private Sun(){
}
public static Sun getInstance(){
return instance ;
}
public void print(){
Ststem.out.println("Hello World!");
}
}
public class Test{
public static void main(String args[]){
Sun s1 = Sun.getInstance() ;
s1.print();
}
}
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';
}
}
---运行结果为：
原因：String类声明的字符串常量被访问的他的内容，不会发生改变，而ch型访问的是地址的值，所以被调用时str的结果任是“hello”，ch[0]则是首地址的值“W”。
（二）实验总结
1.
程序设计思路：首先分别设计4个类，一个日期类，一个职工类，一个部门类，一个测试类，对它们的属性进行封装，再进行实现关联----对象引用，设计一个部门只有一个经理，5个员工在部门中保存员工的信息，最后用toString的方法输出。
---暂无问题。
2.
设计计算工具类
程序设计思路：设计计算工具类把半径，高，体积，表面积进行封装，用测试类，产生独立对象并实例化，将得到的体积和表面积分别加起来，求累加和。在再该测试类中随机产生数，让用户分别求出圆柱体、球体的体积和表面，并调用计算工具类，判断用户的回答正确与否。
问题1:没求累加和
解决方案：
（三）代码托管
https://git.oschina.net/hebau_cs15/java_CS01wfy.git
