java第二次作业

（一）学习总结

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

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

构造方法：构造方法的作用是初始化对象。构造方法的名称必须与类名称一致；构造方法的声明除不能有任何的返回值类型的声明；不能再构造方法中使用return返回一个值。
构造方法的重载：方法名称相同，参数的类型和个数不同。
此程序不能经过编译。
在一个类中如果已经明确的声明了一个构造方法，那么程序在编译时就不会在生成默认的构造方法，即一个类中应保证至少有一个构造方法。

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

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

value在此应该是全局变量，而在这里既没有表明是全局变量还是单一变量。所以出现错误，应该在value前面加上status。声明value是全局变量。

public class Test {
    public static void main(String[] args) {
        MyClass[] arr=new MyClass[3];
        System.out.println( arr[1].value);
        arr[1].value=100;
        System.out.println( arr[1].value);
    }
}
class MyClass{
    public status 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;
}

因为“”只能数值型的比较，而obj1，obj2是类的成员对象，用“”比较的是两个成员对象的地址。如果要比较应该是比较他们类中的value的数值。应该在obj1和obj2后面加上.value。

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

4.什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明。
封装性是指的把代码封装到大括号中,只能访问自己内部的数据,外边的用户访问不了.

class Time{
    private String time;
    public Time(){
    }
    public Time(String time){
        this.time=time;
    }
    public void settime(String time){
        this.time=time;
    }
    public String gettime(){
        return time    
    }
    public String toString(){
        return "时间”+time;
    }
}
import java.util.Scanner;
public class Test{
    public static void main(String args[]){
        Time a=new time() ;
        Scanner input=new Scanner(System.in);
        String time = new input.next();
        a.settime(time);
        System.out.println(a.toString);
    }
}

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的值加一，题中写的方法虽然是++。但不应该如此写。应该先用get方法取值，然后+1.

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

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

y是全局变量，而x未标明是全局变量，出现错误。应在x前面机上status。

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 num;
    static {
        num=1000;
    }
    public Book() {
        
    }
    public Book(String bookName,double price) { 
        this.bookName=bookName;
        this.price=price;
        this.bookId=num;
        num++;
    }
     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 int getbookId() {
        return bookId;
    }
    public void setbookId(int bookId) {
        this.bookId = bookId;
    } 
    public  static int totalBook() {
        int n;
        n=num-1000;
        return n;
    }
    public String toString() {          
        return "编号：\t" + bookId + ", 书名：\t" + bookName + ", 价格为：\t" + price;
    }
    
}

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。
单例模式：是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。
特点：通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

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

8.理解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
理由：java只支持参数传值的机制， 即方法得到的是所有参数值的一个副本，方法不能修改传递给它的任何参数变量的内容。change调用的是str的副本，不能改变str的内容.

（二）实验总结
1.用面向对象思想完成评分系统
程序设计思路：(1)创建一个选手类，基本属性有：编号，姓名，最终得分，定义构造方法，getter和setter方法，tostring方法。
(2)创建一个评分类，基本属性有：评委人数，评委给出的分数，定义构造方法，getter和setter'方法，分数输入方法，计算平均分。
(3)创建一个测试类，在测试类中创建选手对象，为每一位选手打分，所有选手评分完毕后，给出排行榜。
(4)声明import java.util.Arrays;，利用Arrays方法来进行分数的排行。
2.判断email是否有效。
程序设计思路：(1)判断@和.是否同时存在：把@和.当做两个字符串，用indexOf方法，如果找到了，则返回字符串指定的位置，否则返回-1。
(2)判断@是否在.之前：根据indexOf返回的值来进行比较。
(3)不能以@开头：就是返回的位置不能为0。
(4)以com|cn|net|gov|edu|org结尾 :用endwith方法。
3.找指定的字符串：用indexOf方法，找到返回他的位置，然后从他的位置加下一个字符串的长度来寻找下一个位置。
4.统计文件
(1)首先在键盘区域输入所要分类的文件名,以”，“分开。
(2)把所输入的字符串用split方法分开存入字符串数组。
(3)用两层循环，看文件内是否有重复，若有数量++，然后制”\0“，没有重复进行下一个
5..类的设计
(1)创建日期类，建立似有成员年月日，同时创建类的构造方法，set，get方法，以及tostring方法。
(2)创建管理类，建立似有成员部门编号，部门姓名及管理职位姓名，同时创建类的构造方法，set，get方法，以及tostring方法。
(3)创建职员类，建立似有成员编号，姓名，性别，部门姓名，生日，入职日期，同时创建类的构造方法，set，get方法，以及tostring方法。
(4)创建测试类，首先输入职工人数，以循环几次，输入第一个部门的名称人数以及经理名字。(此处因声明了两个部门，剩下的人为第二部分)依次输入员工信息
(5)利用tostring方法输出所有的信息
（三）代码托管（务必链接到你的项目）
https://gitee.com/hebau_java_cs16/Java_CS02ZRX/tree/master/ex2