JavaRush /Java 博客 /Random-ZH /喝咖啡休息#174。在 Java 中创建对象的不同方法。Java 中的 String 到 Int - 如何将 St...

第 41 级

28 二月 2021
36 views
0 comments

喝咖啡休息#174。在 Java 中创建对象的不同方法。Java 中的 String 到 Int - 如何将 String 转换为 Integer

已在 Random-ZH 群组中发布

在 Java 中创建对象的不同方法

来源：Medium 在本教程中，我们将学习在 Java 中创建对象的不同方法。 喝咖啡休息#174。在 Java 中创建对象的不同方法。Java 中的 String 到 Int - 如何将字符串转换为整数 - 1

Java 对象是Java 类的实例。每个对象都有一个状态、一个行为和一个标识符。字段（变量）存储对象的状态，而方法（函数）显示对象的操作。类充当在运行时创建对象实例的“蓝图”。

在 Java 中创建对象

创建对象是分配内存以存储类字段中的数据（也称为变量）的过程。这个过程通常称为创建类的实例。在 Java 中创建对象有四种不同的方法：

使用new关键字
方法newInstance()
克隆()方法
反序列化对象

现在让我们详细看看提到的每个方法。

关键词新

这是在 Java 中创建对象的最常见方法。new关键字通过为指定类型的新实例分配内存来创建类的实例。new 之后是构造函数 - 一种特殊方法，负责创建对象并初始化所创建对象的字段。对象是使用new运算符创建的，并使用构造函数初始化的。下面是使用new运算符创建 Java 对象的示例：

Date today = new Date();

该表达式生成一个新的Date对象（Date是java.util包中的一个类）。代码中的这个子句执行三个操作：声明、实例化和初始化。Date Today是一个变量声明，它通知编译器今天将引用Date类型的对象。new 运算符实例化Date类（在内存中创建一个新的Date对象），并且Date()初始化该对象。考虑下面的例子：

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Michael Cole";
        this.uid = 101;
    }

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

    // getters and setters...

    public static void main(String[] args) {

        Person p1 = new Person();
        Person p2 = new Person("John Bodgan", 102);
        System.out.println("Name: " + p1.getName() + " UID: " + p1.getUid());
        System.out.println("Name: " + p2.getName() + " UID: " + p2.getUid());
    }
}

在这段代码中，我们使用new关键字创建一个Person对象：

p1对象调用非参数化构造函数，变量名称值设置为“Michael Cole”，UID 设置为 101。
p2对象调用参数化构造函数，将值“John Bodgan”和102传递给构造函数，然后为这些值分配变量名和UID。

使用 newInstance() 方法

Java 中的newInstance()方法用于动态创建给定类的对象实例。newInstance()方法有两种标准用法：

java.lang.Class API中的newInstance()方法
java.lang.reflect.Constructor API中的newInstance()方法

使用类 API 中的 newInstance()

要在运行时创建类的对象，我们必须从 Class API 调用newInstance()方法，该方法返回该类的对象。java.lang.Class类的newInstance()方法不带任何参数或实参，可以称为该类的无参构造函数。让我们看一些使用java.lang.Class类的newInstance()方法创建Person类对象的示例代码：

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Carl Max";
        this.uid = 101;
    }

   // getters and setters...
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class c = Class.forName("com.medium.option2.Person");
        @SuppressWarnings("deprecation")
        Person p = (Person) c.newInstance();
        System.out.println("Name: " + p.getName());
        System.out.println("UID: " + p.getUid());
    }
}

Class.forName（类的完全限定名）加载一个名为Person的类，然后newInstance()创建一个Person类型的新对象并返回对其的引用。现在，使用Person对p 的引用，我们可以调用它的getters()和setter()来执行某些操作。请注意：

Class.forName ()和newIstance()都会抛出异常，必须使用try和catch块或throws关键字来处理这些异常。
自 Java 9 起，类 API 中的newInstance()方法已被弃用。

使用构造函数 API 中的 newInstance()

Constructor类( java.lang.reflect.Constructor ) 的newInstance()方法与Class类的newInstance()方法类似，不同之处在于它接受参数化构造函数的参数。让我们通过使用java.lang.reflect.Constructor类的newInstance()方法创建Person类的对象来演示这种方法：

public class PersonTwo {
    private String name;
    private int uid;

    public PersonTwo() {
        this.name = "Maya Kumari";
        this.uid = 101;
    }

    public PersonTwo(String name) {
        this.name = name;
        this.uid = 102;
    }

    public PersonTwo(String name, Integer uid) {
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...
    public static void main(String[] args) {
        try {
            Class.forName("com.medium.option2.PersonTwo");

            Constructor c1 = PersonTwo.class.getConstructor();
            PersonTwo p1 = (PersonTwo) c1.newInstance();
            System.out.println("Name: " + p1.getName());
            System.out.println("UID: " + p1.getUid());

            Constructor c2 = PersonTwo.class.getConstructor(String.class);
            PersonTwo p2 = (PersonTwo) c2.newInstance("James Gunn");
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());

            Constructor c3 = PersonTwo.class.getConstructor(String.class, Integer.class);
            PersonTwo p3 = (PersonTwo) c3.newInstance("Mark Brown", 103);
            System.out.println("Name: " + p3.getName());
            System.out.println("UID: " + p3.getUid());

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

在上面的代码中，首先我们需要使用Class.forName()方法加载类。接下来，我们将调用getConstructor()方法来匹配传递参数的数据类型。最后，在newInstance()方法中，我们传递所需的参数（如果没有参数则为null ）。newInstance()方法将通过调用适当的构造函数返回PersonTwo类的新对象。

使用clone()方法

clone()方法是Object类的一部分，用于创建现有对象的副本。它创建类的对象而不调用任何类构造函数。要克隆方法，相应的类必须实现Cloneable接口，这是一个标记接口。现在我们将创建一个Person类的对象，然后将其克隆到Person类的另一个对象中：

public class Person implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String name;
    private int uid;

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

    // getters and setters...

    public static void main(String[] args) {
        Person p1 = new Person("Ryan", 101);
        try {
            Person p2 = (Person) p1.clone();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

笔记。克隆的对象将通过p2引用引用相同的原始对象。但是，克隆的对象将具有单独的内存分配。这意味着对p2引用的Person对象所做的任何更改都不会更改p1引用的原始Person对象。这是因为clone()方法创建了对象的浅表副本。

使用对象反序列化

对象反序列化是从一系列字节流中提取对象的过程。序列化则相反。它的主要目的是将存储的对象从数据库/网络检索回内存。如果我们想要序列化或者反序列化一个对象，我们需要实现Serialized接口（token接口）。考虑下面的例子：

public class PersonDriver {

    public static void main(String[] args) {
        Person p1 = new Person("Max Payne", 101);
        FileOutputStream fileOutputStream;
        try {
            fileOutputStream = new FileOutputStream("link to text file");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(p1);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileInputStream fileInputStream;
        try {
            fileInputStream = new FileInputStream("link to text file");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            Person p2 = (Person) inputStream.readObject();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
            inputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

这里我们首先通过引用p1将Person对象序列化到文本文件中。writeObject()方法会将对象的字节流写入文本文件。然后，使用对象反序列化，我们将Person对象提取回p2。类似地，readObject()方法将从对象的输入流中读取对象。最后，我们将Person对象中的数据打印到控制台。

结论

在本文中，我们了解了在 Java 中创建对象的不同方法。首先，我们研究了使用new关键字创建对象，这是最常见的方式。然后我们从Class和Constructor类中学习了newInstance()方法，这是另一种创建对象的流行方法。然后我们使用clone()方法，它创建现有对象的浅表副本，而不是创建新对象。最后，我们使用对象序列化和反序列化的概念在Java中创建对象。

Java 中的 String to Int - 如何将字符串转换为整数

来源： FreeCodeCamp 今天您将学习如何在 Java 中使用Integer类的两个方法- parseInt()和valueOf()将字符串转换为整数。这将有助于您使用字符串变量的值执行数学运算。 喝咖啡休息#174。在 Java 中创建对象的不同方法。Java 中的 String 到 Int - 如何将 String 转换为 Integer - 2

喝咖啡休息#174。在 Java 中创建对象的不同方法。Java 中的 String 到 Int - 如何将 String 转换为 Integer - 2

如何在 Java 中使用 Integer.parseInt 将字符串转换为整数

此选项假设parseInt()方法将字符串转换为整数作为参数：

Integer.parseInt(string_varaible)

在查看其使用示例之前，让我们看看当您将字符串值和整数相加而不进行任何转换时会发生什么：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        System.out.println(age + 20);
        // 1020
    }
}

在此代码中，我们创建了一个字符串值“10”的变量age 。当我们将数字 20 添加到整数值时，我们错误地收到了 1020，而不是正确的答案 30。这可以使用 parseInt ()方法来纠正：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.parseInt(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

在这里，为了将age变量转换为整数，我们将其作为参数传递给parseInt()方法- Integer.parseInt(age) - 并将其存储在名为age_to_int的变量中。现在，当添加到另一个整数时，我们得到正确的加法：age_to_int + 20。

如何在 Java 中使用 Integer.valueOf 将字符串转换为整数

valueOf()方法的工作方式与parseInt()方法相同。它采用需要转换为整数的字符串作为参数。这是一个例子：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.valueOf(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

在上面的代码中，您可以看到与上一节相同的内容：

我们将一个字符串作为参数传递给valueOf()：Integer.valueOf(age)。它存储在名为age_to_int 的变量中。
然后我们将 10 添加到创建的变量：age_to_int + 20。结果是 30，而不是 1020。

结论

在本文中，我们讨论了在 Java 中将字符串转换为整数。要将字符串转换为整数，使用了Integer类的两个方法- parseInt()和valueOf()。快乐编码！

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION