《Java技术》的第二次作业

（一）学习总结

1.什么是构造方法？什么是构造方法的重载？下面的程序是否可以通过编译？为什么？

（1） 构造方法用于在创建对象时对其进行初始化，且方法名与类名相同，方法名前面没有返回值类型的声明，不能使用return语句，用户不能直接调用，而是通过关键字new自动调用方法的实现中，也可以进行方法重载

（2） 构造方法的重载，就是每个构造方法的参数类型和参数的个数不同，通过传递参数的个数及类型不同以完成不同功能的方法调用

public class Test {
    public static void main(String args[]) {
       Foo obj = new Foo();
    }
}
class Foo{
    int value;
    public Foo(int intValue){
        value = intValue;
    }
}

（3）不能运行，因为Foo()没有被定义，应该在有参数构造方法中传递参数 例如： Foo obj = new Foo(0);

2.运行下列程序，结果是什么？分析原因，应如何修改。

public class Test {
    public static void main(String[] args) {
       MyClass[] arr=new MyClass[3];
       arr[1].value=100;
    }
}
class MyClass{
   public int value=1;
}

改后的代码如下

public class Test {
    public static void main(String[] args) {
       MyClass arr=new MyClass（）;
       arr.value=100;
    }
}
class MyClass{
   public int value=1;
}

不能直接运用对象数组的格式进行编写代码。

3.运行下列程序，结果是什么？说明原因。

public class Test {
    public static void main(String[] args) {
        Foo obj1 = new Foo();
        Foo obj2 = new Foo();
        System.out.println(obj1 == obj2);
    }
}
class Foo{
    int value = 100;
}

运行结果：false

对于非字符串变量来说，""是用来比较其对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。 若在输出前加上：obj1=obj2; 那么 obj1obj2 是true

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

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问（public），private用于修饰成员变量和成员方法，被修饰的内容在其他类中不可以访问，封装之后属性必须通过setter和getter进行访问

package g;
class Person {
private String name;
private int no;

public void tell() {
	System.out.println("姓名：" + name + ",学号：" + no);
}

public String getName() {
	return name;
}

public void setName(String na) {
	name = na;
}

public int getNo() {
	return no;
}

public void setNo(int n) {
	no = n;
}
}
public class App {
public static void main(String[] args) {
	Person p = new Person();
	p.setName("张三");
	p.setNo(8900556);
	p.tell();                            //姓名：张三,学号：8900556
}
}

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

（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私有的，用private声明的属性或方法只能在其类的内部被调用，而不能在类的外部被调用。将secret改为公有类（public）或者用setter和getter方法进行访问

代码改编：

class A{
    public int secret = 5;

}
public class App{
    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();
    }
}

用static修饰的成员方法可以通过类名直接调用，而x是非静态变量，y是静态变量，需要将x改为静态变量

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

6.使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从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());
        }
    }
}

改编之后

class Book {
int bookId;
String bookName;
double price;
static int count;// 声明静态变量
static { // 定义静态代码块对静态变量初始化
	count = 1000;
}
public Book(String bookName, double price) {// 构造方法
	this.bookName = bookName;
	this.price = price;
	bookId = count;
	count++;// TODO Auto-generated constructor stub
}
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() { // 定义方法求图书总册数
	// TODO Auto-generated method stub
	count = count - 1000;
	return count;
}
public String toString() {
	return "图书编号" + bookId + "书名" + this.bookName + "价格" + this.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());
	}
}
}

7.什么是单例设计模式？它具有什么特点？用单例设计模式设计一个太阳类Sun。

单例设计模型是指在设计一个类时，需要保证在整个程序只存在一个实例对象

特点：构造方法私有化（private修饰），只能有一个实例；在类内创建实例化对象，用私有静态成员instance引用该对象；定义静态方法getInstance（）返回实例对象instance

public class Sun {
private static final Sun sun = new Sun(); // 将自身的实例对象设置成一个static final属性
private Sun() {   }// 私有构造方法
public static Sun getInstance() { // 公共静态方法返回该类的实例 通过getInstance()方法访问
	return sun;
}
}

8.理解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” ，因为str的地址发生了改变，但test.str的地址没有发生改变，所以str只是改变了一个副本，而ch[]改变的是地址内容，所以结果为“你好 World”

9.其他需要总结的内容。

     （1）String中对于“==”与“equals”的区别，“==”比较的是两个对象的地址，“equals”比较的是两个对象的内容
     （2）对象数组的格式：类名称 对象数组名称[]=new 类名称[数组长度]
    （3）构造方法特点：方法名与类名相同；方法名前没有返回值，不能用return语句返回值；用户需要使用new进行调用；在构造方法的实现中，可以进行方法重载
    （4）构造方法的重载：方法名称相同，但参数的类型和参数的个数不同

（二）实验总结

1.用面向对象思想完成评分系统

程序设计思路：

（1）创建一个选手类，基本属性：编号，姓名，最终得分，定义构造方法、getter和setter方法、toSting方法，实现Comparable接口，完成对象比较方法。

（2）创建一个评分类，基本属性：评委人数，评委给出的分数。定义构造方法、 getter和setter方法、分数输入方法inputScore（），计算平均分avarage（double score[]）

（3） 创建一个测试类，在测试类中创建选手对象，为每位选手打分（评分类），所有选手评分完毕后，给出排行榜，包括如下信息（选手编号，选手姓名，选手得分）

2.Email验证

程序设计思路

（1）先使用indexOf，查找@和“.”是否存在且@是否在“‘.”之前

（2）用startswith和endswith来判断位置是否正确

（3）使用if嵌套

问题：

在最开始没有满足全部要求

原因：

没有正确运用“&”和“||”

解决方案：

一遍一遍的进行尝试

3.查找子串

程序设计思路：

（1）先输入一个字符串和需要查找的子串

（2）用indexOf来确定是否存在那个子串，若存在，次数加一，否则返回-1，表示没有查找这个子串

问题：

调用的时候，出现了差错

解决方案：

求助同学，查阅相关资料

4.统计文件

程序设计思路：

（1）首先输入文件名用“，”隔开，用到了“split”；

（2）将首字母变大写用到了数组的第一个位置，运用ASCLL代码，对首字母进行转化

 if (ch[0] >= 'a' && ch[0] <= 'z') {
			ch[0] = (char) (ch[0] - 32);
			s[x] = new String(ch);
			System.out.println("将首字母小写变成大写"+s[x]);
}

（3）再用一下“split”将“.”分隔开，并用数组形式c[x] = t[t.length - 1]，将各类型文件存放在c[x]中

（4）最后统计各类文件统计一下出现了多少次

问题：

最开始不知道如何用数组进行分配空间，怎样将各类文件存放在另一个数组中

原因：

对数组定义不够了解

解决方案

先寻问同学，没有解决，然后找了老师

5.类的设计

程序设计思路：

（1）先写出日期类，将年月日设置成int型

（2）设计一个职工类，该职工类至少具有下面的属性：职工号，姓名，性别，生日，工作部门，参加工作时间，设计toString方法。

（3）设计一个部门类，包括下列属性：部门编号，部门名称，经理，设计相应方法

（4）测试类，采用对象数组模拟一个拥有两个部门，10个职工的单位，实现对相关信息的查询功能

问题：

不知道如何输出两个部门

解决方案：

询问同学，然后用for循环将所需要，其中的具体情况的所对应部门的信息输出即可

（三）代码托管（务必链接到你的项目）https://gitee.com/hebau_java_cs16/java_CS02DRK