黑马程序员——java-模式（工厂模式，单列模式，适配器模式）

———–android培训、java培训、java学习型技术博客、期待与您交流！————

1
设计模式：

模式定义：前人总结的一些经验和思想，给我们提供了从抽象到具体的方法

总共有23种

分类：
创建型-----创建对象
结构型-----对象的关系
行为型-----对象的作用

（1）
工厂设计模式：
把new对象的 动作封装在一个类中，通过该类得到对象。

代码体现：

Car类：

package moshi;

public class Car
{
    private String name;

    public Car(String name)
    {
        this.name = name;
    }

    public void run()
    {
        System.out.println(name + "---" + "动起来");
    }

}

CarFactory类：（此类中包装了，new Car的方法，用来初始化一个Car的对象）

package moshi;

public class CarFactory
{
    public CarFactory ()
    {

    }

    public static Car getCaar(String name)
    {
        return new Car(name);
    }

}

测试类：（因为在主类中执行new的动作，是非常消耗资源的）

package moshi;

public class CarText
{
    public static void main(String[] args)
    {
        Car car=CarFactory.getCaar("奔驰");
        car.run();
    }

}

(2)单例模式：

要求；类在内存中的对象只有一个

    A：让外界不能创建对象
         把构造方法私有化

               B：类本身要创建一个对象
         在成员变量位置创建一个类的对象

    C：对位提供一个方法去获得该对象
         提供一个公共的访问对象

单例模式的分类：

   饿汗式：随着类的加载就创建对象，因为对象是用static修饰的，对象的创建是在成员变量的位置

---

   懒汉式：只有在调用方法的那一刻，才创建对象，对象的创建是在提供对外方法的 那个方法体中



        饿汗式：

package sisuo;

class Phone
{
    private Phone()//私有构造方法，为的是不让外界创建对象
    {}

    private static Phone p=new Phone();//饿汗式，随着类的加载，对象就被创建
    //在成员位置创建对象，因为目的是保证该类在内存中只有一个对象
    //加static为的是，该对象可以被静态方法getPhone()方法所访问（因为静态只能访问静态）
    //加private ，是为了不让外界能直接访问，若不加private，外界接可以直接访问就可以这样改变
    // Phenoe.p=null;这样一来，p引用就失去了作用，
    public static Phone getPhone()//public 是提供一个可以被调用的方法，static静态修饰，为的是方便调用
    {
        return  p;
    }

    public void method()
    {
        System.out.println("method");
    }


}


public class danlimoshi
{
    public static void main(String[] args)
    {

        Phone p=Phone.getPhone();//创建Phone对象，
        //   static Phone p=new Phone();如果，Phone类的成员变量p，前边没有用private修饰，
        //则在用的时候，可能会出现这种情况
        //Phone.p=null;---则p引用就变成了垃圾

        p.method();
    }

}

懒汉式：

package sisuo;

class Phone
{
    private Phone()// 私有构造方法，为的是不让外界创建对象
    {
    }

    private static Phone p = null;

    public static Phone getPhone()
    {
        if (p == null)
        {
            p = new Phone();// 这是懒汉式创建对象，只有在用的时候才创建对象，
                            // 虽然也是静态修饰，但是静态修饰的方法，在类加载的时候，不执行方法体
        }
        return p;
    }

    public void method()
    {
        System.out.println("method");
    }

}

public class danlimoshi
{
    public static void main(String[] args)
    {

        Phone p = Phone.getPhone();// 创建Phone对象，
        // static Phone p=new Phone();如果，Phone类的成员变量p，前边没有用private修饰，
        // 则在用的时候，可能会出现这种情况
        // Phone.p=null;---则p引用就变成了垃圾

        p.method();
    }

}

    开发用：饿汗式
面试用：懒汉式

为饿汉式不会出现线程安全问题？
  分析为何出现线程安全问题
      A  存在多线程
      B  存在共享数据
      C  存在对共享数据有多条语句操作
   解决方案：在方法前加synchronized

   懒汉式还有一种延迟加载的思想（就是用的时候在在创建对象）
      --好处： 

  RunTime类就是单列模式的典型应用（饿汗式），

   RunTime t=RunTime.getRunTime();
   t.exec("notepad");//作用，通过调用exec方法可以打开Path中设置过的exec文件
   t.exec("calc")//打开计算器

（3）

适配器设计模式

  场景描述：
      接口：--接口Inter中有6个抽象方法
  普通类：--有一个方法method（Inter i）
  测试类：创建普通类的对象调用方法

---

  怎么实现：
      接口中有多个方法
  然后提供一个抽象类来实现该接口，并且提供的都是空实现
  在使用的时候，只需要重写要用的方法

实例：

接口类：
package adapterText;

 interface  Inter
{
     public abstract void method1();
     public abstract void method2();
     public abstract void method3();
     public abstract void method4();
     public abstract void method5();


}

普通类：
package adapterText;

public class putonglei
{

    public void f1(Inter i)
    {
        //System.out.println(i.method3());
        i.method3();
    }

}

测试类：
package adapterText;

public class Text
{
    public static void main(String[] args)
    {
        putonglei p1=new putonglei();
//      p1.f1(new Inter()
//      {
//          
//          @Override
//          public void method5()
//          {}
//          
//          @Override
//          public void method4()
//          {}
//          
//          @Override
//          public void method3()
//          {System.out.println("method3");}
//          
//          @Override
//          public void method2()
//          {}
//          
//          @Override
//          public void method1()
//          {}
//      });

        p1.f1(new adapt()
        {
            public void method3()
            {System.out.println("mehtod");}
        });//这一段代码，的匿名内部类，用的实现接口的抽象类（接口的字类）
        //这中间需要一个抽象类（adapt）来实现Inter接口，
    }

}

适配器类：
package adapterText;

public abstract class adapt implements Inter
{

    @Override
    public void method1()
    {}

    @Override
    public void method2()
    {}

    @Override
    public void method3()
    {}

    @Override
    public void method4()
    {}

    @Override
    public void method5()
    {}

}

———–android培训、java培训、java学习型技术博客、期待与您交流！————