GVKun编程网logo

Java创建对象的几种方法（java创建对象的几种方法是什么）

13

本文将介绍Java创建对象的几种方法的详细情况，特别是关于java创建对象的几种方法是什么的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于&和&&的

本文将介绍Java创建对象的几种方法的详细情况，特别是关于java创建对象的几种方法是什么的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于&和&&的共同点和区别、Java字符含义和Java创建对象的几种方式、Java 中创建对象的几种方式、java 创建对象的几种方式、javascript中创建对象的几种不同方法的知识。

本文目录一览：

Java创建对象的几种方法（java创建对象的几种方法是什么）

Java创建对象的几种方法（java创建对象的几种方法是什么）

这篇文章主要为大家详细介绍了Java创建对象的几种方法，使用new创建、使用object.clone()创建、使用反序列化创建等，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

有时候，也可能碰到这样面试题，如：

Java创建对象有哪几种方法？

除了new之外，java创建对象还有哪几种方式？

本文结合例子，给出几种Java创建对象的方法，Here we go~~~~

使用new创建

这是最常用的一种。如：

Book book = new Book();

示例如下：

package test; import java.io.Serializable; import java.util.List; /** * @author wangmengjun * */ public class Book implements Serializable{ private static final long serialVersionUID = -6212470156629515269L; /**书名*/ private String name; /**作者*/ private List authors; /**ISBN*/ private String isbn; /**价格*/ private float price; public Book() { } /** * @param name * @param authors * @param isbn * @param price */ public Book(String name, List authors, String isbn, float price) { this.name = name; this.authors = authors; this.isbn = isbn; this.price = price; } /** * @return the name */ public String getName() { return name; } /** * @param name the name to set */ public void setName(String name) { this.name = name; } /** * @return the authors */ public List getAuthors() { return authors; } /** * @param authors the authors to set */ public void setAuthors(List authors) { this.authors = authors; } /** * @return the isbn */ public String getIsbn() { return isbn; } /** * @param isbn the isbn to set */ public void setIsbn(String isbn) { this.isbn = isbn; } /** * @return the price */ public float getPrice() { return price; } /** * @param price the price to set */ public void setPrice(float price) { this.price = price; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "Book [name=" + name + ", authors=" + authors + ", isbn=" + isbn + ", price=" + price + "]"; } }

/** * 1. 使用new创建对象 */ Book book1 = new Book(); book1.setName("Redis"); book1.setAuthors(Arrays.asList("Eric", "John")); book1.setPrice(59.00f); book1.setIsbn("ABBBB-QQ677868686-HSDKHFKHKH-2324234"); System.out.println(book1);

使用object.clone()

如果要调用clone方法，那么该object需要实现Cloneable接口，并重写clone()方法。

修改后的Book类如下：

package test; import java.io.Serializable; import java.util.List; /** * @author wangmengjun * */ public class Book implements Serializable, Cloneable { private static final long serialVersionUID = -6212470156629515269L; /**书名*/ private String name; /**作者*/ private List authors; /**ISBN*/ private String isbn; /**价格*/ private float price; public Book() { } /** * @param name * @param authors * @param isbn * @param price */ public Book(String name, List authors, String isbn, float price) { this.name = name; this.authors = authors; this.isbn = isbn; this.price = price; } /** * @return the name */ public String getName() { return name; } /** * @param name the name to set */ public void setName(String name) { this.name = name; } /** * @return the authors */ public List getAuthors() { return authors; } /** * @param authors the authors to set */ public void setAuthors(List authors) { this.authors = authors; } /** * @return the isbn */ public String getIsbn() { return isbn; } /** * @param isbn the isbn to set */ public void setIsbn(String isbn) { this.isbn = isbn; } /** * @return the price */ public float getPrice() { return price; } /** * @param price the price to set */ public void setPrice(float price) { this.price = price; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "Book [name=" + name + ", authors=" + authors + ", isbn=" + isbn + ", price=" + price + "]"; } @Override protected Object clone() throws CloneNotSupportedException { return (Book) super.clone(); } }

测试代码

/** * 1. 使用new创建对象 */ Book book1 = new Book(); book1.setName("Redis"); book1.setAuthors(Arrays.asList("Eric", "John")); book1.setPrice(59.00f); book1.setIsbn("ABBBB-QQ677868686-HSDKHFKHKH-2324234"); System.out.println(book1); /** * 2. 使用clone创建对象 */ try { Book book2 = (Book) book1.clone(); System.out.println(book2); } catch (CloneNotSupportedException e) { // Todo Auto-generated catch block e.printstacktrace(); }

使用Class.newInstance()

可以直接使用Class.forName("xxx.xx").newInstance()方法或者XXX.class.newInstance()完成。

/** * 3. 使用Class.newInstance(); */ try { Book book3 = (Book) Class.forName("test.Book").newInstance(); System.out.println(book3); book3 = Book.class.newInstance(); System.out.println(book3); } catch (InstantiationException | illegalaccessexception | ClassNotFoundException e) { // Todo Auto-generated catch block e.printstacktrace(); }

使用Contructor.newInstance()

可以指定构造器来创建，如选择第一个构造器创建；也可以指定构造函数参数类型来创建。

/** * 4. 使用Constructor.newInstance(); */ try { //选择第一个构造器创建Book Book book4 = (Book) Book.class.getConstructors()[0].newInstance(); //Book [name=null, authors=null, isbn=null, price=0.0] System.out.println(book4); /** * 调用指定构造函数创建对象 */ book4 = (Book) Book.class.getConstructor(String.class, List.class, String.class, float.class).newInstance("New Instance Example", Arrays.asList("Wang", "Eric"), "abc1111111-def-33333", 60.00f); //Book [name=New Instance Example, authors=[Wang, Eric], isbn=abc1111111-def-33333, price=60.0] System.out.println(book4); } catch (InstantiationException | illegalaccessexception | IllegalArgumentException | InvocationTargetException | SecurityException | NoSuchMethodException e) { // Todo Auto-generated catch block e.printstacktrace(); }

使用Class.newInstance()或者Contructor.newInstance()，其本质是一样的，都采用了反射机制。

使用反序列化

/** * 5. 使用反序列化 */ try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("book.dat")); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("book.dat"));) { oos.writeObject(book1); Book book5 = (Book) ois.readobject(); System.out.println(book5); } catch (IOException | ClassNotFoundException e) { // Todo Auto-generated catch block e.printstacktrace(); }

当然了，除了上述几种方式之外，还可以使用JNI等方式来创建对象，这边就不一一列举了。

完整的示例代码如下：

Book.java

package test; import java.io.Serializable; import java.util.List; /** * @author wangmengjun * */ public class Book implements Serializable, Cloneable { private static final long serialVersionUID = -6212470156629515269L; /**书名*/ private String name; /**作者*/ private List authors; /**ISBN*/ private String isbn; /**价格*/ private float price; public Book() { } /** * @param name * @param authors * @param isbn * @param price */ public Book(String name, List authors, String isbn, float price) { this.name = name; this.authors = authors; this.isbn = isbn; this.price = price; } /** * @return the name */ public String getName() { return name; } /** * @param name the name to set */ public void setName(String name) { this.name = name; } /** * @return the authors */ public List getAuthors() { return authors; } /** * @param authors the authors to set */ public void setAuthors(List authors) { this.authors = authors; } /** * @return the isbn */ public String getIsbn() { return isbn; } /** * @param isbn the isbn to set */ public void setIsbn(String isbn) { this.isbn = isbn; } /** * @return the price */ public float getPrice() { return price; } /** * @param price the price to set */ public void setPrice(float price) { this.price = price; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "Book [name=" + name + ", authors=" + authors + ", isbn=" + isbn + ", price=" + price + "]"; } @Override protected Object clone() throws CloneNotSupportedException { return (Book) super.clone(); } }

CreateObjectExample.java

package test; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.lang.reflect.InvocationTargetException; import java.util.Arrays; import java.util.List; /** * @author wangmengjun * */ public class CreateObjectExample { public static void main(String[] args) { /** * 1. 使用new创建对象 */ Book book1 = new Book(); book1.setName("Redis"); book1.setAuthors(Arrays.asList("Eric", "John")); book1.setPrice(59.00f); book1.setIsbn("ABBBB-QQ677868686-HSDKHFKHKH-2324234"); System.out.println(book1); /** * 2. 使用clone创建对象 */ try { Book book2 = (Book) book1.clone(); System.out.println(book2); } catch (CloneNotSupportedException e) { // Todo Auto-generated catch block e.printstacktrace(); } /** * 3. 使用Class.newInstance(); */ try { Book book3 = (Book) Class.forName("test.Book").newInstance(); System.out.println(book3); book3 = Book.class.newInstance(); System.out.println(book3); } catch (InstantiationException | illegalaccessexception | ClassNotFoundException e) { // Todo Auto-generated catch block e.printstacktrace(); } /** * 4. 使用Constructor.newInstance(); */ try { //选择第一个构造器创建Book Book book4 = (Book) Book.class.getConstructors()[0].newInstance(); //Book [name=null, authors=null, isbn=null, price=0.0] System.out.println(book4); /** * 调用指定构造函数创建对象 */ book4 = (Book) Book.class.getConstructor(String.class, List.class, String.class, float.class).newInstance("New Instance Example", Arrays.asList("Wang", "Eric"), "abc1111111-def-33333", 60.00f); //Book [name=New Instance Example, authors=[Wang, Eric], isbn=abc1111111-def-33333, price=60.0] System.out.println(book4); } catch (InstantiationException | illegalaccessexception | IllegalArgumentException | InvocationTargetException | SecurityException | NoSuchMethodException e) { // Todo Auto-generated catch block e.printstacktrace(); } /** * 5. 使用反序列化 */ try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("book.dat")); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("book.dat"));) { oos.writeObject(book1); Book book5 = (Book) ois.readobject(); System.out.println(book5); } catch (IOException | ClassNotFoundException e) { // Todo Auto-generated catch block e.printstacktrace(); } } }

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持小编。

&和&&的共同点和区别、Java字符含义和Java创建对象的几种方式

&和&&的共同点和区别、Java字符含义和Java创建对象的几种方式

一、&和&&的共同点和区别

1、&和&&的联系(共同点)：
&和&&都可以用作逻辑与运算符，但是要看使用时的具体条件来决定。

操作数1&操作数2，操作数1&&操作数2，

表达式1&表达式2，表达式1&&表达式2，

情况1：当上述的操作数是boolean类型变量时，&和&&都可以用作逻辑与运算符。

情况2：当上述的表达式结果是boolean类型变量时，&和&&都可以用作逻辑与运算符。

表示逻辑与(and)，当运算符两边的表达式的结果或操作数都为true时，整个运算结果才为true，否则，只要有一方为false，结果都为false。

2、&和&&的区别(不同点)：
(1)、&逻辑运算符称为逻辑与运算符，&&逻辑运算符称为短路与运算符，也可叫逻辑与运算符。

对于&：无论任何情况，&两边的操作数或表达式都会参与计算。

对于&&：当&&左边的操作数为false或左边表达式结果为false时，&&右边的操作数或表达式将不参与计算，此时最终结果都为false。

综上所述，如果逻辑与运算的第一个操作数是false或第一个表达式的结果为false时，对于第二个操作数或表达式是否进行运算，对最终的结果没有影响，结果肯定是false。推介平时多使用&&，因为它效率更高些。

(2)、&还可以用作位运算符。当&两边操作数或两边表达式的结果不是boolean类型时，&用于按位与运算符的操作。

二、 d,D,s,.,*,?,|,[0-9]{6},d+的含义

d: 匹配一个数字字符。等价于[0-9]

D: 匹配一个非数字字符。等价于1

s: 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ fnrtv]

. ：匹配除换行符 n 之外的任何单字符。要匹配 . ，请使用 . 。

：匹配前面的子表达式零次或多次。要匹配 字符，请使用 *。

+：匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。

|:将两个匹配条件进行逻辑“或”（Or）运算

[0-9]{6}:匹配连续6个0-9之间的数字

d+：匹配至少一个0-9之间的数字

三、Java创建对象的几种方式（重要）

(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

补充说明：
(1)和(2)都会明确的显式的调用构造函数 ；

(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；

(4)是从文件中还原类的对象，也不会调用构造函数。

以上选择上海尚学堂《Java面试题大全》，由尚学堂Java学员收集整理，更多Java面试题或技术文章请点击上海尚学堂Java面试大全。

  1. 0-9 ↩

Java 中创建对象的几种方式

Java 中创建对象的几种方式

       java 创建对象时，通常使用依赖注入的方式管理系统，比如：Spring 去创建对象，然而也有很多其他创建对象的方法：使用 New 关键字、使用 Class 类的 newInstance 方法、使用 Constructor 类的 newInstance 方法、使用 Clone 方法、使用反序列化。

  1. 使用 new 关键字：这是我们最常见的也是最简单的创建对象的方式，通过这种方式我们还可以调用任意的构造函数（无参的和有参的）。比如：Student student = new Student ();
  2. 使用 Class 类的 newInstance 方法：我们也可以使用 Class 类的 newInstance 方法创建对象，这个 newInstance 方法调用无参的构造器创建对象，如：Student student2 = (Student) Class.forName ("根路径.Student").newInstance ();　或者：Student stu = Student.class.newInstance ();
  3. 使用 Constructor 类的 newInstance 方法：本方法和 Class 类的 newInstance 方法很像，java.lang.relect.Constructor 类里也有一个 newInstance 方法可以创建对象。我们可以通过这个 newInstance 方法调用有参数的和私有的构造函数。如： Constructor<Student> constructor = Student.class.getInstance (); Student stu = constructor.newInstance ();　这两种 newInstance 的方法就是大家所说的反射，事实上 Class 的 newInstance 方法内部调用 Constructor 的 newInstance 方法。这也是众多框架 Spring、Hibernate、Struts 等使用后者的原因。
  4. 使用 Clone 的方法：无论何时我们调用一个对象的 clone 方法，JVM 就会创建一个新的对象，将前面的对象的内容全部拷贝进去，用 clone 方法创建对象并不会调用任何构造函数。要使用 clone 方法，我们必须先实现 Cloneable 接口并实现其定义的 clone 方法。如：Student stu2 = <Student>stu.clone (); 这也是原型模式的应用。
  5. 使用反序列化：当我们序列化和反序列化一个对象，JVM 会给我们创建一个单独的对象，在反序列化时，JVM 创建对象并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现 Serializable 接口。如：ObjectInputStream in = new ObjectInputStream (new FileInputStream ("data.obj")); Student stu3 = (Student) in.readObject ();

　　从上面的例子可以看出来，除了使用 new 关键字之外的其他方法全部都是转变为 invokevirtual（创建对象的直接方法），使用被 new 的方式转变为两个调用，new 和 invokespecial（构造函数调用）。

另外：两种 newInstance 方法有没有区别？

     ☆　Class 类位于 java 的 lang 包中，而构造器类是 java 反射机制的一部分。

　  ☆　Class 类的 newInstance 只能触发无参数的构造方法创建对象，而构造器类的 newInstance 能触发有参数或者任意参数的构造方法来创建对象。

　 ☆　Class 类的 newInstance 需要其构造方法是共有的或者对调用方法可见的，而构造器类的 newInstance 可以在特定环境下调用私有构造方法来创建对象。

　 ☆　Class 类的 newInstance 抛出类构造函数的异常，而构造器类的 newInstance 包装了一个 InvocationTargetException 异常。

　Class 类本质上调用了反射包构造器类中无参数的 newInstance 方法，捕获了 InvocationTargetException，将构造器本身的异常抛出。

java 创建对象的几种方式

java 创建对象的几种方式

前言，今日面试被问到创建对象是否一定要通过构造器，当时回答错误，查询分析后记录。

创建对象的几种方式：

第一种，也是最常用、一直接触到的方法：通过 new 创建对象。这种方法需要用到构造器

　　  Demo demo1=new Demo();
 　　 Demo demo2=new Demo (1，"有参构造器");

 

 

第二种，比较常用的的方法：通过反射 newInstance () 创建对象。这种方法用到构造器

　　Demo demo2=(Demo) Class.forName("Demo").newInstance();

第三种，通过 object 类的 clone 方法。需要实现 Cloneable 接口，重写 object 类的 clone 方法。无论何时我们调用一个对象的 clone 方法，jvm 就会创建一个新的对象，将前面对象的内容全部拷贝进去。用 clone 方法创建对象并不会调用任何构造函数。（原型模式，还没了解）

　　Demo demo4=(Demo) demo2.clone();

第四种，反序列化。java 中常常进行 JSON 数据跟 Java 对象之间的转换，即序列化和反序列化。
当我们序列化和反序列化一个对象，JVM 会给我们创建一个单独的对象，在反序列化时，JVM 创建对象并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现 Serializable 接口，虽然该接口没有任何方法。不会调用任何构造函数

javascript中创建对象的几种不同方法

javascript中创建对象的几种不同方法

javascript中创建对象的几种不同方法

方法一：最直白的方式：字面量模式创建

 1 <script>
 2     var person={
 3         name:"小明",
 4         age:20,
 5         sex:"男",
 6         hobby:function(){
 7             console.log("打篮球");
 8         }
 9     };
10 </script>

这种方法代码量多，用于“一开始就确定好内部数据类型的”对象创建。

方法二：调用系统构造函数创建

1 <script>
2     var per=new Object();
3     per={};
4     per.name="小明";
5     per.age="20";
6     per.hobby=function(){
7         console.log("打篮球");
8     };
9 </script>

这种方法可以先调用Object来创建一个空的对象，然后动态地在后面添加对象需要的属性，但是代码量也很多。当创建一个跟它相似的对象时可能会重复使用到添加属性的代码语句，不够简洁。

方法三：工厂模式创建

 1 <script>
 2     function createPerson(name,age){
 3         var p=new Object();
 4         p.name=name;
 5         p.age=age;
 6         p.hobby=function(){
 7             console.log("打篮球");
 8         };
 9     }
10     var person1=createPerson("小明","20");
11     var person2=createPerson("小米","18");
12 </script>

这种方法可以解决方法二的问题，即要创建多个相似的对象时只需要调用多次函数就好，但是工厂模式创建对象无法识别对象的类型，它们都是Object()构造函数创建，都是Object类型(所有的对象都是Object的后代)，不像其他方法Array()、Date()等.

方法四：自定义构造函数创建

构造函数就是一个普通的函数，创建方式和普通函数没有区别，不同的是构造函数习惯上首字母大写。另外就是调用方式的不同，普通函数是直接调用，而构造函数需要使用new关键字来调用。

 1 <script>
 2     function Person("name","age"){
 3         this.name=name;
 4         this.age=age;
 5         this.hobby=function(){
 6             console.log("打篮球");
 7         };
 8     }
 9     var person1=new Person("小明","20");
10     var person2=new Person("小米","18");
11 </script>

这种方法与工厂模式创建有几个不同点：1.函数名Person是大写，而工厂模式的函数creatPerson是小写（习惯上这样用而已）;2.该方法没有return语句，而工厂函数创建有return；3.该方法直接将属性和方法赋值给了this对象，而工厂模式没有出现this对象；4.该方法通过new操作符来实例化一个对象，而工厂模式实例化对象直接调用函数即可。

要创建Person的新实例，必须使用new操作符。用这种方式调用构造函数实际上会经历以下四个步骤：

1.创建一个新对象；2.将构造函数的作用域赋给新对象（因此this就指向了这个新对象）；3.为这个新对象添加属性；4.返回新对象。

这种方法虽然好用，但也不是没有问题。例如当你需要创建100个Person,这100个对象都是单独的个体，它们之间的私有属性是不相等的，当创建100个这样的对象时，加入一个对象中有一个方法，那创建100个对象就要创建100个方法，但是这些方法都是一样的功能，就没有这个必要去浪费内存空间。所以开始就有了下面的方法五了。

方法五：原型模式创建对象

原型模式有一个强大的功能就是可以实现数据共享，从而节省空间，比如上面的100个对象有100个功能一样的方法，那我完全可以让这100个对象共用一个方法。

 1 <script>
 2     function Person(name,age)
 3     {
 4     this.name=name;
 5     this.age=age;
 6     }
 7     Person.prototype.eat=function()
 8     {
 9     console.log("吃东西");
10     }
11     var p1=new Person("小米",30);
12     var p2=new Person("小明",20);
13 </script>

 

如上需要共享的数据就可以写在原型对象(prototype)中，不需要共享的数据写在构造函数Person中,

以后用new Person创建的每一个对象，都可以享用到prototype里面的属性和方法，而构造函数Person里的属性和方法则根据创建对象时传入的参数不同来决定。

 1   <script>
 2  2             function Student(name,age,sex){
 3  3                 this.name=name;
 4  4                 this.age=age;
 5  5                 this.sex=sex;
 6  6             }
 7  7             Student.prototype={
 8  8                 constructor:Student,
 9  9                 height:"180",
10 10                 weight:"55kg",
11 11                 study:function(){
12 12                     console.log("学习好开心");
13 13                 },
14 14                 eat:function(){
15 15                     console.log("好好吃");
16 16                 }
17 17             };
18 18             var stu=new Student("张飞",20,"男");
19 19             stu.eat();//好好吃
20 20             stu.study();//学习好开心
21 21  </script>

关于构造函数、原型对象、实例对象的指向关系，表述如下：

构造函数可以实例化对象；
构造函数中有一个属性叫prototype,是构造函数的原型对象;
构造函数的原型对象(prototype)中有一个constructor构造器,这个构造器指向的就是自己所在的原型对象所在的构造函数；
实例对象的隐含属性(__proto__)指向的是该构造函数创造的原型对象；

 

以上资料，部分参考自《javaScript高级语言程序设计（第三版）》，如有错误，并无误导之意，请前辈不吝指出！感谢！

 

今天关于Java创建对象的几种方法和java创建对象的几种方法是什么的讲解已经结束，谢谢您的阅读，如果想了解更多关于&和&&的共同点和区别、Java字符含义和Java创建对象的几种方式、Java 中创建对象的几种方式、java 创建对象的几种方式、javascript中创建对象的几种不同方法的相关知识，请在本站搜索。

本文标签：

上一篇详解Java的Spring框架中bean的注入集合（spring框架注入bean工作原理）

下一篇JAVA布局管理器与面板组合代码实例（java布局管理器与面板组合代码实例是什么）

相关文章