java开发设计模式
java开发设计模式2
-
单例模式
是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。
package design.pattern;
public class Singleton {
private static Singleton singleton;
private Singleton() {}
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
singleton = new Singleton();
}
}
return singleton;
}
}
java开发中常用的几种设计模式及代码例子
-
工厂模式
根据需要返回我们的对象。应用比较熟悉的场景就是spring配置文件了。
package design.pattern;
public class MyFactory {
public static final int TYPE_MI = 1;// 大米
public static final int TYPE_YU = 2;// 油
public static final int TYPE_SC = 3;// 蔬菜
public static Food getFoods(int foodType) {
switch (foodType) {
case TYPE_MI:
return new DaMi();
case TYPE_YU:
return new You();
case TYPE_SC:
default:
return new ShuCai();
}
}
}
abstract class Food {
}
class DaMi extends Food {
}
class You extends Food {
}
class ShuCai extends Food {
}
java开发中常用的几种设计模式及代码例子
-
适配器模式
将一个类的接口转换成客户希望的另外一个接口。通俗地讲，就是在2个类之间做了一个衔接。比如你在调用A类的doSomething方法，实际上内部实现调用了B类的doSomething方法。
package design.pattern;
public class MyAdapter {
private MyAdapterImpl adapterImpl;
public MyAdapter(MyAdapterImpl myAdapterImpl) {
this.adapterImpl = myAdapterImpl;
}
public void doSomething() {
adapterImpl.doSomething();
}
public static void main(String args[]) {
new MyAdapter(new MyAdapterImpl()).doSomething();
}
}
class MyAdapterImpl {
public void doSomething() {
}
}
java开发中常用的几种设计模式及代码例子
-
代理模式
它的定义是：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。Java的反射机制，很多地方就用了代理模式来实现。
package design.pattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxyMain {
public static void main(String[] args) {
Person smallPerson = new Child();
Person proxyBuyHouse = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(),
new Class[] { Person.class }, new DynamicProxyHandler(smallPerson));
proxyBuyHouse.eat();
}
}
interface Person {
void eat();
}
class Child implements Person {
@Override
public void eat() {
// 小孩吃什么
System.out.println("eating");
}
}
class DynamicProxyHandler implements InvocationHandler {
private Object object;
public DynamicProxyHandler(final Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前日志监控");
Object result = method.invoke(object, args);
System.out.println("调用后日志监控");
return result;
}
}
java开发中常用的几种设计模式及代码例子
-
监听模式
当事件源触发某种行为，会自动执行事件监听器里面相应的方法。
Java监听模式右三个部分组成：事件源、事件对象、事件监听器。
package design.pattern;
public class ListenerTest {
public static void main(String[] args) {
MyListener myListener = new MyListener();
MyPerson person = new MyPerson();
person.addEatListener(myListener);
person.eat();
}
}
//事件源
class MyPerson{
private Listener listener;//监听器引用
//给事件源添加监听器
public void addEatListener(Listener listener) {
this.listener = listener;
}
public void eat() {
//吃了很多
if(listener != null) {
Event event=new Event() ;
event.setPerson(this);
listener.isThinking(event);//监听吃饭时，想了什么
}
}
}
//事件
class Event {
private MyPerson person;// 事件源的引用
public MyPerson getPerson() {
return person;
}
public void setPerson(MyPerson person) {
this.person = person;
}
}
interface Listener {
public void isThinking(Event event);
}
class MyListener implements Listener {
@Override
public void isThinking(Event event) {
System.out.println(" is isThinking many things !");
}
}
java开发中常用的几种设计模式及代码例子
-
装饰器模式
简单说就是不改变现有类的结构前提下，扩展它的功能。用别的类来增加原有类的功能。
package design.pattern;
public class MyDecorator {
public static void main(String[] args) {
Animal animal= new SmallDog(new Pet());
animal.eat();
}
}
interface Animal {
public void eat();
}
class Pet implements Animal {
@Override
public void eat() {
System.out.println("eat food");
}
}
class Dog implements Animal{
protected Animal animal;
public Dog(Animal animal) {
this.animal = animal;
}
@Override
public void eat() {
this.animal.eat();
}
}
class SmallDog extends Dog{
public SmallDog(Animal animal) {
super(animal);
}
public void eat() {
System.out.println("eat other food ");
this.animal.eat();
}
}
java开发中常用的几种设计模式及代码例子
java开发中常用的几种设计模式及代码例子
设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是对功能扩展开放，对修改代码关闭。系统扩展功能是，不需要修改原来的代码，只需新增代码便可。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，能使用父类的地方一定可以使用子类替代。 LSP是继承复用的基石，里氏代换原则是对“开-闭”原则的补充。
3、依赖倒转原则（Dependence Inversion Principle）
是开闭原则的基础，具体内容：实现接口编程，依赖于抽象类或接口而不依赖于具体类，系统功能扩展时可以使用具体类扩展。
4、接口隔离原则（Interface Segregation Principle）
使用多个隔离的接口，比使用单个接口要好，原则是：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。