黑马程序员——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学习型技术博客、期待与您交流！————