（一）学习总结

（1）什么是构造方法？

在之前，实例化一个对象后，如果要为这个对象中的属性赋值，则必须用setter方法为属性分别赋值才可以，构造方法就是在对象实例化的时候就直接把对象的值赋给属性，那这个构造方法的主要作用就是为类中的属性初始化。构造方法必须要满足这几点：
<1>构造方法的名称必须与类名称一致。
<2>构造方法的声明处不能有任何返回值类型的声明。
<3>不能再构造方法中使用return返回值。
<4>用户不能直接调用

class 类名称{
    访问权限  类名称（类型1，参数1，类型2，参数2）{
        程序语句；
            ...      //构造方法没有返回值
    }
}

（2）什么是构造方法的重载？
构造方法的重载就是方法名相同，而参数个数和类型不同，调用时，会自动相应的构造方法。
（3）下面的程序是否可以通过编译？为什么？

public class Test {
    public static void main(String args[]) { 
       Foo obj = new Foo();       
    }     
}
class Foo{
    int value;
    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;
}

出错，程序没有实现实例化，应该为：

    public class Test {
    public static void main(String[] args) {
        MyClass[] arr=new MyClass[3];
        for（int i=0;i<3;i++）{
            MyClass[i] arr= new MyClass();

}
arr[1].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;
}

出现flase，最后比较的是地址，两个地址不同。

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

封装性是面向对象的第一大特性，所谓的封装性就是指对外部不可见。 为了避免出现 用对象直接访问类中的属性 这样的错误发生，（这在面向对象中是不允许的），在一般 的开发中往往要将类中的属性封装（private），属性封装：private 属性类型 属性名称；方法封装： private 方法返回值 方法名称（参数列表）{} 类中全部属性都必须封装，封装后的属性必须通过setter和getter进行访问（也就是通过这两种方法设置和取得）。用private声明的属性或方法只能在其类内部被调用，而不能在类的外部被调用。

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是私有属性，所以不能直接调用。

（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属性。

6.使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从1000开始，每产生一个对象，则编号自动递增（利用静态变量和构造方法实现）。下面给出测试类代码和Book类的部分代码，将代码补充完整。

class Book{
    int bookId;
    String bookName;
    double price;
    static int Id,totalBook;// 声明静态变量

    static{
        totalBook=0;
        Id=1000;
    }//定义静态代码块对静态变量初始化

    public Book(String bookName,double price) {
        Id++;
        this.bookName=bookName;
        this.price=price;
        bookId=Id;
        totalBook++;
    }//构造方法

     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() {
        return totalBook;
    }//定义方法求图书总册数

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

码云提交历史截图