Java作业（2）

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

当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。分为两种形式，一种是有参数的构造函数，另一种是无参数的构造函数。在程序员没有给类提供构造函数的情况下，Java编译器会为这个类创建一个默认的无参构造函数。
Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。即使方法的名字相同，但是因为参数的传入类型数量不同，而产生不同的名字相同
Java不支持像C++中那样的复制构造函数，这个不同点是因为如果自己不写构造函数的情况下，Java不会创建默认的复制构造函数。

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

虽然定义了构造函数。但是没有定义无参的构造函数。只定义了有参数的构造函数，而进行无参创建。所以出现错误。

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应该是全局变量，没有加static

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

修改后
原代码比较的是地址，没有比较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中是如何实现封装性的？试举例说明。
封装性是面向对象编程中的三大特征之一,封装性就是把对象的成员属性和成员方法结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含如下两个含义。
(1)把对象的全部成员属性和全部成员方法结合在一起，形成一个不可分割的独立单位（即对象）
(2)信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界，只保留有限的对外接口是指与外部发生联系。

private String name;
     public String getName(){
         return name;
     } 
     public void setName(String n){
         name=n;
     }
     public String toString(){ 
         return "姓名:"+getName();
 public class Text{
      public static void main(String args[]){
      Person per=new Person(); 
      per.setName("Aony");
      System.out.printfln(per.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++);
    }
}

修改后

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;
    }
}
import java.util.Scanner;
public class Test{
    public static void main(String args[]){
        A a = new A();
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        for(int i=0;i<n;i++){
        	System.out.println(a.toString());
        	a.getSecret(a.getSecret()+1);
        }
    }
}

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

修改后

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 "编号：" + bookId + ", 书名：" + bookName + ", 价格为：" + 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。
单例模式：是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例
特点：
（1）实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
（2）灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。

public class Sun {
        private Sun (){}; 
        private static Sun mInstance = new Sun();  
        public static Sun getInstance(){  /
                return 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';
    }
}

运行结果：

理由：
ch[]储存到栈内存内，他的地址被公共属性change所占用，ch[0]被改变为‘W’；str存储到堆内存内，change调用的是str的副本，不能改变str的内容

实验思路
1.用面向对象思想完成评分系统
(1)创建选手类，建立似有成员编号姓名和成绩，同时创建类的构造方法，set，get方法。
(2)创建评分类，建立似有成员评委数量和评委，同时创建类的构造方法，set，get方法以及比较最高分最低分，还有分均值的方法。
(3)创建测试类，输入选手和评委数，建立选手数组类，和评分类。利用循环输入成员信息，评委分数，用类方法进行运算得出平均值。
(4)声明import java.util.Arrays;，利用Arrays方法来进行分数的排行。
2.Email验证
(1)在键盘输入所要验证的Email，首先查询是否有“@”和“."以及前者要在后者的前面。
(2)判断是否是以”@“开头。
(3)看结尾是不是以com，cn，net，gov，edu，org结尾。
3.查找子串
(1)首先从键盘输入整段字符串以及所要查询的子串
(2)查找子串，若出现++，然后从字符串后一位开始再次查询，知道返回值-1查询结束
(3)输出子串出现的次数
4.统计文件
(1)首先在键盘区域输入所要分类的文件名,以”，“分开。
(2)把所输入的字符串用split方法分开存入字符串数组。
(3)用两层循环，看文件内是否有重复，若有数量++，然后制”“，没有重复进行下一个
5..类的设计
(1)创建日期类，建立似有成员年月日，同时创建类的构造方法，set，get方法，以及tostring方法。
(2)创建管理类，建立似有成员部门编号，部门姓名及管理职位姓名，同时创建类的构造方法，set，get方法，以及tostring方法。
(3)创建职员类，建立似有成员编号，姓名，性别，部门姓名，生日，入职日期，同时创建类的构造方法，set，get方法，以及tostring方法。
(4)创建测试类，首先输入职工人数，以循环几次，输入第一个部门的名称人数以及经理名字。(此处因声明了两个部门，剩下的人为第二部分)依次输入员工信息
(5)利用tostring方法输出所有的信息

码云：https://gitee.com/hebau_java_cs16/java_cs02wgy/tree/master/ex02