在java中，将对象传递给另一个类引用有什么用？

例如：fooab=newdog（）

---

正在将另一类型类的对象保存到另一类的引用

并不总是需要执行类似于

Foo Foo=new Bar（）

的操作，但通常建议参考接口而不是实现。 通过这种方式，您可以更改实现，而无需更改其他代码。 例如，如果您正在使用列表执行某些操作，并且使用ArrayList，您可能会执行以下操作：

ArrayList<Integer> numbers = new ArrayList<>();
//Do stuff with numbers

ArrayList number=new ArrayList（）；
//用数字做事

然而，你可能不在乎它是什么样的列表，所以你可能会更好地使用它

List<Integer> numbers = new ArrayList<>();
//Do stuff with numbers

List number=new ArrayList（）；
//用数字做事

现在，不管你有什么样的列表，也许你会发现使用LinkedList会获得更好的性能，你可以直接使用它，而不是更改任何其他代码

---

我想说，当其他调用方接收对象时，多态性是最重要的。

并不总是需要执行类似

Foo Foo=new Bar（）

的操作，但通常建议参考接口而不是实现。 通过这种方式，您可以更改实现，而无需更改其他代码。 例如，如果您正在使用列表执行某些操作，并且使用ArrayList，您可能会执行以下操作：

ArrayList<Integer> numbers = new ArrayList<>();
//Do stuff with numbers

ArrayList number=new ArrayList（）；
//用数字做事

然而，你可能不在乎它是什么样的列表，所以你可能会更好地使用它

List<Integer> numbers = new ArrayList<>();
//Do stuff with numbers

List number=new ArrayList（）；
//用数字做事

现在，不管你有什么样的列表，也许你会发现使用LinkedList会获得更好的性能，你可以直接使用它，而不是更改任何其他代码

---

不过，我想说，多态性在其他调用方接收对象时是最重要的。

对于方法参数更有用

class Animal {
    public boolean hasHair = true;
    public void speak() {}
}

class Dog extends Animal {
    public void speak() {
        System.out.println("Woof!");
    }
}

class Person {
    public void shave(Animal a) {
        a.hasHair = false;
        a.speak();
    }
}

class Main {
    public static void main(String[] args) {
        Person joe = new Person();
        Dog fido = new Dog();
        joe.shave(fido);
    }
}

在这种情况下，一个人可以给任何动物剃须，但我们可以给它一条狗

Animal fido=新狗（）不太有用，因为我们知道FIDO是一只狗，但请考虑如下：

Animal pet;
if(joe.prefersCats)
    pet = new Cat();
else
    pet = new Dog();

它对方法参数更有用

class Animal {
    public boolean hasHair = true;
    public void speak() {}
}

class Dog extends Animal {
    public void speak() {
        System.out.println("Woof!");
    }
}

class Person {
    public void shave(Animal a) {
        a.hasHair = false;
        a.speak();
    }
}

class Main {
    public static void main(String[] args) {
        Person joe = new Person();
        Dog fido = new Dog();
        joe.shave(fido);
    }
}

在这种情况下，一个人可以给任何动物剃须，但我们可以给它一条狗

Animal fido=新狗（）不太有用，因为我们知道FIDO是一只狗，但请考虑如下：

Animal pet;
if(joe.prefersCats)
    pet = new Cat();
else
    pet = new Dog();

答案很简单，你不能这么做

更复杂的答案是，只有在“Dog”是“Foo”类型的情况下，您才能这样做。
当Dog实现Foo（如果是接口）或扩展Foo（如果是另一个类或抽象类）时，我们什么时候会说Dog是“Foo”的类型

现在，对接口进行编码（问题的技术名称）的好处是

1） Java的多态性就是基于此（多态性使运行时的行为改变成为可能，请在Java中搜索多态性以获取更多信息）
2） 通过这种方法，您可以使接口独立于实现

希望这能回答你的问题。
简单的回答，你不能这么做

更复杂的答案是，只有在“Dog”是“Foo”类型的情况下，您才能这样做。
当Dog实现Foo（如果是接口）或扩展Foo（如果是另一个类或抽象类）时，我们什么时候会说Dog是“Foo”的类型

现在，对接口进行编码（问题的技术名称）的好处是

1） Java的多态性就是基于此（多态性使运行时的行为改变成为可能，请在Java中搜索多态性以获取更多信息）
2） 通过这种方法，您可以使接口独立于实现

希望这能回答您的问题。
这种声明是唯一可能的

 Foo ab=new Dog();

如果Dog类扩展了类Foo或Foo是由Dog类实现的接口

class Dog extends Foo { .... }

或

我认为，如果使用继承接口或继承类作为所有基类函数初始化类对象是没有用的，那么派生类对象中的属性将可用。如果您使用不同的派生类初始化具有相同基类的多个对象，这种类型的声明将非常方便。

比如说,

public class MyObject
{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class MyFile extends MyObject
{
    private String extension;

    public String getExtension() {
        return extension;
    }

    public void setExtension(String extension) {
        this.extension = extension;
    }
}

public class MyFolder extends MyObject
{

}

如果您正在初始化

MyObject file = new MyFile();

这真的没有用，但是当我们想要初始化时，它会很有用

List<MyObject> listOfFilesFolders = new ArrayList<MyObject>();
listOfFilesFolders.add(new MyFile());
listOfFilesFolders.add(new MyFolder());

它可以获取从基类派生的所有对象，并根据基类属性或函数执行操作。
这种类型的声明是唯一可能的

 Foo ab=new Dog();

如果Dog类扩展了类Foo或Foo是由Dog类实现的接口

class Dog extends Foo { .... }

或

我认为，如果使用继承接口或继承类作为所有基类函数初始化类对象是没有用的，那么派生类对象中的属性将可用。如果您使用不同的派生类初始化具有相同基类的多个对象，这种类型的声明将非常方便。

比如说,

public class MyObject
{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class MyFile extends MyObject
{
    private String extension;

    public String getExtension() {
        return extension;
    }

    public void setExtension(String extension) {
        this.extension = extension;
    }
}

public class MyFolder extends MyObject
{

}

如果您正在初始化

MyObject file = new MyFile();

这真的没有用，但是当我们想要初始化时，它会很有用

List<MyObject> listOfFilesFolders = new ArrayList<MyObject>();
listOfFilesFolders.add(new MyFile());
listOfFilesFolders.add(new MyFolder());

它可以获取从基类派生的所有对象，并根据基类属性或函数执行操作。
是的，如果Foo是一个接口，那么这种方法可以让您更好地控制代码。您实现了java编程语言的
多态性
，
插入能力
，
可维护性
和
松耦合
特性

假设您应该从应用程序连接到oracle，并像这样编写代码

    OracleDrive driver= new OracleDriver()
    driver.connect();

Driver driver = properties.get(db.driver.class)
driver.connect()

它会解决你的问题。但会使您的代码与OracleDriver紧密耦合。如果从类路径中删除与Oracle相关的jar，则应用程序将无法编译。如果有人要求你根据配置将你的应用程序连接到不同的数据库，那么你最终会得到多个基于你的应用程序支持的数据库的
if
s。这是一个坏习惯
feedAndGroom(new Hyena());
feedAndGroom(new Lion());
feedAndGroom(new Panther());

public interface `DomesticatedAnimal` extends `Animal` { ... }

public static void feedAndGroom(DomesticatedAnimal da) { ... }

public class Dog implements DomesticatedAnimal { ... }

Foo ab=new Dog();