单例模式
设计原则:
- 1.单一职责原则:
- 又称单一功能原则。所谓职责是指类变化的原因。如果一个类有 多于一个的动机被改变,那么这个类就具有多于-一个的职责。
- 而单一-职责原则就是指一 一个类或者模块应该有且只有一个改变的原因。
- 2.开放封闭原则:
- 是所有面向对象原则的核心。其核心的思想是:软件实体应该是可扩展,而不可修改的。
- 也就是说,对扩展是开放的,而对修改是封闭的。主要体现在两个方面:
- -对扩展开放,意味着有新的需求或变化时,可以对现有代码进行扩展,以适应新的情况。
- -对修改封闭,意味着类一旦设计完成 ,就可以独立完成其工作,而不要对类进行任何修改。
- 3.依赖倒置原则:
- 是程序要依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程,
- 不要对实现进行编程,这样就降低了客户与实现模块间的耦合。主要体现在两方面:
- -高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象。
- -抽象不应该依赖于具体实现,具体实现应该依赖于抽象。
- 4.接口隔离原则:
- 使用多个专门的接口比使用单一的总接口要好,一个类对另外一个类的依赖性应当
- 是建立在最小的接口上的,一个接口代表一个角色,不应当将不同的角色都交给一个接口。
- 5.里氏代换原则:
- 使用多个专门的接口比使用单一的总接口要好,一个类对另外一个类的依赖性应当是建立在最小的接口上的,
- 一个接口代表一个角色,不应当将不同的角色都交给一个接口。使用多个专门的接口比使用单一的总接口要好,
- 一个类对另外一个类的依赖性应当是建立在最小的接口上的,一个接口代表一个角色,不应当将不同的角色都交给一个接口。
饿汉式
public class Singleton1 {
private Singleton1() {}
private static final Singleton1 single = new Singleton1();
public static Singleton1 getInstance() {
return single;
}
}
懒汉式
package cn.iceson.singlen;
public class SingleTon {
protected double d=Math.random();
private static SingleTon singleTon=null;
private SingleTon(){
}
public static SingleTon singleTon2(){
if (singleTon==null) {
singleTon=new SingleTon();
}
return singleTon;
}
}
工厂模式
简单工厂模式
Car.java
package cn.iceson.factory.jd;
public abstract class Car {
public abstract void drive();
}
class Bike extends Car{
@Override
public void drive() {
System.out.println("骑自行车!");
}
}
class Bus extends Car{
@Override
public void drive() {
System.out.println("开公共汽车!");
}
}
Factory.java
package cn.iceson.factory.jd;
public class Factory {
static Car car=null;
public static Car product(int i) {
switch (i) {
case 1:
car=new Bike();
break;
case 2:
car=new Bus();
break;
default:
break;
}
return car;
}
}
Test.java
package cn.iceson.factory.jd;
public class Test {
public static void main(String[] args) {
Car car=Factory.product(1);
car.drive();
}
}
工厂方法模式
Car.java
package cn.iceson.factory.ff;
public abstract class Car {
public abstract void drive();
}
class Bike extends Car{
@Override
public void drive() {
System.out.println("骑自行车!");
}
}
class Bus extends Car{
@Override
public void drive() {
System.out.println("开公共汽车!");
}
}
FactoryMethod.java
package cn.iceson.factory.ff;
public abstract class FactoryMethod {
public abstract Car product();
}
class BikeFactory extends FactoryMethod{
@Override
public Car product() {
return new Bike();
}
}
class BusFactory extends FactoryMethod{
@Override
public Car product() {
return new Bus();
}
}
Test.java
package cn.iceson.factory.ff;
public class Test {
public static void main(String[] args) {
FactoryMethod factoryMethod= new BikeFactory();
Car car=factoryMethod.product();
car.drive();
}
}
抽象工厂模式
Car.java
package cn.iceson.factory.cx;
public abstract class Car {
public abstract void drive();
}
class Bus extends Car{
@Override
public void drive() {
System.out.println("开走汽车");
}
}
Chairs.java
package cn.iceson.factory.cx;
public abstract class Chairs {
public abstract void shape();
}
class CarChairs extends Chairs{
@Override
public void shape() {
System.out.println("汽车椅子!");
}
}
Wheel.java
package cn.iceson.factory.cx;
public abstract class Wheel {
public abstract void run();
}
class CarWheel extends Wheel{
@Override
public void run() {
System.out.println("汽车轮子!");
}
}
Factory.java
package cn.iceson.factory.cx;
public abstract class Factory {
public abstract Chairs productChairs();
public abstract Wheel productWheel();
public abstract Car productCar();
}
class CarFactory extends Factory{
@Override
public Chairs productChairs() {
return new CarChairs();
}
@Override
public Wheel productWheel() {
return new CarWheel();
}
@Override
public Car productCar() {
return new Bus();
}
}
代理模式
Subject.java
package cn.iceson.proxy;
public abstract class Subject {
public abstract void operate();
}
class RealSubject extends Subject{
@Override
public void operate() {
System.out.println("operate...");
}
}
Porxy.java
package cn.iceson.proxy;
public class Proxy extends Subject{
Subject subject;
public Proxy(){
}
public Proxy(Subject subject) {
this.subject=subject;
}
@Override
public void operate() {
System.out.println("before...");
subject.operate();
System.out.println("after...");
}
}
Test.java
package cn.iceson.proxy;
public class Test {
public static void main(String[] args) {
Subject subject=new RealSubject();
Proxy proxy=new Proxy(subject);
proxy.operate();
}
}
观察者模式
Visitor.java
package cn.iceson.observer;
public abstract class Visitor {
public abstract void update();
}
class Protector extends Visitor{
@Override
public void update() {
System.out.println("保护运钞车");
}
}
class Thief extends Visitor{
@Override
public void update() {
System.out.println("准备动手");
}
}
TransferCar.java
package cn.iceson.observer;
import java.util.ArrayList;
import java.util.List;
public abstract class TransferCar {
public abstract void add(Visitor visitor);
public abstract void delete(Visitor visitor);
public abstract void notice();
}
class TransferCarMoney extends TransferCar{
List<Visitor> list=new ArrayList<Visitor>();
@Override
public void add(Visitor v) {
list.add(v);
}
@Override
public void delete(Visitor v) {
list.remove(v);
}
@Override
public void notice() {
for (Visitor visitor : list) {
visitor.update();
}
}
}
Test.java
package cn.iceson.observer;
public class Test {
public static void main(String[] args) {
Visitor p=new Protector();
Visitor t=new Thief();
TransferCar tc=new TransferCarMoney();
tc.add(p);
tc.add(t);
tc.notice();
}
}
适配器模式
Adaptee.java
package cn.iceson.adapter;
public class Adaptee {
public void operate1(){
System.out.println("普通接口");
}
}
Target.java
package cn.iceson.adapter;
public interface Target {
public abstract void operate1();
public abstract void operate2();
}
Adapter.java
package cn.iceson.adapter;
public class Adapter extends Adaptee implements Target{
@Override
public void operate2() {
System.out.println("特殊接口");
}
}
Test.java
package cn.iceson.adapter;
public class Test {
public static void main(String[] args) {
Adapter adapter=new Adapter();
adapter.operate1();
adapter.operate2();
}
}