Question

 public boolean contains(Object o) {
    for (E x : this)
        if (x.equals(o))
            return true;
    return false;
}

有人能告诉我什么是激动人心的意思吗？＃34;这个＆＃34;在这段代码？没有这个怎么写呢？怎么写？

Answer 1

此处this表示调用当前方法的对象。例如，如果您有a.contains(x)，那么contains方法this内将返回对a引用变量中保存的同一对象的引用。

由于你可以在for-each中使用this，这意味着contains方法被放置在实现Iterable<E>接口的类中，因为for-each只能遍历：

像String[] array = ...; for(String s : array){...}
实现Iterable<E>的类的实例，例如List<String>我们可以写for(String s : list){...}

要避免this，您可以显式添加包含此方法的类的方法参数，例如

public boolean contains(YourClass yc, Object o) {

//and use that parameter in loop instead of `this`

    for (E x : yc)
        if (x.equals(o))
            return true;
    return false;
}

但这意味着您需要以a.contains(a,x)的方式调用此方法，因此需要重复a两次（更不用说它可以允许我们传递我们类的其他实例而不是{{} 1}}喜欢a）。

为了避免这种重复，我们可以制作a.contains(b,x)方法contains，允许通过static调用它。但是这样我们需要从一个基本的OOP概念 - 多态 - 中辞职，因为它不适用于YourClass.contains(a,x)方法。

编译器使用第一个解决方案来解决它，所以它编译我们的方法就像编写它们一样（我们实际上可以用这种方式编写方法）

static

然后当我们写public boolean contains(YourClass this, Object o) { // ^^^^^^^^^^^^^^ ... }时，它被编译为好像我们会调用a.contains(x)。

Answer 2

this是包含contains()方法的类的对象。它指的是执行该方法的类的对象。

将它放在增强的for循环的:之后意味着包含此方法的类必须实现Iterable<E>，因为增强的for循环可用于迭代任何数组或类的实例实现Iterable接口。这意味着您的类可以迭代一些E元素集合。 E可能是泛型类型参数。

为了编写没有this的方法，你必须提供一个实现Iterable<E>的替代对象的引用，但我没有看到这样做的意义。

Answer 3

此代码中的this究竟是什么意思？

它始终是对当前实例的引用。我假设您的类实现了Iterable<T>接口并覆盖了Iterator<T> iterator()方法。

循环只是增强型for语句的语法糖。根据规范（§14.14.2.）：

for ({VariableModifier} UnannType VariableDeclaratorId : Expression)
    Statement
Expression的类型必须是Iterable或数组类型（第10.1节），否则会发生编译时错误。

如果Expression的类型是Iterable的子类型，则翻译如下。

如果某个类型参数Expression的{{1}}类型是Iterable<X>的子类型，则让X为I类型;否则，让java.util.Iterator<X>为原始类型I。

增强的for语句相当于表单的基本for语句：
Iterator

通常，类实现for (I #i = Expression.iterator(); #i.hasNext(); ) { {VariableModifier} TargetType Identifier = (TargetType) #i.next(); Statement }以向API用户提供允许迭代隐藏实际实现的内部集合的能力。

我可以不用这个写它吗？

使用您为内部迭代器编写的逻辑。
使用底层集合的实现（如果它适合并且它适合）。
选择上述其中一个选项，然后重写为标准Iterable。

Answer 4

关键字this只是对当前对象的引用。

以下是如何使用this的示例：

public class Person {
    public final String name;

    public Person(String name) {
        // name = name; 
        // which one is an argument, and which one is class field? 
        // by default, both are reference on argument

        // using "this" to access class field
        this.name = name;
    }

    public void copyFields(Person other) {
        // current object's reference is the same as other object reference 
        // in other words "this" and "other" are the same instances 
        // example: 
        // Person p1 = new Person("a");
        // Person p2 = p1; // p2 is now pointing on the same memory address
        //                 // as p1, so both are pointing on the same object
        //                 // stored in memory.
        // p1.copyFields(p2);
        if (this == other) { // copying from self? useless...
            return;
        }
        this.name = other.name;
    }
}

任何实现Iterable接口的方法都有返回Iterator实例的方法，该方法由foreach循环隐式使用迭代对象持有的项目。迭代器如果有另一个对象，则方法hasNext()返回true 在可迭代容器中，相对于当前位置，以及返回的next() 如果没有下一个对象（object的最后一次调用已返回NoSuchElementException），则下一个hasNext()或抛出false。

以下是使用Iterable方法实现contains的简单示例：

public class Customer extends Person implements Iterable<Item> {
    private final List<Item> list = new LinkedList<>();
    public final String name;

    public Customer(String name) {
        this.name = name;
    }

    public void add(Item item) {
        list.add(item);
    }

    // implementing iterable interface

    @Override
    public Iterator<Item> iterator() {
        return list.iterator();
    }

    // some contains implementations

    public boolean contains1() {
        for (Item item : this) { // customer implements Iterable = OK
            if (o.equals(item)) {
                return true;
            }
        }
        return false;
    }

    public boolean contains2() {
        for (Item item : list) { // list implements Iterable = OK
            if (o.equals(item)) {
                return true;
            }
        }
        return false;
    }

    public boolean contains3(Object o) {
        for (Iterator<Item> iter = iterator(); iter.hasNext();   ) {
            Item item = iter.next();
            if (o.equals(item)) {
                return true;
            }
        }
        return false;
    }

    public boolean contains4(Object o) {
        for (Iterator<Item> iter = list.iterator(); iter.hasNext();   ) {
            Item item = iter.next();
            if (o.equals(item)) {
                return true;
            }
        }
        return false;
    }

    public boolean contains5(Object o) {
        Iterator<Item> iter = iterator(); 
        while (iter.hasNext()) {
            Item item = iter.next();
            if (o.equals(item)) {
                return true;
            }
        }
        return false;
    }

    public boolean contains6(Object o) {
        Iterator<Item> iter = list.iterator();
        while (iter.hasNext()) {
            Item item = iter.next();
            if (o.equals(item)) {
                return true;
            }
        }
        return false;
    }

    public boolean contains7(Object o) {
        return list.contains(o);
    }
}

Answer 5

方法在 classes 中定义，而不是在 objects 中定义。

但它们（通常）是从 objects 调用的。

方法 - 正如 classes 中定义的那样 - 事先不知道哪个对象会调用它们。

因此，有一种机制（由隐藏参数this实现），通过该机制，对象 - 在调用方法时 - 秘密地将本身的地址传递给参数this

（在其他编程语言中可以使用其他名称，Me或self。）

Answer 6

我会把它分给你

当我们创建一个类的新实例时，非静态方法和非静态成员字段就是其中的一部分。我们使用.运算符访问这些方法和字段。
所有非静态方法或成员字段都可以访问this。 this关键字只是对执行该方法的当前对象的引用。
任何实现Iterable接口的类都可以与增强型For-Loop一起使用。
增强型for循环使用语法

for (Object object : objectOfIterableType)

如果实现Iterable接口的类被参数化，则假设其E。那就是你在代码中所拥有的东西。

    for (E x : this)

这意味着当前类具有可迭代的行为，并且可以在它所拥有的项集合上进行迭代。上面的语句将针对由this关键字引用的当前对象所代表的E 类型的项集合中的每个项执行。在每次迭代中，x将代表包含这些项目的项目。

＆＃34;这个＆＃34;的含义在这段代码？

6 个答案: