《Java技术》第三次作业
（一）学习总结
1-1.什么是面向对象的封装性
封装是起保护作用，保护某些方法或属性可以不被外部看见，在内部自几处理。
1-2.Java中是如何实现封装性的？试举例说明。
在Java中可以通过private这个关键字对属性或者方法进行封装。
格式
为属性封装：private 属性类型 属性名称；
为方法封装：private 方法返回值 方法名称（参数列表）
例如：
class Person{
String name;
int age;
public void tell(){
System.out.println("姓名："+name+",年龄："+age);
}
}
public class Yang {
public static void main(String arg[])
{
Person per=new Person();
per.name="张";
per.age=-18;
per.tell();
}
}
执行这个代码得到如下结果：
代码本身没有语法问题，但是任何人的年龄都不可能是负数。显而易见代码是不符合要求的，以为他的属性是可以被外部直接访问；因此我们可以对代码进行封装解决这个问题。用private进行封装：
package lianxi;
class Person{
private String name;
private int age;
public void tell(){
System.out.println("姓名："+name+",年龄："+age);
}
}
public class Yang {
public static void main(String arg[])
{
Person per=new Person();
per.name="张";
per.age=-18;
per.tell();
}
}
结果如下：
显示的错误为 name和age两个属性不可视；因为用private进行封装后，两个属性为类中的私有属性外部不可访问。若果要访问私有属性要用setter和getter方法
class Person{
private String name;
private int age;
public void tell(){
System.out.println("姓名："+name+",年龄："+age);
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age=age;
}
}
public class Test {
public static void main(String arg[])
{
Person per=new Person();
per.setAge(18);
per.setName("张");
per.tell();
}
}
结果如下：
2.阅读下面程序，分析是否能编译通过？如果不能，说明原因。
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++);
}
}
执行上面的程序结果如下：
在类中对secret属性进行了封装，所以外部不能直接访问，需要通过getter和ssetter方法进行访问。
修改：
class A{
private int secret = 5;
public int getSecret() {
return secret;
}
public void setSecret(int secret) {
this.secret = secret;
}
}
public class Yang{
public static void main(String args[]){
A a = new A(); //声明并实例化对象
a.setSecret(6); //调用setter方法设置变量
System.out.println(a.getSecret());
}
}
在类中定义了一个变量为5，并进行了封装，使用setter方法对变量进行访问修改，使用getter方法得到数据并输出。结果如下：
2-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关键字对属性静静态声明：
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[]){
Yang.method();
}
}
加static关键字，变量随类一起赋值，引用变量的是后内存里就有了；修改后结果：
3 . 使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从1000开始，每产生一个对象，则编号自动递增（利用静态变量和构造方法实现）。下面给出了测试类代码和Book类的部分代码，将代码补充完整。
package lianxi;
class Book{
int bookId;
String bookName;
double price;
static int count;// 声明静态 变量
static
{
count=1000;
}
//定义静态代码块对静态变量初始化
public Book()
{
}
public Book(String bookName,double price) {
this.bookName=bookName;
this.price=price;
bookId=count;
count++;
} //构造方法
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 sum;
sum=count-1000;
return sum;
}
public String toString() //重写toString方法
{
return
" 编号：" + bookId+ "
" +
" 书名：" + this.getBookName() + "
" +
" 价格：" + this.getPrice() + "
" ;
}
}
public class Yang{
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
单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。用private对构造方法进行封装，避免类在外部被实例化。
特点：
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。
优点：
一是能避免实例重复创建；
二是可以节省内存。
饿汉式建立一个sun，饿汉式单例模式，在类初始化的时候，已经自动实例化。
class sun{
private sun()
{
}
private static final sun a= new sun() ;
public static sun getInstance(){
return a ;
}
}
懒汉式建立sun，懒汉式单例模式是在第一次使用的时候实例化。
class sun{
private sun()
{
}
private static sun a= null ;
public synchronized static sun getInstance(){
if (a==null)
{
a=new sun();
}
return a ;
}
}
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';
}
}
运行结果：
原因：change()的参数str和ch[]都是引用类型，在类中str指向“你好”的地址，ch[]指向ch[]的地址，change()内str指向“hello”，但在类中str仍指向"你好"，而ch[0]仍指向ch[0]，因为String的内容一旦声明就不会改变，改变它的值实际上是改变了它指向的内存地址，但由函数返回时仍指向原地址。
图解：
6、用private进行封装；随机数的产生；类之间的联系。
（二）实验总结
实验内容：
1.按照下列要求完成类的设计
（1）设计一个日期类，用于记录年、月、日，提供对日期处理的常用方法(日期输出格式xxxx-xx-xx）。
（2）设计一个职工类，该职工类至少具有下面的属性：职工号，姓名，性别，生日，工作部门，参加工作时间，设计相应的方法。
（3）设计一个部门类，包括下列属性：部门编号，部门名称，经理，设计相应方法。
（4）设计一个测试类，采用对象数组模拟一个拥有两个部门，10个职工的单位，实现对相关信息的查询功能。
- 程序设计思路：分别建立日期类、职工类、部门类、测试类，职工类的生日和参加工作的时间需要引用日期类，在测试类中建立两个类之间的联系；部门中的经理也是员工类中的某个员工，在部门类中把经理定义成职工类，在测试类中建立联系；每个部门中有多个职工，需要在部门中建立员工类的对象数组，在测试类中把职工存到数组中。
- 问题1：输出的职工信息中的生日和参加工作时间是空；
- 原因：职工类和日期类没建立联系
解决方案：建立两个类之间的联系；
2.设计一个计算工具类，要求：
（1）为用户提供几个常见的几何体面积和体积的算法（如球的体积和表面积，圆柱体的体积和表面积，圆锥体的体积和表面积）（可以学习使用static关键字）
（2）设计一个测试类，给出几个不同的圆柱体，圆锥体，球体的尺寸，用计算工具类分别求它们体积的累加和与表面积的累加和。
（3）设计一个测试类，随机产生球，圆柱、圆锥体的尺寸，模拟考试，要求用户回答它们的体积和面积，并判断用户的回答是否正确 - 程序设计思路：建立一个工具类，定义计算面积需要的变量：半径、高线、母线，这里的∏可以用static定义为3.14，用toString方法直接返回计算面积和体积的公式；在测试类中，构造方法传入参数，输出调用toString方法直接输出计算结果；在模拟考试的测试类中，随机产生3个随机数，并且给他们实例化；调用头String输出正确的计算结果和输入的值作比较，如果相等猜测正确；否则猜测错误。
- 问题1：把球的面积和体积一起用toString调用输出，在模拟测试类中则没法分别于面积、体积比较是否相等，在测试类中无法把面积和体积分别求和。
- 解决方法：一个toString只返回一个面积或体积。
（三）[代码托管]
https://git.oschina.net/Java-CS01YXR/Java-CS01YXR.git
- 码云commit历史截图
（四）学习进度条
| 代码行数（新增/累积） | 学习时间（新增/累积） | 本周学习内容 | |
|---|---|---|---|
| 目标 | 5000行 | 300小时 | |
| 第2-4周 | 150/300 | 30/30 | 学习了.... |
| 第5周 | 220/300 | 30/50 | 学习了关于double类型存在精度问题，取指定位置和截取字符串；数组的应用 |
| 第6周 | 550/600 | 60/80 |