一、抽象类与适配器模式
在接口与这个类中间可以加一个抽象类:
抽象类去覆写接口中的全部方法,而那个类去继承这个抽象类,根据需要覆写抽象类中的方法。(简单的适配器模式)
interface Eat{
public void eatBread();
public void eatApple();
public void eatBanana();
}
abstract class PersonEat implements Eat{
public void eatBread(){
}
public void eatApple(){}
public void eatBanana(){}
}
class Person extends PersonEat{
public void eatBread(){
System.out.println("我在吃面包");
}
public void eatApple(){
System.out.println("我在吃苹果");
}
}
public class Demo02 {
/**
* @param args
*/
public static void main(String[] args) {
Person p=new Person();
p.eatBread();
p.eatApple();
}
}
二、单态模式和简单工厂模式
class Single{
private Single(){}
private static final Single s1=new Single();
public static Single getSingleInstance(){
return s1;
}
public void Say(){
System.out.println("我开始说话了。。。。");
}
}
public class SingletonDemo {
public static void main(String[] args) {
Single s=Single.getSingleInstance();
s.Say();
}
}
interface Car{
public void run();
public void stop();
}
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
class Toyota implements Car{
public void run(){
System.out.println("Toyota开始启动了。。。");
}
public void stop(){
System.out.println("Toyota停车了。。。。");
}
}
class Factory{
public static Car getCarInstance(String type){
Car c=null;
try {
c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return c;
}
}
public class FactoryDemo03 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Toyota");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}
三、工厂方法模式
abstract interface AbstractFactory
{
}
class CarFactory implements AbstractFactory
{
public Car getCar(String type)
{
Car c = null;
try {
c = (Car)Class.forName("org.jzkangta.factorydemo02." + type).newInstance();
}
catch (InstantiationException e) {
e.printStackTrace();
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
return c;
}
}
class BusFactory implements AbstractFactory
{
public Car getBus(String type)
{
Car c = null;
try {
c = (Car)Class.forName("org.jzkangta.factorydemo02." + type).newInstance();
}
catch (InstantiationException e) {
e.printStackTrace();
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
return c;
}
}
四、抽象工厂模式
//NWFactory-->女娲
interface NWFactory{
public Person getPerson(String type);
public Animal getAnimal(String type);
}
//阳绳-->用来造男人和雄性动物(Bull)
class YangSheng implements NWFactory{
Man m=null;
Bull b=null;
public Man getPerson(String type){
try {
m=(Man)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return m;
}
public Bull getAnimal(String type){
try {
b=(Bull)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return b;
}
}
//阴绳-->用来造女人和雌性动物(Cow)
class YinSheng implements NWFactory{
Woman w=null;
Cow c=null;
public Woman getPerson(String type){
try {
w=(Woman)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return w;
}
public Cow getAnimal(String type){
try {
c=(Cow)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return c;
}
}
五、代理模式(proxy)
静态代理
abstract class SaleComputer{
abstract public void SaleComputer();
}
//真实的主题角色(ComputerMaker)
class ComputerMaker extends SaleComputer{
public void SaleComputer(){
System.out.println("卖出了一台电脑。。。");
}
}
//代理的主题角色(ComputerProxy)
class ComputerProxy extends SaleComputer{
ComputerMaker cm=null;
public void youHui(){
System.out.println("我给你优惠....");
}
public void giveMouse(){
System.out.println("我还送你一个鼠标。。。");
}
public void SaleComputer(){
youHui();
giveMouse();
if(cm==null){
cm=new ComputerMaker();
}
cm.SaleComputer();
}
}
public class ProxyDemo {
public static void main(String[] args) {
//SaleComputer sc=new ComputerMaker();
SaleComputer sc=new ComputerProxy();
sc.SaleComputer();
}
}
动态代理
public interface SaleComputer {
public void sale(String type);
}
public class ComputerMaker implements SaleComputer {
public void sale(String type) {
System.out.println("卖出了一台"+type+"电脑");
}
}
public class ComputerProxy {
public static SaleComputer getComputerMaker(){
ProxyFunction pf=new ProxyFunction();
return (SaleComputer)Proxy.newProxyInstance(ComputerMaker.class.getClassLoader(), ComputerMaker.class.getInterfaces(), pf);
}
}
public class ProxyFunction implements InvocationHandler {
private ComputerMaker cm;
public void youHui(){
System.out.println("我给你一些优惠。。。");
}
public void giveMouse(){
System.out.println("我还要送你一个鼠标。。。 ");
}
public Object invoke(Object arg0, Method arg1, Object[] arg2)
throws Throwable {
String type=(String)arg2[0];
if(type.equals("联想")||type.equals("三星")){
if(cm==null){
cm=new ComputerMaker();
youHui();
giveMouse();
arg1.invoke(cm, type);
}
}else{
System.out.println("我没有你要的这个牌子的电脑。。。。");
}
return null;
}
}
六、策略模式(Strategy)
对算法的包装,把使用算法和算法本身分开,委派给不同的对象管理。
//抽象的策略角色
public abstract class Operation {
public abstract void oper(float a,float b);
}
public class Add extends Operation{
public void oper(float a,float b){
float result=a+b;
System.out.println("相加的结果为-->"+result);
}
}
public class Calc {
private Operation o;
public final static Operation add=new Add();
public final static Operation jian=new Jian();
public final static Operation cheng=new Cheng();
public final static Operation chu=new Chu();
public void oper(float a,float b){
o.oper(a, b);
}
}
七、门面模式(Facade)
1.为一个复杂的子系统提供一个简单的接口。
2.仅仅通过门面通信,简化层次之间的依赖。
八、建造模式(Builder)
建造模式是对象的创建模式,可以讲一个产品的内部表象与产品的生成过程分割开来,从而可以使一个建造过程生成具有不同的内部表象的产品
九、模板模式(Template)
准备一个抽象类,将部分逻辑以具体方法的形式实现,然后申明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法,从而对剩余的逻辑有不同的实现。
public abstract class Template {
protected String pcType;
public Template(String pcType){
this.pcType=pcType;
}
//留给子类去实现的基本方法1
abstract protected void makeCPU(String pcType);
//留给子类去实现的基本方法2
abstract protected void makeMainBorad(String pcType);
//留给子类去实现的基本方法3
abstract protected void makeHD(String pcType);
//基本方法,已经实现好了
public final void makeOver(String pcType){
System.out.println(pcType+"造好了");
}
//模板方法,造电脑
public final void makePC(){
makeCPU(pcType);
makeMainBorad(pcType);
makeHD(pcType);
makeOver(pcType);
}
}
public class PC extends Template{
public PC(String pcType) {
super(pcType);
// TODO Auto-generated constructor stub
}
@Override
protected void makeCPU(String pcType) {
// TODO Auto-generated method stub
System.out.println(pcType+"的CPU造好了");
}
@Override
protected void makeHD(String pcType) {
// TODO Auto-generated method stub
System.out.println(pcType+"的硬盘造好了");
}
@Override
protected void makeMainBorad(String pcType) {
// TODO Auto-generated method stub
System.out.println(pcType+"的主板造好了");
}
}