java類實例

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 域是不可能的，因為它沒有定義。