1、upperBound(Type t)方法

/**
     * The "rvalue conversion".
     * The upper bound of most types is the type itself.  Wildcards, on the other hand have upper and lower bounds.
     * @param t a type
     * @return the upper bound of the given type
     */
    public Type upperBound(Type t) {
        return upperBound.visit(t);
    }
    // where
    private final MapVisitor<Void> upperBound = new MapVisitor<Void>() {

        @Override
        public Type visitWildcardType(WildcardType t, Void ignored) {
            if (t.isSuperBound())
                return t.bound == null ? syms.objectType : t.bound.bound;
            else
                return visit(t.type);
        }

        @Override
        public Type visitCapturedType(CapturedType t, Void ignored) {
            return visit(t.bound);
        }
    };

举个例子,如List<?>或者List<? super InputStream>时,这个WildcardType的isSuperBound()返回都为true,如果为List<?>,那么上界为Object类型,否则就是类声明的上界。查看List的实现,如下:

public interface List<E> extends Collection<E> {
   // ...
}  

那么bound类型为E,bound.bound为Object。如果为List<? super X>时,如下:

public class Test<X> {
	public void test() {
		List<? super X> x;
	}
}

那么bound类型为TypeVar,则TypeVar的bound为X的bound  

如果为List<? extends InputStream>或List<? extends X>时会调用visit(t.type),而这个type类型就是InputStream(ClassType类型)或者X(TypeVar类型)来继续查找上界。举个例子如下:

public class Test<X extends InputStream> {
	public void test(){
		List<? extends X> x = new ArrayList();
		x.add(null);
	}
}

这时候传入方法的t参数如下:

调用visit(t.type)后会返回TypeVar类型,如果为CapturedType,那么就访问upperBound实例中的visitCapturedType(CapturedType t,Void ignored)方法,然后继续visit(t.bound)进行上界的查找。

2、lowerBound(Type t)方法  

 /**
     * The "lvalue conversion".
     * The lower bound of most types is the type itself.  Wildcards, on the other hand have upper and lower bounds.
     * @param t a type
     * @return the lower bound of the given type
     */
    public Type lowerBound(Type t) {
        return lowerBound.visit(t);
    }
    // where
    private final MapVisitor<Void> lowerBound = new MapVisitor<Void>() {

        @Override
        public Type visitWildcardType(WildcardType t, Void ignored) {
            return t.isExtendsBound() ? syms.botType : visit(t.type);
        }

        @Override
        public Type visitCapturedType(CapturedType t, Void ignored) {
            return visit(t.getLowerBound());
        }
    };

如果如List<?>或者List<? extends InputStream>或者List<? extends T>时,下界为null,否则就是List<? super InputStream>或者List<? super T>时调用visit(t.type)查找下界,如果t.type为非CapturedType,那么下界就是t.type,如果为CapturedType类型时,则继续查找

t.getLowerBound()类型的下界。

3、isUnbounded(Type t)方法

 /**
     * Checks that all the arguments to a class are unbounded wildcards or something else that doesn't make any restrictions
     * on the arguments. If a class isUnbounded, a raw super- or subclass can be cast to it without a warning.
     * @param t a type
     * @return true iff the given type is unbounded or raw
     */
    public boolean isUnbounded(Type t) {
        return isUnbounded.visit(t);
    }
    // where
    private final UnaryVisitor<Boolean> isUnbounded = new UnaryVisitor<Boolean>() {

        public Boolean visitType(Type t, Void ignored) {
            return true;
        }

        @Override
        public Boolean visitClassType(ClassType t, Void ignored) {
            List<Type> parms = t.tsym.type.allparams();
            List<Type> args = t.allparams();
            while (parms.nonEmpty()) {
                // public WildcardType(Type type, BoundKind kind, TypeSymbol tsym, TypeVar bound)
                WildcardType unb = new WildcardType(syms.objectType,
                                                    BoundKind.UNBOUND,
                                                    syms.boundClass,
                                                    (TypeVar)parms.head);
                if (!containsType(args.head, unb)) {
                    return false;
                }
                parms = parms.tail;
                args = args.tail;
            }
            return true;
        }
    };

举个例子,如下:

List<? extends X> x = new ArrayList();
Object y = (List<?>)x;  

传入的ClassType的t参数如下截图:

  

实际的类型参数是否包含形式类型参数来决定是否对实际的类型参数产生约束。

3、containsType() 方法

这个方法的注释如下:

Check if t contains s.

T contains S if:

L(T) <: L(S) && U(S) <: U(T)

This relation is only used by ClassType.isSubtype(), that is,

C<S> <: C<T> if T contains S.

Because of F-bounds, this relation can lead to infinite recursion. Thus we must somehow break that recursion. Notice that containsType() is only called from ClassType.isSubtype(). Since the arguments have already been checked against their bounds, we know:

U(S) <: U(T) if T is "super" bound (U(T) *is* the bound)

L(T) <: L(S) if T is "extends" bound (L(T) is bottom)

通过如下方法就可知道代码是如何来判断两者之间的关系的,如下:

  void debugContainsType(WildcardType t, Type s) {
            System.err.println();
            System.err.format(" does %s contain %s?%n", t, s);
            System.err.format(" %s U(%s) <: U(%s) %s = %s%n",
                               upperBound(s), s, t, U(t),
                               t.isSuperBound() ||
                                       isSubtypeNoCapture(upperBound(s), U(t)));

            System.err.format(" %s L(%s) <: L(%s) %s = %s%n",
                              L(t), t, s, lowerBound(s),
                              t.isExtendsBound() ||
                                      isSubtypeNoCapture(L(t), lowerBound(s)));
            System.err.println();
        }

在TypeRelation匿名类中,有两个私有方法,代码如下:

private Type U(Type t) {
            while (t.tag == WILDCARD) {
                WildcardType w = (WildcardType)t;
                if (w.isSuperBound())
                    return w.bound == null ? syms.objectType : w.bound.bound;
                else
                    t = w.type;
            }
            return t;
}

private Type L(Type t) {
            while (t.tag == WILDCARD) {
                WildcardType w = (WildcardType)t;
                if (w.isExtendsBound())
                    return syms.botType;
                else
                    t = w.type;
            }
            return t;
}

主要的逻辑就是求通配符的上界和下界。剩下就是处理特定几个类型了,如下:

@Override
public Boolean visitWildcardType(WildcardType t, Type s) {
            if (s.tag >= firstPartialTag)
                return containedBy(s, t);
            else {
                debugContainsType(t, s);

                if(isSameWildcard(t, s)){
                    return true;
                }
                if(isCaptureOf(s, t)){
                    return true;
                }
                boolean a = t.isExtendsBound() || isSubtypeNoCapture(L(t), lowerBound(s));
                boolean b = t.isSuperBound() || isSubtypeNoCapture(upperBound(s), U(t));

                return a && b;
            }
}

  

可以看到主要还是处理WildcardType与UndeterminedVariable类型。

(1)visitWildcardType(WildcardType t,Type s)判断t是否包含了s类型,如果s.tag>=firstPartialTag,那么调用containedBy(s,t)方法来判断两者之间的关系。也就是

  /** The tag of an unknown type
     */
    public static final int UNKNOWN = ERROR+1;

    /** The tag of all instantiatable type variables.
     */
    public static final int UNDETVAR = UNKNOWN+1;

    /** The number of type tags.
     */
    public static final int TypeTagCount = UNDETVAR+1;

当s为UNKNOWN或者UNDETVAR类型时调用containedBy()方法。  

当s与t是两个相同的WildcardType时,返回true,如何判断两个WildcardType类型相同呢?

public boolean isSameWildcard(WildcardType t, Type s) {
        if (s.tag != WILDCARD)
            return false;
        WildcardType w = (WildcardType)s;
        return w.kind == t.kind && w.type == t.type;
}

kind相同同时type也相同,kind是一个枚举类型,如下:

public enum BoundKind {
    EXTENDS("? extends "),
    SUPER("? super "),
    UNBOUND("?");

    private final String name;
    BoundKind(String name) {
        this.name = name;
    }
    public String toString() { return name; }
}

  

接下来调用isCaptureOf()方法进行判断,代码如下:

public boolean isCaptureOf(Type s, WildcardType t) {
        if (s.tag != TYPEVAR || !((TypeVar)s).isCaptured())
            return false;
        return isSameWildcard(t, ((CapturedType)s).wildcard);
}  

  

看一下CaptureType类型的实现代码,如下:

 /** A captured type variable comes from wildcards which can have
     *  both upper and lower bound.  CapturedType extends TypeVar with  a lower bound.
     */
    public static class CapturedType extends TypeVar {

        public WildcardType wildcard;

        public CapturedType(Name name,
                            Symbol owner,
                            Type upper,
                            Type lower,
                            WildcardType wildcard) {
            super(name, owner, lower);
            this.lower = Assert.checkNonNull(lower);
            this.bound = upper;
            this.wildcard = wildcard;
        }

        @Override
        public <R,S> R accept(Type.Visitor<R,S> v, S s) {
            return v.visitCapturedType(this, s);
        }

        @Override
        public boolean isCaptured() {
            return true;
        }

        @Override
        public String toString() {
            return "capture#"
                + (hashCode() & 0xFFFFFFFFL) % Printer.PRIME
                + " of "
                + wildcard;
        }
}  

这个CaptureType继承了TypeVar类型,也就和TypeVar有相同的tag值。所以如果s.tag!=TYPEVAR,那就一定不是CaptureType类型。然后继续调用TypeVar类型的isCaptured()方法进行了判断。只有CapturedType类型的isCaptured()方法返回true,TypeVar及其它类型返回为false。

也就可以断定,如果走到了if判断语句的下面,那么s类型肯定为CaputuredType。

接下来有两个判断,如下:

 boolean a = t.isExtendsBound() || isSubtypeNoCapture(L(t), lowerBound(s)); // L(t)是否为LowerBound(s)的子类型
 boolean b = t.isSuperBound()   || isSubtypeNoCapture(upperBound(s), U(t)); // upperBound(s)是否为U(t)的子类型

关于isExtendsBond()与isSuperBound()方法定义在WildcardType类型中,代码如下:

 public boolean isSuperBound() {
            return kind == SUPER || kind == UNBOUND;
}
public boolean isExtendsBound() {
            return kind == EXTENDS || kind == UNBOUND;
}
public boolean isUnbound() {
            return kind == UNBOUND;
}  

关于a与b的判断条件如下:

当t要包含s类型时,t的上界要大于s的上界,t的下界要小于s的下界。

 

当t为UndetVar类型时,判断逻辑代码如下:

@Override
 public Boolean visitUndetVar(UndetVar t, Type s) {
            if (s.tag != WILDCARD)
                return isSameType(t, s);
            else
                return false;
}

当s不为通配符类型时判断是否为同一个类型,否则就没有包含的关系。  

  

@Override
public Boolean visitType(Type t, Type s) {
            if (s.tag >= firstPartialTag)
                return containedBy(s, t);
            else
                return isSameType(t, s);
}
@Override
public Boolean visitErrorType(ErrorType t, Type s) {
    return true;
}  

也就是如果t是非ErrorType,CapturedType与UndetVar类型时,会调用visitType()方法来判断包含关系。

当t为ErrorType时为什么会返回true?

  


  

  

 

Types方法之upperBound-lowerBound-isUnbounded-containsType的更多相关文章

  1. Types方法之isSameType-isSuperType-isSubType

    4.isSameType() 方法 /** * Is t the same type as s? */ public boolean isSameType(Type t, Type s) { retu ...

  2. Types方法之isCastable-isConvertible

    5. Conversions and Promotions 5.1. Kinds of Conversion 5.1.1. Identity Conversion 5.1.2. Widening Pr ...

  3. java.lang.OutOfMemoryError: bitmap size exceeds VM budget解决方法

    1 BitmapFactory.decodeFile(imageFile); 用BitmapFactory解码一张图片时,有时会遇到该错误.这往往是由于图片过大造成的.要想正常使用,则需要分配更少的内 ...

  4. runtime第三部分方法和消息

    接上一篇http://www.cnblogs.com/ddavidXu/p/5924049.html 转载来源http://www.jianshu.com/p/6b905584f536 http:// ...

  5. Runtime 动态加载方法

    动态加载 #import"ViewController.h" #import"Person.h" @interfaceViewController() @end ...

  6. Objective-C Runtime 运行时之三:方法与消息

    基础数据类型 SEL SEL又叫选择器,是表示一个方法的selector的指针,其定义如下: typedef struct objc_selector *SEL; objc_selector结构体的详 ...

  7. Objective-C Runtime 运行时之三:方法与消息(转载)

    前面我们讨论了Runtime中对类和对象的处理,及对成员变量与属性的处理.这一章,我们就要开始讨论Runtime中最有意思的一部分:消息处理机制.我们将详细讨论消息的发送及消息的转发.不过在讨论消息之 ...

  8. iOS运行时使用(动态添加方法)

    1 举例  我们实现一个Person类 然后Person 其实是没得对象方法eat:的 下面调用person的eat方法 程序是会奔溃的 那么需要借助运行时动态的添加方法 Person *p = [[ ...

  9. BitmapFactory.Options.inSampleSize 的使用方法

    BitmapFactory.decodeFile(imageFile); 用BitmapFactory解码一张图片时.有时会遇到该错误. 这往往是因为图片过大造成的. 要想正常使用,则须要分配更少的内 ...

随机推荐

  1. (连通图 Tarjan)Caocao's Bridges --HDU --4738

    链接: http://acm.hdu.edu.cn/showproblem.php?pid=4738 题目大意:曹操有很多岛屿,然后呢需要建造一些桥梁将所有的岛屿链接起来,周瑜要做的是就是不让曹操将所 ...

  2. svn服务器快速搭建及简单配置

    http://www.360doc.com/content/11/0711/19/5131531_132950891.shtml 简介Svn已经不容质疑的成为了一款流行的代码控制工具,但是你是否还在为 ...

  3. nodejs+express安装配置(Linux版本)

    在ubuntu下面,直接从源里面安装nodejs的话,此版本还行,但是相关的express等,会比较老. 采用源码安装,先下载nodejs的源码,然后三步: ./configure make make ...

  4. SQL反模式-1

    SQL反模式讲了很多数据库设计中遇到的难题.跟我最近的工作很相关.因此特意拜读了下.本文主要讲解"多值列"和"幼稚的树" 多值列要分成映射表,比如(A,B),其 ...

  5. C#HttpUtility.UrlEncode 大写问题

    工作上和另一个公司对接,调对方的api需要用到md5加密,加密前要使用HttpUtility.UrlEncode,对方接口一直返回验证错误,定位了问题发现是中文编码使用HttpUtility.UrlE ...

  6. XML文件之创建

    1.创建XML文档对象XmlDocument doc=new XmlDocument() 2.创建XML根节点变量XmlElement xmlElement 3.判断XML文件是否已经存在 1)若存在 ...

  7. [翻译].NET Core 3 Preview1和Windows桌面框架开源

    原文来自TechViews 今天,我们宣布推出.NET Core 3 Preview 1.这是.NET Core 3的第一个公开发布.我们有一些令人兴奋的新功能可供分享,并希望得到您的反馈.您可以使用 ...

  8. .net生成条形码

    1..net 标准库(.net standard 2.0) Nuget添加引用:ZXing.Net生成条形码,ZXing.Net.Bindings.ImageSharp生成图片 public stat ...

  9. Mysql 练习题一

    库操作: 1. 创建 数据库  create database db1; 2. 使用数据库 use db1 3. 查看表  show tables; 4. 删除  drop database db1  ...

  10. Day 30 面向对象的考试题

    -摘自张磊同学博客. 面向对象 1.请简述类.对象.实例化.实例这些名词的含义: #类 : 是对具有相同属性和相似行为的一类事物的抽象 #对象: 是一个具有具体属性值的类的实例化 #实例化 : 从一个 ...