java基础面向对象之封装

2017-01-15

封装

　　　　1）封装性就是保证类内部被外部类不可见

　　　　2）所有属性都必须使用private关键字声明

　　　　3）封转后的属性如果要被外部所访问就必须实现set和get方法

例如：

　　使用了private声明的属性只有在自己的类是可见的

 1 class Book{
 2     private String title ;    //使用private声明的属性
 3     private int price ;
 4 }
 5 public class PrivateDemo1 {
 6     public static void main(String[] args) {
 7         Book bk = new Book () ;
 8         bk.title = "java基础" ;    //使用了private声明的属性只有在自己的类是可见的
 9         bk.price = 89.9 ;
10     }
11 }

如果想要让我们的程序正常使用，那么必须要想办法让外部的程序去操作类的属性才可以。

在类中所有的属性都要求使用private关键字来声明，如果属性需要被外部所使用，那么需要定义相应的set和get方法。

setter方法：设置属性内容

1     public void setTitle(String title) {
2         this.title = title;
3     }

getter方法：取得设置的属性内容

    public String getTitle() {
        return title;
    }

构造方法

对象的产生格式：1类名称  2对象名称  =  3new  4类名称（） ；

　　　　　　类名称：规定了对象的类型，就是规定了对象属于那个类的实例(可以使用那些属性或方法)

　　　　　　对象名称：如果想要使用对象，就需要有一个名字，这个对象名是唯一的

　　　　　　new： 开辟新的对内存空间，如果没有new关键字对象是无法被实例化的

　　　　　　类名称（）：调用了一个和类名称一样的方法，这个方法就称为构造方法

java为了保证程序的正常执行，那么在程序的编译之后为类里增加一个无参数的构造方法。

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

 1 class Person{
 2     public Person() {    //无参构造方法
 3         System.out.println("**********");
 4     }
 5 }
 6 public class PrivateDemo2 {
 7     public static void main(String[] args) {
 8         Person p = null ;//声明对象
 9         p = new Person() ; //实例化对象
10         /**
11          * 实例化对象的时候会调用构造方法
12          */
13     }
14 }

所有的构造方法都在使用关键字new实例化的时候被默认调用。

构造方法与普通的方法最大的区别

　　构造方法是在实例化对象的时候只调用一次。

　　普通方法是在实例化对象之后，可以随意调用多次

构造方法的核心作用，在类对象实例化的时候设置属性初始化内容。构造方法是为属性初始化准备的。

如果一个类中已经明确的定义了一个构造方法，那么自动生成的无参的构造方法将不会自动生成默认的构造方法。一个类中至少保留一个构造方法。

 1 class Person{
 2     private String name ;
 3     private int age ;
 4     public Person(String n , int a) {    //无参构造方法
 5         name = n ;
 6         age = a ;
 7         System.out.println("**********");
 8     }
 9     public String getName() {
10         return name;
11     }
12     public void setName(String name) {
13         this.name = name;
14     }
15     public int getAge() {
16         return age;
17     }
18     public void setAge(int age) {
19         this.age = age;
20     }
21
22 }
23 public class PrivateDemo2 {
24     public static void main(String[] args) {
25         Person p = null ;//声明对象
26         p = new Person("zhangsan" ,30) ; //实例化对象
27         /**
28          * 实例化对象的时候会调用构造方法
29          */
30     }
31 }　　　　构造方法的核心作用：在类对象实例化的时候为属性设置初始化

构造方法的重载

　　既然构造方法也属于方法的一种，那么构造方法也是可以重载的。

 1 class Person1{
 2     private String name ;
 3     private int age ;
 4     public Person1(){
 5         System.out.println("没有参数的构造方法    ");
 6     }
 7     public Person1(String n){
 8         System.out.println("有一个参数的构造方法");
 9     }
10     public Person1(String name , int age){
11         System.out.println("有两个参数的构造方法");
12     }
13 }

　　匿名对象

真实的信息都保存在堆内存之中，如果栈指向的对象就称为匿名对象。

 1 class Person2{
 2     private String name ;
 3     private int age  ;
 4     public void info(){
 5         System.out.println("匿名方法调用");
 6     }
 7 }
 8 public class PrivateDemo4 {
 9     public static void main(String[] args) {
10         new Person2().info() ;//匿名对象调用info（）方法
11         /**
12          * 没有栈内存引用的对象就是匿名对象
13          */
14     }
15 }

　　匿名对象由于没有其他对象的引用，所以匿名对象只能使用一次。

总结：1、构造方法的定义要求：方法名与类名完全相同，且无返回值。2、构造方法是在类对象在实例化的时候调用的3、一个类之中必须保留有一个构造方法，如果没有明确定义一个构造方法那么会自动生成一个无参的什么也不做的构造方法。4、构造方法的核心是类对象在实例化的时候为类中的属性初始化。5、构造方法重载时只要求考虑参数的个数及类型。6、匿名对象只可以使用一次。