Java学习笔记(13)--面向对象的封装性

一、面向对象的封装性

封装(encapsulation)又叫隐藏实现(Hiding the implementation)。就是只公开代码单元的对外接口，而隐藏其具体实现。比如手机，手机的键盘，屏幕，听筒等，就是其对外接口。你只需要知道如何按键就可以使用手机，而不需要了解手机内部的电路是如何工作的。封装机制就像手机一样只将对外接口暴露，而不需要用户去了解其内部实现。

在研究封装性之前，我们先来看一段代码：

package com.wz.classandobj;class Book{    String title;    double price;    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            Book book = new Book();            book.title = "Java开发";            book.price = -89.9;            book.getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

图书的名称：Java开发 图书的价格：-89.9
1

以上代码没有任何语法错误，却存在一个业务逻辑的错误，因为图书的价格不能为负数。造成这种情况的的原因在于：对象可以在一个类的外部直接访问属性。 
如何解决？我们需要将Book类中的属性设置为对外不可见（只能是本类访问），可以使用private关键字来定义属性。

修改之前的代码如下：

package com.wz.classandobj;class Book{    private String title;    private double price;    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            Book book = new Book();            book.title = "Java开发";            book.price = -89.9;            book.getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行：

Exception in thread "main" java.lang.Error: Unresolved compilation problems:     The field Book.title is not visible    The field Book.price is not visible    at com.wz.classandobj.TestDemo.main(TestDemo.java:16)
1
2
3
4
5
6

我们发现，在访问属性的时候，外部的对象无法再直接调用类中的属性了，此时就相当于Book类的属性对外部不可见。

但是，要想让程序可以正常运行，那么必须让外部可以操作Book类的属性。在Java开发中，针对属性有这样的定义，在类中定义的属性都要求使用private声明，如果属性需要被外部所使用，那么按照要求，定义属性相应的setter和getter方法，以Book类中的String title 为例： 
（1）setter方法是设置属性内容：

public void setTitle(String t)
1

主要：有参数。

（2）getter方法是取得属性内容:

public String getTitle()
1

注意：无参数。

范例：为Book类的封装属性设置setter和getter。

package com.wz.classandobj;class Book{    private String title;    private double price;    public String getTitle() {        return title;    }    public void setTitle(String title) {        this.title = title;    }    public double getPrice() {        return price;    }    public void setPrice(double price) {        this.price = price;    }    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            Book book = new Book();            book.setTitle("Java开发");             book.setPrice(-89.9);            book.getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

运行结果：

图书的名称：Java开发 图书的价格：-89.9
1
2

发现，图书的价格是负数，需要加入检查业务逻辑错误的代码，可以在setter中增加验证，如果值为正，赋值，否则为默认值0.0：

    public void setPrice(double price) {        if(price > 0.0){            this.price = price;        }    }
1
2
3
4
5

对于数据验证，在Java标准开发中应该由辅助代码完成。在实际开发中，setter往往只是简单的设置属性内容，getter只是简单的取得属性内容。

开发建议：以后在定义类的时候，所有的属性都要编写private封装，封装之后的属性如果需要被外部操作，则编写setter、getter。

二、类中的构造方法

先来看对象的产生格式：

①类名称 ②对象名称 = ③new ④类名称（）；
1

①类名称：规定了对象的类型。即：对象可以使用哪些属性和方法都是由类定义的； 
②对象名称：如果需要使用对象，需要有一个名称，这是一个唯一的标记； 
③new：分配新的堆内存空间； 
④类名称()：调用了名称和类名称相同的方法，这就是构造方法。

实际上，构造方法一直在被我们调用，但我们并没有去定义它，为什么能够使用呢？这是因为在整个Java开发中，为了保证程序可以正常执行，即便用户没有定义任何构造方法，也会在程序编译后自动为类增加一个没有参数，方法名称与类名称相同，没有返回值的构造方法。

构造方法的定义：方法名称和类名称相同，没有返回值声明。

    //无参，无返回值的构造方法    public Book() {    }
1
2
3
4

如果在Book类中没有定义以上的构造方法，那么也会自动生成一个无参，无返回值的构造方法。

我们再看：

package com.wz.classandobj;class Book{    //无参，无返回值的构造方法    public Book() {        System.out.println("无参构造方法");    }}public class TestDemo {        public static void main(String args[]) {            Book book = null;//声明对象        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行，什么也没有打印。 
在主方法中加入实例化对象的代码：

public class TestDemo {        public static void main(String args[]) {            Book book = null;//声明对象            book = new Book();//实例化对象        }}
1
2
3
4
5
6

运行：

无参构造方法
1

以上说明，构造方法是在对象使用关键字new实例化的时候被调用。

构造方法与普通方法最大的区别是： 
构造方法在实例化对象（new）的时候只调用一次，而普通方法是在实例化对象之后可以随意调用多次。

在实际开发中，构造方法的作用是在类对象实例化的时候设置属性的初始化内容，范例如下：

package com.wz.classandobj;class Book{    private String title;    private double price;    public Book(String title, double price) {        this.title = title;        this.price = price;    }    public String getTitle() {        return title;    }    public void setTitle(String title) {        this.title = title;    }    public double getPrice() {        return price;    }    public void setPrice(double price) {        this.price = price;    }    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            Book book = new Book("Java开发",89.9);//设置属性的初始化内容            book.getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

运行结果：

图书的名称：Java开发 图书的价格：89.9
1

如果一个类中已经明确定义了一个构造方法，则无参构造方法将不会自动生成。而且，一个类之中至少存在一个构造方法。另外，既然构造方法也属于方法，那么构造方法也可以重载，但是由于构造方法的特殊性，所以在构造方法重载时注意其参数的类型及参数的个数即可。

范例如下：

package com.wz.classandobj;class Book{    private String title;    private double price;    public Book() {        System.out.println("无参的构造方法");    }    public Book(String title) {        this.title = title;        System.out.println("有一个参数的构造方法");    }    public Book(String title, double price) {        this.title = title;        this.price = price;        System.out.println("有俩个参数的构造方法");    }    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            Book book1 = new Book();            book1.getInfo();            Book book2 = new Book("Java开发");            book2.getInfo();            Book book3 = new Book("Java开发",89.9);            book3.getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

运行结果：

无参的构造方法图书的名称：null 图书的价格：0.0有一个参数的构造方法图书的名称：Java开发 图书的价格：0.0有俩个参数的构造方法图书的名称：Java开发 图书的价格：89.9
1
2
3
4
5
6
7

在进行构造方法重载时有一个编写建议：所有重载的构造方法按照参数的个数由多到少，或者是由少到多排列。

我们再来看，如果在类中为属性直接设置默认值，结果会怎样？

package com.wz.classandobj;class Book{    private String title = "Android开发";    private double price = 199.9;    public Book() {        System.out.println("无参的构造方法");    }    public Book(String title) {        this.title = title;        System.out.println("有一个参数的构造方法");    }    public Book(String title, double price) {        this.title = title;        this.price = price;        System.out.println("有俩个参数的构造方法");    }    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            Book book1 = new Book();            book1.getInfo();            Book book2 = new Book("Java开发");            book2.getInfo();            Book book3 = new Book("Java开发",89.9);            book3.getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

运行结果：

无参的构造方法图书的名称：Android开发 图书的价格：199.9有一个参数的构造方法图书的名称：Java开发 图书的价格：199.9有俩个参数的构造方法图书的名称：Java开发 图书的价格：89.9
1
2
3
4
5
6
7

从上面可以发现：如果在类中为属性直接设置默认值，而且这个默认值是在构造方法执行完后才会设置的，且属性内容为对应数据类型的默认值时才设置类中定义的这个默认值。但是，要注意的是在构造方法没有执行之前，属性内容都是其对应数据类型的默认值。

三、类中的匿名对象

没名字的对象称为匿名对象，对象的名字按照之前的内存关系来讲，在栈内存之中，而对象的具体内容在堆内存之中保存，这样，没有栈内存指向堆内存空间，就是一个匿名对象。

范例：

package com.wz.classandobj;class Book{    private String title;    private double price;    public Book(String title, double price) {        this.title = title;        this.price = price;        System.out.println("有俩个参数的构造方法");    }    public void getInfo(){        System.out.println("图书的名称："+title+" 图书的价格："+price);    }}public class TestDemo {        public static void main(String args[]) {            //匿名对象            new Book("Java开发",89.9).getInfo();        }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

有俩个参数的构造方法图书的名称：Java开发 图书的价格：89.9
1
2

匿名对象由于没有对应的栈内存指向，所以只能使用一次，一次之后就将成为垃圾，并且等待被GC回收释放