黑马程序员__面向对象之封装

黑马程序员——面向对象之封装

-------android培训、java培训、期待与您交流！ ----------

1.      封装是面向对象的三大特征之一。指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部的信息，而是通过该类所提供的方法来实习对内部信息的操作和访问。简而言之，封装就是隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

2.      封装的好处：

（1）      将变化隔离

（2）      提高重用性

（3）      提高安全性

（4）      便于使用

3.      封装的原则：

将对象的属性和实现细节都隐藏起来，不允许外部直接访问；将方法暴露出来，让方法来控制对这些属性进行安全的访问和操作。

4.    封装的一种表现形式：private

private:表示私有的权限修饰符，用于修饰类中的成员包括成员变量和成员函数。私有只在本类中有效。

注意：将属性私有化以后，类以外即使建立了对象也不能直接访问，但可以通过对外提供的公共的访问方式访问该属性。

属性的封装：

（1）      把属性定义为私有的（private），只能在本类中访问。

（2）      为属性提供公共的（public）getter/setter方法。

 

class Person

{ 

       //将属性进行封装

       private String name;

       private int age;

       private String sex;

       //对外提供公共的访问方式

       public void setName(String name)

       {

              this.name=name;

       }

       public String getName()

       {

              return name;

       }

       public void setAge(int age)

       {

              this.age=age;

       }

       public int getAge()

       {

              return age;

       }

       public void setSex(String sex)

       {

              this.sex=sex;

       }

       public String getSex()

       {

              return sex;

       }

}

class  PersonDemo

{

       public static void main(String[] args) 

       {

              Person p=new Person();

              p.setName("Apple");

              p.setAge(18);

              p.setSex("女");

              System.out.println("name:"+p.getName());

              System.out.println("age:"+p.getAge());

              System.out.println("sex:"+p.getSex());

       }

}

5.      构造函数

（1）      定义：是指函数名与类名相同，且无返回值类型的声明。

（2）      特点：

函数名与类名相同；

不用定义返回值类型

不可以写return语句

对象一建立就会调用与之对应的构造函数

（3）      作用：给对象进行初始化

（4）      构造函数中定义的内容

当分析事物时，该事物存在具备一些特性或者行为，那么这些内部可以定义在构造函数中。

（5）构造函数与一般函数的区别：

写法上不同；

运行上不同：构造函数是在对象一建立就运行而一般函数是在对象调用时执行

一个对象建立，构造函数只运行一次；一般函数可被对象调用多次

（6）构造函数与构造代码块的区别：

构造函数用于给对应的对象初始化；而构造代码块用于给所用的对象进行统一初始化，构造代码块中用于定义不同对象共性的初始化内容。

<pre class="java" name="code">class Person

{ 

    private String name;

    private int age;

    //构造代码块

    {

           System.out.println("这是构造块！");

    }

    //构造方法

    Person()

    {

           System.out.println("这是无参构造方法");

    }

    Person(String name,int age)

    {

           System.out.println("这是带参构造方法");  

    }

 

}

class  PersonDemo

{

    public static void main(String[] args) 

    {

           Person p1=new Person();

           System.out.println("-----------------------2");

           Person p2=newPerson("Joe",18);

    }

}

 

6.      this关键字

含义：代表本类对象且代表它所在函数所属对象的引用。需要注意的是，类中的成员被使用都是通过对象，而本类对象就是this。

应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了本类对象，都用this表示。

           例如：给人定义一个用于比较年龄是否相同的功能

         

  public boolean compare(Person p)

           {

               //this表示调用此方法的当前本类对象

               return this.age==p.age;  

           }

this在构造函数间调用

class Person

{ 

           private String name;

           private int age;

           Person(){}

           Person(String name)

           {

               //this调用无参构造函数

               this();

               this.name=name;

           }

           Person(String name,int age)

           {

               //调用带一个参数的构造函数

               this(name);

               this.age=age;

           }

           

}

 

 

注意：this用于构造函数间的调用，一般函数是不能调用的；并且this语句只能定义在构造函数的第一行，因为初始化操作要先执行。

7.      static关键字

用法：表示静态的，只能用于修饰成员变量和成员函数的修饰符。当成员被静态所修饰

      就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用即

类名.静态成员。

       特点：

（1）      随着类的加载而加载，随着类的消失而消失

（2）      被所以对象所共享

（3）      优先于对象存在

（4）      可以直接被类名所调用

使用注意事项：

（1）      静态方法只能访问静态成员；非静态方法既可以访问静态也可以访问非静态成员

（2）      静态方法中不可以定义this,super关键字。因为静态是优先于对象存在的。

静态的好处：

       对对象的共享数据进行单独空间的存储，节省空间；

       可以用类名来直接调用，无需创建对象。

静态的弊端：

       生命周期过长；

       访问出现局限性。

静态的使用情况：

定义静态变量：当出现被多个对象所共享的数据时，该数据就可以被静态所修饰；而对象中的特有数据要定义成非静态的。

定义静态函数：当功能内部没有访问到非静态数据时，该功能可以被定义为静态的。

       静态代码块：

              格式：static{

                           静态代码块中的执行语句；

}

              特点：随着类的加载而执行，只执行一次。

8.      单例设计模式

含义:保证一个类在内存中只存在一个对象。

设计步骤：

（1）      将构造方法私有化

（2）      在类中创建一个本类对象

（3）      提供一个方法可以获取到该对象

饿汉式：

class Single1

{

       //构造函数私有化

       private Single1(){}

       //创建本类对象

       private static Single1 s=new Single1();

       //提供公共的方法获取对象

       public static Single1 getInstance()

       {

              return s;

       }

}

 

 

懒汉式：

class Single2

{

       //构造方法私有化

       private Single2(){}

       //声明一个本类对象

       private static Single2=null;

       //提供公共的方法来获取对象

       public static Single2 getInstance()

       {

              //判断对象是否为空，如果为空则实例化对象

              if(s==null)

                     s=new Single2();

              return s;

       }

}

 

 

懒汉式存在线程安全的问题，将其进行优化之后：

class Single2

{

       private Single2(){}

       private static Single2=null;

       public static Single2 getInstance()

       {

              //双重判断

              if(s==null)

              {

                     synchronized(Single2.class)

                     {

                            if(s==null)

                                   s=newSingle2();

                     }

              }

              return s;

       }

}

 

 

 

注意：在实际开发中建议使用恶汉式。

总结：一个类常常就是一个小的模块，我们应该只让这个模块公开必须让外界知道的内容，而隐藏其他一切内容。进行程序设计时，应尽量避免一个模块直接操作和访问另一个模块的数据，应当追求低耦合、高内聚。

 

-------android培训、java培训、期待与您交流！ ----------