JAVA混型和潜在类型机制

时间：2016-07-24 16:17:29 阅读：567 评论：0 收藏：0 [点我收藏+]

标签：

一、混型

①、定义

二、利用JAVA如何实现混型

①、代理 ②、装饰器模式 ③、动态代理模式

三、潜在类型机制

①、定义

四、JAVA的潜在类型机制的补偿

①、利用反射

回答：

一、混型

就是一个类混合了多个类的能力。当想在混型类中修改某些东西，这些修改会应用于混型的所有类型上。

二、实现混型

①、代理机制

步骤：1、创建混型接口 2、创建接口的具体实现 3、创建混型类，类中持有混型。

首先创建混型接口

public interface Fly{
    void fly();
}

Fly

其次，创建接口的具体实现

public Swing implements Fly{
    public void fly(){
      System.out.println("I can use swing to fly"); 
    }
}

Swing

最后创建具体混型类

public class Duck implements Fly{
    private Swing mSwim = new Swing();
    
    public void fly(){
        mSwim.fly();
    }
    
    public void swim(){
        System.out.println("I can swim");
    }
}

Duck

缺点：当使用复杂的混型，代码量会急剧上升。

②、装饰器模式

步骤：1、创建被装饰对象（可以是类也可以是接口，最好是接口这里我用的是接口） 2、创建被装饰对象继承装饰接口 3、创建装饰器（装饰器中包含装饰对象）

1、创建装饰接口

public interface Basket {
    void show();
}

Basket

2、继承装饰接口，为被装饰对象

public class Original implements Basket{

    @Override
    public void show() {
        // TODO Auto-generated method stub
        System.out.println("I am a Basket");
    }

}

Original

3、创建装饰器(Apple,Banana,Orange)

public class AppleDecorator implements Basket{
    private Basket mBasket;
    public Apple(Basket basket) {
        // TODO Auto-generated constructor stub
        mBasket = basket;
    }
    @Override
    public void show() {
        // TODO Auto-generated method stub
        mBasket.show();
        System.out.println("Apple");
    }
}

AppleDecorator

public class BananaDecorator implements Basket{
    private Basket mBasket;
    public Banana(Basket basket) {
        // TODO Auto-generated constructor stub
        mBasket = basket;
    }
    @Override
    public void show() {
        // TODO Auto-generated method stub
        mBasket.show();
        System.out.println("Banana");
    }
}

BananaDecorator

其他略

4、使用装饰器

public class Main {
    public static void main(String[]args){
        Original original = new Original();
        Basket basket = new Apple(new Banana(new Orange(original)));
        basket.show();
    }
}

Main

缺点：只有效作用于装饰的最后一层。

③、动态代理

步骤：1、创建接口 2、创建接口的具体实现 3、创建Proxy类 4、使用Proxy类

①、创建接口

public interface Business {
    void doSomething();
    void doSomeElse();
}

Business

②、实现接口

public class RealObject implements Business{

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        printf("Do some better things");
    }

    @Override
    public void doSomeElse() {
        // TODO Auto-generated method stub
        printf("Anything i can do it");
    }
    
    public static void printf(String str){
        System.out.println(str);
    }

}

RealObject

③、创建代理类

public class BusinessProxy implements InvocationHandler{
    private Object mData;
    public BusinessProxy(Object dataObject) {
        // TODO Auto-generated constructor stub
        mData = dataObject;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("No one thing I can do");
        return method.invoke(mData, args);
    }
}

BusinessProxy

④、启动代理

public class Main {
    public static void main(String[] args){
        RealObject object = new RealObject();
        Business proxy = (Business)Proxy.newProxyInstance(Business.class.getClassLoader(), new Class[]{Business.class},new BusinessProxy(object));
        proxy.doSomething();
    }
}

Main

Android潜在类型机制

1、什么叫做潜在类型机制

在C++和python中，可以不知道当前类的类型，就可以调用方法。

2、JAVA如何补偿（反射机制）

步骤 1、建立两个类，其有相同的方法

public class TypeOne {
    private int data = 1;
    
    public void setData(int data){
        this.data = data;
    }
    
    public int getData() {
        return data;
    }
}

TypeOne

public class TypeTwo {
    private int data = 2;
    public void setData(int data){
        this.data = data;
    }
    
    public int getData(){
        return data;
    }
}

TypeTwo

2、利用反射调用，相同的方法

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TypeOne typeOne = new TypeOne();
        TypeTwo typeTwo = new TypeTwo();
        //调用反射方法，实现不同类可以通过一个方法调用相同的方法
        getData(typeOne);
        getData(typeTwo);
    }
    
    //实现反射的方法
    public static void getData(Object type){
        Class<?> c = type.getClass();
        try {
            //获取叫做getData()的方法
            Method method = c.getMethod("getData");
            //调用该方法
            int data = (int) method.invoke(type,null);
            //输出
            System.out.println(type.getClass().getSimpleName()+"  data:"+data);
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Main

JAVA混型和潜在类型机制

标签：

原文地址：http://www.cnblogs.com/rookiechen/p/5700795.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行