A. 創建一個對象的步驟
Student s=new Student();
1、Student.class載入進內存
2、聲明一個Student類型的引要 s
3、在堆內存中創建對象
4、給對象中屬性默認初始化值
5、屬性進行顯示初始化
6、構造方法進棧，對對象中的屬性賦值，構造方法彈棧
7、蔣對象的地址值賦值給s
B. 在java中創建對象到底有多少種方法
Java中創建對象的四種方式
1.用new語句創建對象，這是最常見的創建對象的方法。
2.運用反射手段,調用java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。
3.調用對象的clone()方法。
4.運用反序列化手段，調用java.io.ObjectInputStream對象的 readObject()方法。
下面演示了用前面3種方式創建對象的過程：
public class Customer implements Cloneable{
private String name;
private int age;
public Customer(){
this("unknown",0);
System.out.println("call default constructor");
}
public Customer(String name,int age){
this.name=name;
this.age=age;
System.out.println("call second constructor");
}
public Object clone()throws CloneNotSupportedException{
return super.clone();
}
public boolean equals(Object o){
if(this==o)return true;
if(! (o instanceof Customer)) return false;
final Customer other=(Customer)o;
if(this.name.equals(other.name) && this.age==other.age)
return true;
else
return false;
}
public String toString(){
return "name="+name+",age="+age;
}
public static void main(String args[])throws Exception{
//運用反射手段創建Customer對象
Class objClass=Class.forName("Customer");
Customer c1=(Customer)objClass.newInstance(); //會調用Customer類的默認構造方法
System.out.println("c1: "+c1); //列印name=unknown,age=0
//用new語句創建Customer對象
Customer c2=new Customer("Tom",20);
System.out.println("c2: "+c2); //列印name=tom,age=20
//運用克隆手段創建Customer對象
Customer c3=(Customer)c2.clone(); //不會調用Customer類的構造方法
System.out.println("c2==c3 : "+(c2==c3)); //列印false
System.out.println("c2.equals(c3) : "+c2.equals(c3)); //列印true
System.out.println("c3: "+c3); //列印name=tom,age=20
}
}
除了以上4種顯式地創建對象的方式以外，在程序中還可以隱含地創建對象，包括以下幾種情況：
1.對於java命令中的每個命令行參數，Java虛擬機都會創建相應的String對象，並把它們組織到一個String數組中，再把該數組作為參數傳給程序入口main(String args[])方法。
2.程序代碼中的String類型的直接數對應一個String對象。
3.字元串操作符「+」的運算結果為一個新的String對象。
4.當Java虛擬機載入一個類時，會隱含地創建描述這個類的Class實例.
C. java面向對象如何創建對象
java作為互聯網編程中使用范圍最廣泛的編程語言之一，我們有許多的知識是需要掌握學習的，今天java課程培訓機構http://www.kmbdqn.cn/就給大家分析講解一下java面向對象的編程方法有哪些。
常用的創建對象的模式有以下幾種：
一.工廠模式
工廠模式抽象了具體對象的過程，用函數來封裝以特ing介面創建對象的細節。
如下：
functioncreateAnimal(name,age){
varo=newObject();
o.name=name;
o.age=age;
o.sayName=function(){
alert(this.name);
}
returno;
}
varcat=createAnimal("cat",12);
vardog=createAnimal("dog",3);
工廠模式雖然解決了創建多個相似兌現過的問題，但是卻沒有解決對象識別的問題。
二.構造函數模式
構造函數模式可以創建特定類型的對象。
functionAnimal(name,age){
this.name=name;
this.age=age;
this.sayName=function(){
alert(this.name);
}
}
varcat=newAnimal("cat",12);
vardog=newAnimal("dog",3);
可以使用對象的constructor屬性或instanceof操作符來標識對象類型。
cat.constructor==Animal//true
catinstanceofAnimal//true
三.原型模式
每個函數都有一個prototype(原型)屬性。這個屬性是一個指針，指向一個對象，而這個對象的用途是包含可以由特定類型的所有實例共享的屬性和方法。
使用原型對象的好處是，可以讓所有對象實例共享它所包含的屬性和方法。
functionAnimal(){}
Animal.prototype.name="animal";
Animal.prototype.age=1;
Animal.prototype.sayName=function(){
alert(this.name);
}
vartest1=newAnimal();
test1.sayName();//"animal"
vartest2=newAnimal();
test2.sayName();//"animal"
alert(test1.sayName===test2.sayName);//true
或者：
functionAnimal(){}
Animal.prototype={
constructor:Animal,
name:"animal",
age:1,
sayName:function(){
alert(this.name);
}
};
原型中所有屬性是被很多實例共享的，通過在實例上添加一個同名屬性，可以隱藏原型中的對應屬性。但是，對於包含引用類型值的屬性來說，問題就比較明顯了。
D. 創建對象的三種方法
1、字面量創建
利用字面量創建 ，裡面可以添加屬性 值 方法多個（多個屬性 用逗號隔開））
例如：
let obj = {
name: 'zhangsan',
age:18
fn: function () {
alert('我是對象裡面的fn方法')
}
}
調用裡面的值： 對象名.屬性名（可以理解為對象 的 什麼 東西）
例如：
方式一：console.log(obj.name)
方式二：console.log(obj.['age'])
調用裡面的方法：obj.fn（） -------對象.方法名（） 記得加括弧 調用
2、利用 new object 創建對象
Array：用於在單獨的變數名中存儲一系列的值
Date：用於操作日期和時間
String：用於支持對字元串的處理
Math：用於執行常用的數學任務，它包含了若干個數字常量和函數
例如：
let obj=new object();
obj.name='zhangsan '
obj,sex='男'
obj.age=18
let arr = new Array(3);
arr[0] = '賓士'
arr[1] = '寶馬'
arr[2] = '奧迪'
arr[3] = '凱德拉克'
console.log(arr[3]);
/* 可以使用for-in循環輸出數組元素 */
for(let i in arr){-
console.log(arr[i]);
}
3、利用 構造函數 創建對象
let arr = [{name:"zhangsan1"},{name:"zhangsan2"},{name:"zhangsan3"},{name:"zhangsan4"}]
for(let i=0;i<arr.length;i++){
console.log(arr[i].name);
}
E. JAVA創建對象有哪幾種方式
Java中創建對象的四種方法 收藏Java中創建對象的四種方式x0dx0a1.用new語句創建對象，這是最常見的創建對象的方法。x0dx0a2.運用反射手段,調用java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。x0dx0a3.調用對象的clone()方法。x0dx0a4.運用反序列化手段，調用java.io.ObjectInputStream對象的 readObject()方法。x0dx0a第一種最常見
F. java如何創建對象
JAVA創建對象的四種方式：
有4種顯式地創建對象的方式：
1.用new語句創建對象，這是最常用的創建對象的方式。最常用 比如
Scanner scanner = new Scanner(System.in)
2.運用反射手段，Java.lang.Class或者java.lang.reflect.Constructor類的newInstance()實例方法。
3.調用對象的clone()方法。
4.運用反序列化手段
G. 怎樣用new創建一個對象
new關鍵字創建對象方法如下：
類名 對象名=new 類的構造函數；
例如：
類：
class A{
int id;
int name;
/*構造函數*/
public A(){
}
}
創建對象：
A a=new A();
H. 北大青鳥設計培訓：創建新對象的兩種方式
隨著互聯網編程開發技術的發展，編程開發語言已經由面向程序發展成為了面向對象的編程。
今天，我們就從兩個方面來了解一下，java編程語言中如何創建新對象的。
java在new一個對象的時候，會先查看對象所屬的類有沒有被載入到內存，如果沒有的話，就會先通過類的全限定名來載入。
載入並初始化類完成後，再進行對象的創建工作。
我們先假設是一次使用該類，這樣的話new一個對象就可以分為兩個過程：載入並初始化類和創建對象。
一、類載入過程(一次使用該類)java是使用雙親委派模型來進行類的載入的，所以在描述類載入過程前，我們先看一下它的工作過程：雙親委託模型的工作過程是：如果一個類載入器(ClassLoader)收到了類載入的請求，它先不會自己去嘗試載入這個類，而是把這個請求委託給父類載入器去完成，每一個層次的類載入器都是如此，因此所有的載入請求終都應該傳送到頂層的啟動類載入器中，只有當父類載入器反饋自己無法完成這個載入請求(它的搜索范圍中沒有找到所需要載入的類)時，子載入器才會嘗試自己去載入。
使用雙親委託機制的好處是：能夠有效確保一個類的全局性，當程序中出現多個限定名相同的類時，類載入器在執行載入時，始終只會載入其中的某一個類。
1、載入由類載入器負責根據一個類的全限定名來讀取此類的二進制位元組流到JVM內部，並存儲在運行時內存區的方法區，然後將其轉換為一個與目標類型對應的java.lang.Class對象實例2、驗證格式驗證：驗證是否符合class文件規范語義驗證：檢查一個被標記為final的類型是否包含子類;檢查一個類中的final方法是否被子類進行重寫;確保父類和子類之間沒有不兼容的一些方法聲明(比如方法簽名相同，但方法的返回值不同)操作驗證：在操作數棧中的數據必須進行正確的操作，對常量池中的各種符號引用執行驗證(通常在解析階段執行，檢查是否可以通過符號引用中描述的全限定名定位到指定類型上，以及類成員信息的訪問修飾符是否允許訪問等)3、准備為類中的所有靜態變數分配內存空間，並為其設置一個初始值(由於還沒有產生對象，實例變數不在此操作范圍內)被final修飾的static變數(常量)，會直接賦值;4、解析將常量池中的符號引用轉為直接引用(得到類或者欄位、方法在內存中的指針或者偏移量，以便直接調用該方法)，這個可以在初始化之後再執行。
解析需要靜態綁定的內容。
//所有不會被重寫的方法和域都會被靜態綁定以上2、3、4三個階段又合稱為鏈接階段，鏈接階段要做的是將載入到JVM中的二進制位元組流的類數據信息合並到JVM的運行時狀態中。
5、初始化(先父後子)4.1為靜態變數賦值4.2執行static代碼塊注意：static代碼塊只有jvm能夠調用如果是多線程需要同時初始化一個類，僅僅只能允許其中一個線程對其執行初始化操作，其餘線程必須等待，只有在活動線程執行完對類的初始化操作之後，才會通知正在等待的其他線程。
因為子類存在對父類的依賴，所以類的載入順序是先載入父類後載入子類，初始化也一樣。
不過，父類初始化時，子類靜態變數的值也有有的，是默認值。
終，方法區會存儲當前類類信息，包括類的靜態變數、類初始化代碼(定義靜態變數時的賦值語句和靜態初始化代碼塊)、實例變數定義、實例初始化代碼(定義實例變數時的賦值語句實例代碼塊和構造方法)和實例方法，還有父類的類信息引用。
二、創建對象1、在堆區分配對象需要的內存分配的內存包括本類和父類的所有實例變數，但不包括任何靜態變數2、對所有實例變數賦默認值將方法區內對實例變數的定義拷貝一份到堆區，然後賦默認值3、執行實例初始化代碼初始化順序是先初始化父類再初始化子類，初始化時先執行實例代碼塊然後是構造方法4、如果有類似於Childc=newChild()形式的c引用的話，在棧區定義Child類型引用變數c，然後將堆區對象的地址賦值給它需要注意的是，南京IT培訓http://www.kmbdqn.cn/發現每個子類對象持有父類對象的引用，可在內部通過super關鍵字來調用父類對象，但在外部不可訪問
I. ES6創建對象的幾種方式
1）創建對象的方式不同
new Object() 通過構造函數來創建對象, 添加的屬性是在自身實例下。
Object.create() es6創建對象的另一種方式，可以理解為繼承一個對象, 添加的屬性是在原型下。
Object.create()方法創建的對象時，屬性是在原型下面的，也可以直接訪問 b.rep // {rep: "apple"} ,
此時這個值不是吧b自身的，是它通過原型鏈 proto 來訪問到b的值。
2）創建對象屬性的性質不同
Object.create() 用第二個參數來創建非空對象的屬性描述符默認是為false的，而構造函數或字面量方法創建的對象屬性的描述符默認為true。看下圖解析：
[圖片上傳失敗...(image-ee8b47-1638233974390)]
3）創建空對象時不同
[圖片上傳失敗...(image-45d6a0-1638233974390)]
當用構造函數或對象字面量方法創建空對象時，對象時有原型屬性的，即有 _proto_ ;
當用Object.create()方法創建空對象時，對象是沒有原型屬性的。
4） __proto__ 屬性
JavaScript 的對象繼承是通過原型鏈實現的。ES6 提供了更多原型對象的操作方法。
__proto__ 屬性（前後各兩個下劃線），用來讀取或設置當前對象的prototype對象。目前只有瀏覽器環境必須部署有這個屬性，其他運行環境不一定要部署，因此不建議使用這個屬性，而是使用下面這些來 Object.setPrototypeOf() （寫操作）、 Object.getPrototypeOf() （讀操作）、 Object.create() （生成操作）代替。
[圖片上傳失敗...(image-6a4995-1638233974390)]
如果是不用Object,create()方法，我們是如何給對象原型添加屬性和方法的？
------ 通過構造函數或者類，例如：
[圖片上傳失敗...(image-6fb928-1638233974390)]
[圖片上傳失敗...(image-deee8f-1638233974390)]
現在有 Object.create() 就簡單的多了
[圖片上傳失敗...(image-fbb13e-1638233974390)]
輸出結果中看出，添加的方法是在原型上的。就類似於
4.1）原型屬性的繼承
這里結合一個例子來說說這幾個方法的使用：
場景：拷貝一個構造函數的實例。
列印出 實例c 看看結構是怎樣的
[圖片上傳失敗...(image-f8e3d9-1638233974390)]
其中 color 屬性在實例上，而其他的原型上。
現在來拷貝一個 實例 c2
因為 Object.assing 是不能拷貝到繼承或原型上的方法的。所以 實例c2 沒有 a 這個屬性。那要怎麼要才能拷貝到原型上的方法呢？
4.1.1）第一種方法
這樣就實現了原型屬性的拷貝。
Object.getPrototypeOf(c) 既 originProto 得到的是原型上的 //{a: 1, b: 2, c: 3}；
Object.create(originProto) 既 originProto2 既是創建了一個 {a: 1, b: 2, c: 3} 在原型上的新對象；
Object.assign(originProto2, c) 在源對象originProto2 上合並對象 c；
4.1.2）第二種方法 （推薦）
可以把Object.create()的參數理解為：第一個參數是放在新對象的原型上的，第二個參數是放在新對象的實例上的。
所以上面例子
Object.getPrototypeOf() 得到的是 c 對象的原型，然後作為第一個參數，所以會在新對象c2 的原型上。
Object.getOwnPropertyDescriptors() 得到是 c 對象自身屬性(包括可枚舉和不可枚舉的)，作為第二個參數，放在 c2 的實例上。
為什麼說推薦這個方法呢？ 因為Object.assign() 方法不能正確拷貝 get ，set 屬性。
例如，我們給 c 實例添加一個 "colorGet" 屬性，並設置該屬性的get 描述符：
結果如下：
[圖片上傳失敗...(image-60e708-1638233974390)]
這里沒有拷貝到 "colorGet" 的 get 描述符，而是直接把獲取到的值賦值給 "colorGet" 。
那對於 get 描述符要怎麼獲取呢？ Object.getOwnPropertyDescriptors就專為解決這問題而生。
而又因為要拷貝原型上的屬性，所以結合Object.create、Object.getPrototypeOf 方法一起使用。即上面的第二種實現方法，如下：
結果如下：
[圖片上傳失敗...(image-505bf1-1638233974390)]
此時已經成功的拷貝到了get描述符啦。
雖然說實際開發上很少會要去修改 get 描述符，但是知道多一種方法，遇到這種情況時就知道該怎麼去解決了。
注意： 這些都只是一個層級的深拷貝。
上面實現 原型屬性拷貝 中的兩種方法中用到了 Object.getOwnPropertyDescriptors 、 Object.assing() 、 Object.create 、 Object.getPrototypeOf() 方法，通常這幾種方法都有一起結合使用。
如果上面的例子還不理解，這里把他簡單的拿到 對象的繼承 來講解。理解的話就可以忽略啦。
4.2）原型屬性的繼承
以前，繼承另一個對象，常常寫成下面這樣。
ES6 規定 __proto__ 只有瀏覽器要部署，其他環境不用部署。如果去除 __proto__ ，可以用 Object.create() 和 Object.assign() 來實現。
但是 Object.assign() 無法正確拷貝get屬性和set屬性的問題。例如：
[圖片上傳失敗...(image-55279a-1638233974390)]
上圖中，obj 對象的 foo 屬性是一個取值函數，Object.assign不會復制這個取值函數，只會拿到值以後，將這個值賦上去。
而 Object.getOwnPropertyDescriptors() 可以解決這個問題 實現get 、set 屬性的正確拷貝，即方法3 ，如下：
[圖片上傳失敗...(image-df3c31-1638233974390)]
說了那麼多種拷貝方法，怎麼去選擇呢，還是要看實際應用中的情況:
如果只是拷貝 自身可枚舉屬性，就可以只用 Object.assign 方法；
如果是要拷貝原型上的屬性，就需要 Object.assign , Object.create, Object.getPrototypeOf 方法結合使用
如果是拷貝get /set 屬性，就需要 結合 Ojbect.getOwnPropertyDescriptors 方法
參考資料：
J. 有幾種創建對象的方法
作為java開發者，我們每天創建很多對象，但是我們通常使用依賴注入的方式管理系統，比如：Spring去創建對象，然而這里有很多創建對象的方法：使用New關鍵字、使用Class類的newInstance方法、使用Constructor類的newInstance方法、使用Clone方法、使用反序列化。
使用new關鍵字：這是我們最常見的也是最簡單的創建對象的方式，通過這種方式我們還可以調用任意的夠贊函數（無參的和有參的）。比如：Student student = new Student();
使用Class類的newInstance方法：我們也可以使用Class類的newInstance方法創建對象，這個newInstance方法調用無參的構造器創建對象，如：Student student2 = (Student)Class.forName("根路徑.Student").newInstance();或者：Student stu = Student.class.newInstance();
使用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等使用後者的原因。
使用Clone的方法：無論何時我們調用一個對象的clone方法，JVM就會創建一個新的對象，將前面的對象的內容全部拷貝進去，用clone方法創建對象並不會調用任何構造函數。要使用clone方法，我們必須先實現Cloneable介面並實現其定義的clone方法。如：Student stu2 = <Student>stu.clone();
使用反序列化：當我們序列化和反序列化一個對象，JVM會給我們創建一個單獨的對象，在反序列化時，JVM創建對象並不會調用任何構造函數。為了反序列化一個對象，我們需要讓我們的類實現Serializable介面。如：ObjectInputStream in = new ObjectInputStream (new FileInputStream("data.obj")); Student stu3 = (Student)in.readObject();