Day3-3.30

（1）单件模式

设计模式中一种，它确保一个类有且只有一个对象。

解决方法：将类的构造方法封装起来，这样在类的外部无法实例化这个对象；在类的内部用静态属性方式定义该类的一个声明；提供一个静态方法完成单件逻辑，即当静态类声明没有引用对象实例化类对象，而在引用一个类对象时，返回该对象的引用。

优点：保证一个类有且仅有一个实例；提供某个对象的全局访问点。

缺点：只考虑对象的创建管理，没有考虑销毁的管理，也不支持对象序列化。

 

代码：（加粗为关键代码）

package com.resource;//单件模式

public class FitghterPlane {
       private String name;
       private int missileNum;
       private static FighterPlane fp;
       private FighterPlane(String _name,int _missileNum){
       name=_name;
       missileNum=_missileNum;
       }
       public static FighterPlane getInstance(Dtring _name,int _missileNum){
             if(fp=null){
             fp=new FighterPlane(_name,_missileNum);
             }
       return fp;
    }
      public void fire(){
             if(missileNum>0){
             System.out.println("now fire a missile!");
             missileNum-=1;
             }
             else{
                   System.out.println("no missile left!");
            }
         }
      }

package com.run;
import com.resource.*;
       public class RunPlane {
       public static void main(String args[]){
             FighterPlane fp;
             fp=FighterPlane.getInstance("苏35",6);
             fp.fire();
             }
        }

 

 

（2）消息

在面向对象的语言中，程序=对象+消息

当fp作为A对象的属性时，且具备了发送消息的条件后，A对象就有了对FighterPlane对象的访问权限。A对象就可以像FighterPlane对象发送消息------控制FighterPlane对象产生相应的操作。即FighterPlane对象能被A所访问。同理，当FighterPlane中也有A对象的引用时，它也可以向A对象发送消息，控制A对象产生相应的操作。它们之间就存在双向关联关系。
代码举例：

package message;

public class FighterPlane {

           String name;
           int missileNum;
           public FighterPlane(String _name,int _missileNum){
                   name=_name;
                   missileNum=_missileNum;
                   }
           public void fire(){
                    if(missileNum>0){
                         System.out.println("now fire a missile!");
                         missileNum-=1;
                    }
                    else{
            System.out.println("No missile left!");
                    }
              }
 }

package message;

public class A {
         FighterPlane fp;
         public A(FighterPlane fpp){
                   this.fp=fpp;//A对象中拥有了FighterPlane对象的引用
         }
        public void invoke(){
        //A对象发送消息给FighterPlane的对象
        System.out.println(fp.name);
     }
}

package message;

public class run {

          public static void main(String[] args){
                     FighterPlane ftp=new FighterPlane("su35",10);
                     //产生A对象，并将ftp作为对象引用传入
                     A a=new A(ftp);
                     //发送消息，产生调用关系
                     a.invoke();

      }

}

 

 

 

（3）封装与访问权限，继承

   较简单，略