java實例化對象,java實例化對象的幾種方式

本文目錄一覽：

• 1、java怎麼判斷單例模式創建的對象是同一個
• 2、java:類的實例化就是用類創建對象嗎？
• 3、在JAVA中關於循環實例化類的對象問題
• 4、java怎麼實例化student對象
• 5、在java中實例化一個子類對象賦給父類對象引用或一個實現了介面的類的對象賦給介面的引用，有什麼好處？
• 6、JAVA的「一個類只能要求有一個實例化對象」是什麼意思?

java怎麼判斷單例模式創建的對象是同一個

1. 說明

1）單例模式：確保一個類只有一個實例，自行實例化並向系統提供這個實例

2）單例模式分類：餓單例模式（類載入時實例化一個對象給自己的引用），懶單例模式（調用取得實例的方法如getInstance時才會實例化對象）（java中餓單例模式性能優於懶單例模式，c++中一般使用懶單例模式）

3）單例模式要素：

a）私有構造方法

b）私有靜態引用指向自己實例

c）以自己實例為返回值的公有靜態方法

2.實例

餓單例模式：

複製代碼代碼如下:

package com.wish.modedesign;

public class HungrySingleton {

private static HungrySingleton instance = new HungrySingleton();

private HungrySingleton(){

}

public static HungrySingleton getInstance(){

return instance;

}

}

懶單例模式：

複製代碼代碼如下:

package com.wish.modedesign;

public class Singleton {

private Singleton(){

}

private static Singleton instance;

public static synchronized Singleton getInstance(){ //多線程時注意線程安全

if(instance == null){

instance = new Singleton();

}

return instance;

}

}

測試類Driver.java

複製代碼代碼如下:

package com.wish.modedesign;

public class Driver {

public static void main(String[] args) {

Singleton s1 = Singleton.getInstance();

Singleton s2 = Singleton.getInstance();

System.out.println(s1==s2); //true

}

}

3.優點和適用場景

1）單例模式的優點：

在內存中只有一個對象，節省內存空間。

避免頻繁的創建銷毀對象，可以提高性能。

避免對共享資源的多重佔用。

可以全局訪問。

2）適用場景：

需要頻繁實例化然後銷毀的對象。

創建對象時耗時過多或者耗資源過多，但又經常用到的對象。

有狀態的工具類對象。

頻繁訪問資料庫或文件的對象。

4.使用時注意事項

1）使用時不能用反射模式創建單例，否則會實例化一個新的對象

2）使用懶單例模式時注意線程安全問題

3）餓單例模式和懶單例模式構造方法都是私有的，因而是不能被繼承的，有些單例模式可以被繼承（如登記式模式）

java:類的實例化就是用類創建對象嗎？

實例化就是創建一個類的對象。

如有類a，那麼實例化一個a類的對象就是這樣：

a

a=

new

a();

其中a()為類a的構造函數

在JAVA中關於循環實例化類的對象問題

第一段代碼產生了3個A類的對象，不會重複，因為每次循環都會將實例變數a重新指向內存中新產生的一個A類對象；

第二段代碼報錯，是因為關於變數a，後兩個語句屬於重複定義，所以報錯。

java怎麼實例化student對象

java實例化對象有三種方式

通過new關鍵字

通過反射機制

通過反序列化

在java中實例化一個子類對象賦給父類對象引用或一個實現了介面的類的對象賦給介面的引用，有什麼好處？

這是多態的一種應用：

把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，寫出通用的代碼，做出通用的編程，以適應需求的不斷變化。

賦值之後，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。也就是說，父親的行為像兒子，而不是兒子的行為像父親。

舉個例子：從一個基類中派生，響應一個虛命令，產生不同的結果。

比如從某個基類繼承出多個對象，其基類有一個虛方法Tdoit，然後其子類也有這個方法，但行為不同，然後這些子對象中的任何一個可以賦給其基類的對象，這樣其基類的對象就可以執行不同的操作了。實際上你是在通過其基類來訪問其子對象的，你要做的就是一個賦值操作。

使用繼承性的結果就是可以創建一個類的家族，在認識這個類的家族時，就是把導出類的對象當作基類的對象，這種認識又叫作upcasting。這樣認識的重要性在於：我們可以只針對基類寫出一段程序，但它可以適應於這個類的家族，因為編譯器會自動就找出合適的對象來執行操作。這種現象又稱為多態性。而實現多態性的手段又叫稱動態綁定(dynamic binding)。

簡單的說，建立一個父類的對象，它的內容可以是這個父類的，也可以是它的子類的,當子類擁有和父類同樣的函數，當使用這個對象調用這個函數的時候，定義這個對象的類（也就是父類）里的同名函數將被調用，當在父類里的這個函數前加virtual關鍵字，那麼子類的同名函數將被調用。

例子在C++中：

class A {

public:

A() {}

virtual void foo() {

cout “This is A.” endl;

}

};

class B : public A {

public:

B() {}

void foo() {

cout “This is B.” endl;

}

};

int main(int argc, char* argv[]) {

A *a = new B();

a-foo();

if(a != NULL)

delete a;

return 0;

}

這將顯示：

This is B.

如果把virtual去掉，將顯示：

This is A.

前面的多態實現使用抽象類,並定義了虛方法.

在java中：

多態，是面向對象的程序設計語言最核心的特徵。多態，意味著一個對象有著多重特徵，可以在特定的情況下，表現不同的狀態，從而對應著不同的屬性和方法。從程序設計的角度而言，多態可以這樣來實現（以java語言為例）：

public interface Parent {

public void simpleCall();

}

public class Child_A implements Parent{

public void simpleCall(){

//具體的實現細節；

}

}

public class Child_B implements Parent{

public void simpleCall(){

//具體的實現細節；

}

}

//當然還可以有其他的實現

然後，我們就可以看到多態所展示的特性了：

Parent pa = new Child_A();

pa.simpleCall()則顯然是調用Child_A的方法；

Parent pa = new Child_B();

pa.simpleCall()則是在調用Child_B的方法。所以，我們對於抽象的父類或者介面給出了我們的具體實現後，pa 可以完全不用管實現的細節，只訪問我們定義的方法，就可以了。事實上，這就是多態所起的作用，可以實現控制反轉這在大量的J2EE輕量級框架中被用到，比如Spring的依賴注射機制。

JAVA的「一個類只能要求有一個實例化對象」是什麼意思?

就是單例 是設計模式的一種

class A

{

private A

{

}

A a;

static

{

a = new A();

}

pubic A getA()

{

return a;

}

}

這就是一個簡單的例子 A對象只能有一個實例 不能new出起來的A對象的實例 這就是單例