类，实例，引用，对象

最新推荐文章于 2023-11-14 10:33:06 发布

原创最新推荐文章于 2023-11-14 10:33:06 发布 · 1.6k 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#java #类 #实例 #引用 #对象

Java 专栏收录该内容

30 篇文章

订阅专栏

对象与实例:

面向对象编程 (OOP) 是最流行的编程范例之一。在 OOP 中,重点是根据现实世界的元素来思考要解决的问题,并根据对象及其行为来表示问题。许多支持 OOP 关键方面的编程语言（称为 OOP 语言）都将类作为主要的编程工具。它们被称为基于类的。类是现实世界对象的抽象表示。类具有称为属性的属性。属性被实现为全局变量和实例变量。类中的方法表示或定义这些类的行为。类的方法和属性称为类的成员。用非常简单的术语来说,类是特定现实生活对象的蓝图或模板。所以,对象是用于根据此蓝图存储必要信息的内存块。实例是引用对象的内存块。

什么是类？

类是对象的蓝图。当你编写一个类时，您是在描述 JVM 应该如何创建该类型的对象（结构，房屋设计的蓝图就像一个类描述）。

什么是对象？

对象是实例化类的结果。实例化是获取蓝图并定义每个属性和行为的过程,以便生成的对象实际上代表现实生活中的对象。对象是分配给存储变量,方法或函数等信息的专用且连续的内存块。在Java编程语言中,对象是使用new运算符创建的。例如,如果有一个名为 Person 的类,则可以使用以下方法创建 Person 类的对象。new Person(); 此处,一个 Person 对象由 new 运算符创建,并返回对该对象的引用。new 运算符与 Person 类的构造函数一起用于创建新对象。对象的生命周期从调用它的构造函数开始到它被销毁为止。一旦一个对象没有被引用,它就会被垃圾收集器删除/销毁。

什么是实例？

实例是一个内存块,其中包含对对象的引用。也就是说,Instance会保留对象所在的起始内存块的地址。实际上,实例的名称可以用来访问对象内存区域的开始。起始内存的偏移量由运行时引擎计算,以便我们可以转到存储单个数据或方法引用的位置。以下 Java 代码片段可用于创建 Person 对象的实例。Person myPerson = new Person(); 如上所述,new 运算符创建 Person 对象并返回对它的引用。此引用存储在 Person 类型变量 myPerson 中。所以,myPerson 是创建 Person 对象的实例。

对象和实例有什么区别？

对象是一个连续的内存块,用于存储将此对象与其他对象区分开来的实际信息,而实例是对对象的引用。它是一块内存,指向存储对象的起始地址。两个实例可能引用同一个对象。对象和实例的生命周期是不相关的。因此,实例可能为空。一旦指向一个对象的所有实例都被删除,该对象将被销毁。

代码如下

package org.example.helloswing.domain;

public class Animal extends Biology {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        super(name, age);
        this.name = name;
        this.age = age;
    }

}

package org.example.helloswing.domain;

public interface Behavior {

    void eat();

    void breath();

}

package org.example.helloswing.domain;

/**
 * 用生物当做抽象类，因为生物复杂多样，比如外星人，跨物种等等
 */
public abstract class Biology implements Behavior {
    private String name;
    private int age;

    public Biology() {
    }

    protected Biology(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void eat() {
        System.out.println(this.name + "\t吃东西……");
    }


    @Override
    public void breath() {
        System.out.println(this.name + "\t牛13气体……");
    }
}

package org.example.helloswing.domain;

import java.util.Objects;

public class Person extends Animal {
    private int id;
    private String name;
    private int age;

    public Person() {
        super();
    }

    public Person(int id, String name, int age) {
        super(name, age);
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void breath() {
        super.breath();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id && age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

package org.example.helloswing;


import org.example.helloswing.domain.Behavior;
import org.example.helloswing.domain.Biology;
import org.example.helloswing.domain.Person;

import java.lang.reflect.InvocationTargetException;


public class Main {
    /**
     * 类是数据类型，你使用这种类型来创建对象（Person，结构，房屋设计的蓝图就像一个类描述）。
     * 实例是指对象的引用（p1，就是一个地址引用）。
     * 对象是物理上占用一些内存（new Person(1, "Carlos", 20)，物理存储）。
     *
     * @param args
     */
    public static void main(String[] args) {
        // 对于情况 1,类 Person 有两个实例,但两个实例代表同一个对象。
        // 对象是类的实例,实例是代表对象在该类下的副本。
        Person p1 = new Person(1, "Carlos", 20);
        Person p2 = new Person(1, "Carlos", 20);
        // 对于情况 2,类 Person 有两个实例,但每个实例代表一个不同的对象,一个对象可以有多个实例。
        Person p3 = new Person(2, "John", 15);
        Person p4 = new Person(3, "Mary", 17);
        // 所以类、对象和实例是不同的东西。
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
        System.out.println(p4);
        // 对象方法
        p1.eat();
        p2.eat();
        p3.eat();
        p4.eat();
        // 创建一个子类的对象
        Person person1 = new Person();
        // 你不能存储一个实例,但你可以存储一个对象（数据库的记录）
        Person person2 = person1;
        System.out.println(person1);
        System.out.println(person2);
        // 检查 person1 是否是子类的实例
        System.out.println(person1 instanceof Person);
        // 检查 person1 是否是父类的实例
        System.out.println(person1 instanceof Biology);
        // 检查 person1 是否是接口的实例
        System.out.println(person1 instanceof Behavior);


        // 我们可以为抽象类和接口创建一个实例，但我们不能为它们创建一个对象。
        // org.example.helloswing.domain.Behavior是抽象的; 无法实例化
        // 但是我个人对此持有疑惑加个中括号就可以了,无构造方法
        Behavior behavior = new Behavior() {
            @Override
            public void eat() {

            }

            @Override
            public void breath() {

            }
        };
        behavior.eat();
        behavior.breath();
        System.out.println("behavior instanceof Object:\t" + (behavior instanceof Object));
        System.out.println("behavior:\t" + (behavior instanceof Behavior));
        try {
            System.out.println("behavior:\t" + Class.forName("org.example.helloswing.domain.Behavior").isInstance(behavior));
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Behavior.class.getName());


        // java: org.example.helloswing.domain.Biology是抽象的; 无法实例化
        Biology biology = new Biology() {
        };
        Biology biology1 = new Biology() {
        };
        biology.setAge(11);
        biology.setName("抽象类");
        biology.eat();
        biology.breath();
        biology1.setAge(12);
        biology1.setName("AbstractClass");
        biology1.eat();
        biology1.breath();
        System.out.println(biology);
        System.out.println(biology1);
        System.out.println("biology:\t" + (biology instanceof Biology));
        try {
            System.out.println("biology:\t" + Class.forName("org.example.helloswing.domain.Biology").isInstance(biology));
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        /**
         * 创建对象的三种方法
         */
        try {
            // 反射跳过继承，
            Class<?> aClass = Class.forName("org.example.helloswing.domain.Person");
            Person person = (Person) aClass.getDeclaredConstructor().newInstance();
            person.setName("newInstance1");
            person.eat();

            /**
             * java.lang.NoSuchMethodException: org.example.helloswing.domain.Behavior.<init>()
             */
//            Class<?> bClass = Class.forName("org.example.helloswing.domain.Behavior");
//            Behavior behavior1 = (Behavior) bClass.getDeclaredConstructor().newInstance();
//            behavior1.eat();

            /**
             * java.lang.InstantiationException
             */
//            Class<?> cClass = Class.forName("org.example.helloswing.domain.Biology");
//            Biology biology2 = (Biology) cClass.getDeclaredConstructor().newInstance();
//            biology2.eat();

        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | InvocationTargetException |
                 NoSuchMethodException e) {
            throw new RuntimeException(e);
        }


//        try {
//            // java: org.example.helloswing.domain.Behavior是抽象的; 无法实例化
//            Behavior behavior3 = new Behavior();
//            // java: org.example.helloswing.domain.Biology是抽象的; 无法实例化
//            Biology biology3 = new Biology();
//        } catch (Exception e) {
//            throw new RuntimeException(e);
//        }

    }
}