當前位置:首頁 » 編程語言 » java類實例

java類實例

發布時間: 2024-04-16 16:26:59

1. java類的實例化順序是什麼樣的Java線程同步的方式有哪些

引言:java是在1990年初 ,被詹姆斯•高斯林等人開發的一門面向對象的編程語言。起初,java被稱為0ak,來經過發展0ak改名為java,與1995年的五月份正式向大家發布。

一、java類的實例化順序

java的實例化順序在繼承沒有的情況

單獨一個類的場景下,初始化順序為依次為靜態數據,繼承的基類的構造函數,成員變數,被調用的構造函數。

其中靜態數據只會初始化一次。(靜態數據包括靜態代碼塊和靜態變數,每個類的靜態數據只會初始化一次)

在繼承的情況下

添加兩個基類,讓繼承父親,父親繼承祖父。

繼承的情況就比較復雜了。由繼承了基類,還將往上回溯,遞歸地調用基類的無參構造方法。

在我們的例子中,在初始化靜態數據後,會先往上追溯,調用父的默認構造方法,此時再往上追溯到爺爺的默認構造方法。


無論是java還是什麼別的東西他都體現了現代社會與信息技術的不斷發展,人們在進行進行技術開發時也有了越來越多的方法。程序類的工作也有了更為快捷的方法,這為信息技術的發展也提供了更好的發展方法

2. java如何創建一個類的多個實例

1、定義一個類

publicclassA{//定義一個類
}

2、根據類new多個實例

Aa1=newA();//第一個實例
Aa2=newA();//第二個實例

3. Java中實例是什麼意思

A a = new A();
其中A叫類型;a叫變數;new A() 叫實例化對象,簡稱實例。
a也叫實例,因為變數的值就是實例化對象嘛。不太嚴格的話,一般叫a實例是可以的。

4. 在java中 什麼叫 實例方法

Java中類的方法分為類方法(用static修飾,也叫靜態方法)和實例方法(沒有用static修飾,也叫非靜態方法),我們來了解下兩者的區別。
1.實例方法
當類的位元組碼文件載入到內存中時,類的實例方法並沒有被分配入口地址,只有當該類的對象創建以後,實例方法才分配了入口地址。從而實例方法可以被類創建的所有對象調用,還有一點需要注意,當我們創建第一個類的對象時,實例方法的入口地址會完成分配,當後續在創建對象時,不會再分配新的入口地址,也可以說,該類的所有對象共享實例方法的入口地址,當該類的所有對象被銷毀,入口地址才會消失。
2.類方法
當類的位元組碼文件載入到內存,類方法的入口地址就會分配完成,所以類方法不僅可以被該類的對象調用,也可以直接通過類名完成調用。類方法的入口地址只有程序退出時消失。

5. java中實例和對象有什麼區別

對象的名字看你怎麼理解,我們有時以變數名也就是對象的引用名稱之, 以特指這個變數的對象,有時我們以其所屬類名稱之,以泛指所有相關的對象,此時與類對象只有一個 類 字之差
java中萬物皆對象,實例是其中一種對象的稱呼,
相當於從「模板」(類)中創造出實際的「物品」(對象),我們說這個對象是這個類的實例
比如Person p=new Person()
這里的對象叫實例對象,這里的對象相當於實際的「物品」,他是從「模板」中創造的,未必是new出來的,只要符合這個原則就是實例
比如Class p=Person.class
這里的對象叫類對象,因為類相當於「模板」,並不是new Person()這種實際的「物品」

6. java中反射實例類裝載的步驟及簡要闡述

java反射和類裝載

反射機制:

Person p=new Person();
這是什麼?當然是實例化一個對象了.可是這種實例化對象的方法存在一個問題,那就是必須要知道類名才可以實例化它的對象,這樣我們在應用方面就會受到限制.那麼有沒有這樣一種方式,讓我們不知道這個類的類名就可以實例化它的對象呢?Thank Goodness!幸虧我們用的是java, java就提供了這樣的機制.

1).java程序在運行時可以獲得任何一個類的位元組碼信息,包括類的修飾符(public,static等),基類(超類,父類),實現的介面,欄位和方法等信息.
2).java程序在運行時可以根據位元組碼信息來創建該類的實例對象,改變對象的欄位內容和調用對象方法.
這樣的機制就叫反射技術.可以想像光學中的反射,就像我們照鏡子,鏡子中又出現一個自己(比喻可能不太恰當,但是足以表達清楚意思了).反射技術提供了一種通用的動態連接程序組件的方法,不必要把程序所需要的目標類硬編碼到源程序中,從而使得我們可以創建靈活的程序.

反射的實現步驟( 不問不需要答) ,

1、獲取類的常用方式有三種: a) Class.forName("包名.類名"),最常用、推薦;b) 包名.類名.class 最簡捷;c) 對象.getClass 的方式獲得。

2、對象的實例化,上面已經獲取了類,只需要調用類的實例化方法,類.newInstance()便可。

3、獲取屬性和構造等,可以參考 JavaApi 的調用,類. getDeclaredFields,類. getConstructor(..)等。

Java的反射機制是通過反射API來實現的,它允許程序在運行過程中取得任何一個已知名稱的類的內部信息.反射API位於java.lang.reflect包中.主要包括以下幾類:
1).Constructor類:用來描述一個類的構造方法
2).Field類:用來描述一個類的成員變數
3).Method類:用來描述一個類的方法.
4).Modifer類:用來描述類內各元素的修飾符
5).Array:用來對數組進行操作.
Constructor,Field,Method這三個類都是JVM(虛擬機)在程序運行時創建的,用來表示載入類中相應的成員.這三個類都實現了java.lang.reflect.Member介面,Member介面定義了獲取類成員或構造方法等信息的方法.要使用這些反射API,必須先得到要操作的對象或類的Class類的實例.通過調用Class類的newInstance方法(只能調用類的默認構造方法)可以創建類的實例.這樣有局限性,我們可以先沖類的Class實例獲取類需要的構造方法,然後在利用反射來創建類的一個實例.

類載入機制:



類的載入機制可以分為載入-鏈接-初始化三個階段,鏈接又可以分為驗證、准備、解析三個過程。

載入:通過類的載入器查找並載入二進制位元組流的過程,在堆內存中的方法區生成 一個代表這個類的 java.lang.Class 對象,作為這個類的數據請求入口。(這里可以把上面類載入器載入文件的過程描述一下(參考版本一,不作重復))。

驗證:主要是對一些詞法、語法進行規范性校驗,避免對 JVM 本身安全造成危害; 比如對文件格式,位元組碼驗證,無數據驗證等。但驗證階段是非必須的,可以通過參數 設置來進行關閉,以提高載入的時效。

准備:對類變數分配內存,並且對類變數預初始化,初始化成數據類型的原始值, 比如 static int a=11,會被初始化成成 a=0;如果是 static double a =11,則會被初始化成 a=0.0; 而成員變數只會成實例化後的堆中初始化。

解析:把常量池中的符號引用轉換為直接引用的過程。

初始化:對類的靜態變數和靜態塊中的變數進行初始化。(上面的准備階段可以作為 預初始化,初始到變數類型的原值,但如果被 final 修飾會進行真正初始化)

上面載入、鏈接、初始化的各個階段並不是彼此獨立,而是交叉進行,這點很重要 。

***class.forName和 classloader的區別

Class.forName 和 ClassLoader 都是用來裝載類的,對於類的裝載一般為分三個階段載入、鏈接、編譯,它們裝載類的方式是有區別。

首先看一下 Class.forName(..),forName(..)方法有一個重載方法 forName(className,boolean,ClassLoader),它有三個參數,第一個參數是類的包路徑,第二個參數是 boolean

類型,為 true 地表示 Loading 時會進行初始化,第三個就是指定一個載入器;當你調用class.forName(..)時,默認調用的是有三個參數的重載方法,第二個參數默認傳入 true,第三個參數默認使用的是當前類載入時用的載入器。

ClassLoader.loadClass()也有一個重載方法,從源碼中可以看出它默認調的是它的重載 方法 loadClass(name, false),當第二參數為 false 時,說明類載入時不會被鏈接。這也是兩者之間最大區別,前者在載入的時候已經初始化,後者在載入的時候還沒有鏈接。如果你需要在載入時初始化一些東西,就要用 Class.forName 了,比如我們常用的驅動載入, 實際上它的注冊動作就是在載入時的一個靜態塊中完成的。所以它不能被 ClassLoader 載入代替。

7. java中如何以給定的字元串為名字創建某個類的實例

可以用反射根據給定的類名來動態生成實例

比如你定義了一個類

packagesample;

/**
*Createdbypseudoon15-9-16.
*/
publicclassTestClass{
privateStringname;

publicTestClass(Stringname){
this.name=name;
}

@Override
publicStringtoString(){
return"TestClass{"+
"name='"+name+'''+
'}';
}
}

然後使用如下代碼創建這個類的一個實例

publicstaticvoidmain(String[]args)throwsException{
//載入要反射的類
Classclz=Class.forName("sample.TestClass");
//找到類的構造方法
Constructorconstructor=clz.getDeclaredConstructor(String.class);
//使用找到的構造方法創建實例
Objectinstance=constructor.newInstance("Lilei");
System.out.println(instance);
}

這個instance就是需要的結果

8. Java中什麼是類的實例

類就相當於一個模板,實例就是照著模板做的一個東西,打個比方,類是蓋樓房的圖紙,可以照著圖紙蓋好多個樓房,而具體的樓房就是實例

9. JAVA繼承實例

繼承是面向對象編程技術的一塊基石,因為它允許創建分等級層次的類。運用繼承,你能夠創建一個通用類,它定義了一系列相關項目的一般特性。該類可以被更具體的類繼承,每個具體的類都增加一些自己特有的東西。在Java 術語學中,被繼承的類叫超類(superclass ),繼承超類的類叫子類(subclass )。因此,子類是超類的一個專門用途的版本,它繼承了超類定義的所有實例變數和方法,並且為它自己增添了獨特的元素。

繼承一個類,只要用extends 關鍵字把一個類的定義合並到另一個中就可以了。為了理解怎樣繼承,讓我們從簡短的程序開始。下面的例子創建了一個超類A和一個名為B的子類。注意怎樣用關鍵字extends 來創建A的一個子類。

// A simple example of inheritance.
// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
class SimpleInheritance {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}

該程序的輸出如下:

Contents of superOb:
i and j: 10 20

Contents of subOb:
i and j: 7 8
k: 9

Sum of i, j and k in subOb:
i+j+k: 24

像你所看到的,子類B包括它的超類A中的所有成員。這是為什麼subOb 可以獲取i和j 以及調用showij( ) 方法的原因。同樣,sum( ) 內部,i和j可以被直接引用,就像它們是B的一部分。

盡管A是B的超類,它也是一個完全獨立的類。作為一個子類的超類並不意味著超類不能被自己使用。而且,一個子類可以是另一個類的超類。聲明一個繼承超類的類的通常形式如下:

class subclass-name extends superclass-name {
// body of class
}

你只能給你所創建的每個子類定義一個超類。Java 不支持多超類的繼承(這與C++ 不同,在C++中,你可以繼承多個基礎類)。你可以按照規定創建一個繼承的層次。該層次中,一個子類成為另一個子類的超類。然而,沒有類可以成為它自己的超類。

成員的訪問和繼承
盡管子類包括超類的所有成員,它不能訪問超類中被聲明成private 的成員。例如,考慮下面簡單的類層次結構:

/* In a class hierarchy, private members remain private to their class.

This program contains an error and will not compile.
*/

// Create a superclass.

class A {
int i;
private int j; // private to A
void setij(int x, int y) {
i = x; j = y;
}
}
// A"s j is not accessible here.
class B extends A {
int total; void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
class Access {
public static void main(String args[]) {
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}

該程序不會編譯,因為B中sum( ) 方法內部對j的引用是不合法的。既然j被聲明成private,它只能被它自己類中的其他成員訪問。子類沒權訪問它。

注意:一個被定義成private 的類成員為此類私有,它不能被該類外的所有代碼訪問,包括子類。

更實際的例子
讓我們看一個更實際的例子,該例子有助於闡述繼承的作用。新的類將包含一個盒子的寬度、高度、深度。

// This program uses inheritance to extend Box.

class Box {
double width; double height; double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume double
volume() {
return width * height * depth;
}
}

BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight
BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
double vol;
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
System.out.println("Weight of mybox1 is " + mybox1.weight);
System.out.println();
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
System.out.println("Weight of mybox2 is " + mybox2.weight);
}
}

該程序的輸出顯示如下:

Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3

Volume of mybox2 is 24.0
Weight of mybox2 is 0.076

BoxWeight 繼承了Box 的所有特徵並為自己增添了一個weight 成員。沒有必要讓BoxWeight 重新創建Box 中的所有特徵。為滿足需要我們只要擴展Box就可以了。

繼承的一個主要優勢在於一旦你已經創建了一個超類,而該超類定義了適用於一組對象的屬性,它可用來創建任何數量的說明更多細節的子類。每一個子類能夠正好製作它自己的分類。例如,下面的類繼承了Box並增加了一個顏色屬性:

// Here, Box is extended to include color.
class ColorBox extends Box {
int color; // color of box
ColorBox(double w, double h, double d, int c) {
width = w;
height = h;
depth = d;
color = c;
}
}

記住,一旦你已經創建了一個定義了對象一般屬性的超類,該超類可以被繼承以生成特殊用途的類。每一個子類只增添它自己獨特的屬性。這是繼承的本質。

超類變數可以引用子類對象
超類的一個引用變數可以被任何從該超類派生的子類的引用賦值。你將發現繼承的這個方面在很多條件下是很有用的。例如,考慮下面的程序:

class RefDemo {
public static void main(String args[]) {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box(); double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " + weightbox.weight);
System.out.println();
// assign BoxWeight reference to Box reference
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
/* The following statement is invalid because plainbox does not define a weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
}

這里,weightbox 是BoxWeight 對象的一個引用,plainbox 是Box對象的一個引用。既然BoxWeight 是Box的一個子類,允許用一個weightbox 對象的引用給plainbox 賦值。

當一個子類對象的引用被賦給一個超類引用變數時,你只能訪問超類定義的對象的那一部分。這是為什麼plainbox 不能訪問weight 的原因,甚至是它引用了一個BoxWeight 對象也不行。仔細想一想,這是有道理的,因為超類不知道子類增加的屬性。這就是本程序中的最後一行被注釋掉的原因。Box的引用訪問weight 域是不可能的,因為它沒有定義。

熱點內容
榮威編程 發布:2024-05-26 07:08:28 瀏覽:882
理發店wifi密碼是什麼 發布:2024-05-26 07:08:19 瀏覽:884
編程百分率 發布:2024-05-26 06:44:42 瀏覽:828
分卷壓縮包解壓不完整 發布:2024-05-26 06:28:03 瀏覽:529
a連接未訪問 發布:2024-05-26 06:04:25 瀏覽:268
安卓游戲都哪裡下載 發布:2024-05-26 06:04:07 瀏覽:598
浙江機械網路配置有哪些 發布:2024-05-26 05:50:23 瀏覽:394
郵政怎麼修改登錄密碼是什麼 發布:2024-05-26 05:41:00 瀏覽:279
window10無法訪問指定 發布:2024-05-26 05:35:56 瀏覽:469
如何修改鎖頭密碼 發布:2024-05-26 05:30:06 瀏覽:850