java類機制
⑴ java提供了一種稱為「內部類」的機制，使類可以在其他類中定義
不可以， 內部類只能在自己類裡面使用
除非是靜態內部類，靜態內部類就跟普通靜態類一樣
這是Java基礎，值得好好理解
⑵ 簡述java類型轉換機制。
string和int之間的轉換?
字元串轉換成數據
Java代碼
String MyNumber ="1234";
int MyInt = Integer.parseInt(MyNumber);
String MyNumber ="1234";
int MyInt = Integer.parseInt(MyNumber);
字元串轉換成byte, short, int, float, double, long等數據類型，可以分別參考Byte, Short, Integer, Float, Double, Long類的parseXXX 方法。
Java代碼
a1=Integer.parseInt(s1);
s1=Integer.toString(a1);
a1=Integer.parseInt(s1);
s1=Integer.toString(a1);
數據轉換成字元串
Java代碼
int MyInt = 1234;
String MyString = "" + MyInt;
int MyInt = 1234;
String MyString = "" + MyInt;
其它數據類型可以利用同樣的方法轉換成字元串。
十進制到其他進制的轉換
十進制整數轉換成二進制整數，返回結果是一個字元串：
Integer.toBinaryString(int i);
Integer和Long提供了toBinaryString, toHexString和toOctalString方法，可以方便的將數據轉換成二進制、十六進制和八進制字元串。功能更加強大的是其 toString(int/long i, int radix)方法，可以將一個十進制數轉換成任意進制的字元串形式。
byte, short, float和double等數據類型，可以利用Integer或者是Long的toBinaryString, toHexString, to OctalString和toString方法轉換成其他進制的字元串形式。
其它進制到十進制的轉換
五進制字元串14414轉換成十進制整數，結果是1234：
System.out.println(Integer.valueOf("14414", 5);
Integer和Long提供的valueOf(String source, int radix)方法，可以
將任意進制的字元串轉換成十進制數據。
把String類型轉換成16進制的整數
Java代碼
public static void main(String args[]){
String x = "0x300C8";
int y = Integer.decode(x).intvalue();
System.out.println(y);
}
public static void main(String args[]){
String x = "0x300C8";
int y = Integer.decode(x).intvalue();
System.out.println(y);
}
int、char、double與byte相互轉換的程序
整數到位元組數組的轉換
Java代碼
public static byte[] intToByte(int number) {
int temp = number;
byte[] b=new byte[4];
for (int i=b.length-1;i>-1;i--){
b[i] = new Integer(temp&0xff).byteValue(); //將最高位保存在最低位
temp = temp >> 8; //向右移8位
}
return b;
}
public static byte[] intToByte(int number) {
int temp = number;
byte[] b=new byte[4];
for (int i=b.length-1;i>-1;i--){
b[i] = new Integer(temp&0xff).byteValue(); //將最高位保存在最低位
temp = temp >> 8; //向右移8位
}
return b;
}
位元組數組到整數的轉換
Java代碼
public static int byteToInt(byte[] b) {
int s = 0;
for (int i = 0; i < 3; i++) {
if (b[i] >= 0)
s = s + b[i];
else
s = s + 256 + b[i];
s = s * 256;
}
if (b[3] >= 0) //最後一個之所以不乘，是因為可能會溢出
s = s + b[3];
else
s = s + 256 + b[3];
return s;
}
public static int byteToInt(byte[] b) {
int s = 0;
for (int i = 0; i < 3; i++) {
if (b[i] >= 0)
s = s + b[i];
else
s = s + 256 + b[i];
s = s * 256;
}
if (b[3] >= 0) //最後一個之所以不乘，是因為可能會溢出
s = s + b[3];
else
s = s + 256 + b[3];
return s;
}
短整數與位元組數組之間的相互轉換
short與int之間的區別在於short是兩個位元組的，而int是四個位元組的。因此，只需要將5 與6 中的范常式序小做改動，即可實現短整數與位元組數組之間的相互轉換。
字元到位元組轉換
Java代碼
public static byte[] charToByte(char ch){
int temp=(int)ch;
byte[] b=new byte[2];
for (int i=b.length-1;i>-1;i--){
b[i] = new Integer(temp&0xff).bytevalue(); //將最高位保存在最低位
temp = temp >> 8; //向右移8位
}
Java中的強制類型轉換,如果這2種類型是兼容的，那麼Java 將自動地進行轉換。例如，把int 類型的值賦給long 類型的變數，總是可行的。然而，不是所有的類型都是兼容的，因此，不是所有的類型轉換都是可以隱式實現的。例如，沒有將double 型轉換為byte 型的定義。幸好，獲得不兼容的類型之間的轉換仍然是可能的。要達到這個目的，你必須使用一個強制類型轉換，它能完成兩個不兼容的類型之間的顯式變換。讓我們看看自動類型轉換和強制類型轉換。
一．Java 的自動轉換
如果下列2個條件都能滿足，那麼將一種類型的數據賦給另外一種類型變數時，將執行自動類型轉換（automatic type conversion）：
1．這2種類型是兼容的。
2．目的類型數的范圍比來源類型的大。
當以上2個條件都滿足時，拓寬轉換（widening conversion ）發生。例如，int 型的范圍比所有byte 型的合法范圍大，因此不要求顯式強制類型轉換語句。
對於拓寬轉換，數字類型，包括整數（integer ）和浮點（floating-point ）類型都是彼此兼容的，但是，數字類型和字元類型（char）或布爾類型（bollean ）是不兼容的。字元類型（char ）和布爾類型（bollean ）也是互相不兼容的。
二． 不兼容類型的強制轉換
盡管自動類型轉換是很有幫助的，但並不能滿足所有的編程需要。例如，如果你需要將int 型的值賦給一個byte 型的變數，你將怎麼辦？這種轉換不會自動進行，因為byte 型的變化范圍比int 型的要小。這種轉換有時稱為「縮小轉換」（），因為你肯定要將源數據類型的值變小才能適合目標數據類型。
為了完成兩種不兼容類型之間的轉換，你就必須進行強制類型轉換。所謂強制類型轉換只不過是一種顯式的類型變換。它的通用格式如下：
(target-type)value
其中，目標類型（target-type ）指定了要將指定值轉換成的類型。例如，下面的程序段將int 型強制轉換成byte 型。如果整數的值超出了byte 型的取值范圍，它的值將會因為對byte 型值域取模（整數除以byte 得到的余數）而減少。
int a;
byte b;
// ...
b = (byte) a;
當把浮點值賦給整數類型時一種不同的類型轉換發生了：截斷（truncation ）。你知道整數沒有小數部分。這樣，當把浮點值賦給整數類型時，它的小數部分會被捨去。例如，如果將值1.23賦給一個整數，其結果值只是1，0.23 被丟棄了。當然，如果浮點值太大而不能適合目標整數類型，那麼它的值將會因為對目標類型值域取模而減少。
下面的程序說明了強制類型轉換：
// Demonstrate casts.
class Conversion {
public static void main(String args[]) {
byte b;
int i = 257;
double d = 323.142;
System.out.println("\nConversion of int to byte.");
b = (byte) i;
System.out.println("i and b " + i + " " + b);
System.out.println("\nConversion of double to int.");
i = (int) d;
System.out.println("d and i " + d + " " + i);
System.out.println("\nConversion of double to byte.");
b = (byte) d;
System.out.println("d and b " + d + " " + b);
}
}
該程序的輸出如下：
Conversion of int to byte.
i and b 257 1
Conversion of double to int.
d and i 323.142 323
Conversion of double to byte.
d and b 323.142 67
讓我們看看每一個類型轉換。當值257被強制轉換為byte 變數時，其結果是257除以256 （256是byte 類型的變化范圍）的余數1。當把變數d轉換為int 型，它的小數部分被舍棄了。當把變數d轉換為byte 型，它的小數部分被舍棄了，而且它的值減少為256 的模，即67。
⑶ java 類載入機制有什麼用
AVA類載入機制詳解
「代碼編譯的結果從本地機器碼轉變為位元組碼，是存儲格式發展的一小步，卻是變成語言發展的一大步」，這句話出自《深入理解JAVA虛擬機》一書，後面關於jvm的系列文章主要都是參考這本書。
JAVA源碼編譯由三個過程組成：
1、源碼編譯機制。
2、類載入機制
3、類執行機制
我們這里主要介紹編譯和類載入這兩種機制。
一、源碼編譯
代碼編譯由JAVA源碼編譯器來完成。主要是將源碼編譯成位元組碼文件（class文件）。位元組碼文件格式主要分為兩部分：常量池和方法位元組碼。
二、類載入
類的生命周期是從被載入到虛擬機內存中開始，到卸載出內存結束。過程共有七個階段，其中到初始化之前的都是屬於類載入的部分
載入----驗證----准備----解析-----初始化----使用-----卸載
系統可能在第一次使用某個類時載入該類，也可能採用預載入機制來載入某個類，當運行某個java程序時，會啟動一個java虛擬機進程，兩次運行的java程序處於兩個不同的JVM進程中，兩個jvm之間並不會共享數據。
1、載入階段
這個流程中的載入是類載入機制中的一個階段，這兩個概念不要混淆，這個階段需要完成的事情有：
1）通過一個類的全限定名來獲取定義此類的二進制位元組流。
2）將這個位元組流所代表的靜態存儲結構轉化為方法區的運行時數據結構。
3）在java堆中生成一個代表這個類的Class對象，作為訪問方法區中這些數據的入口。
由於第一點沒有指明從哪裡獲取以及怎樣獲取類的二進制位元組流，所以這一塊區域留給我開發者很大的發揮空間。這個我在後面的類載入器中在進行介紹。
2、准備階段
這個階段正式為類變數（被static修飾的變數）分配內存並設置類變數初始值，這個內存分配是發生在方法區中。
1、注意這里並沒有對實例變數進行內存分配，實例變數將會在對象實例化時隨著對象一起分配在JAVA堆中。
2、這里設置的初始值，通常是指數據類型的零值。
private static int a = 3;
這個類變數a在准備階段後的值是0，將3賦值給變數a是發生在初始化階段。
3、初始化階段
初始化是類載入機制的最後一步，這個時候才正真開始執行類中定義的JAVA程序代碼。在前面准備階段，類變數已經賦過一次系統要求的初始值，在初始化階段最重要的事情就是對類變數進行初始化，關注的重點是父子類之間各類資源初始化的順序。
java類中對類變數指定初始值有兩種方式：1、聲明類變數時指定初始值；2、使用靜態初始化塊為類變數指定初始值。
初始化的時機
1）創建類實例的時候，分別有：1、使用new關鍵字創建實例；2、通過反射創建實例；3、通過反序列化方式創建實例。
new Test();
Class.forName(「com.mengdd.Test」);
2）調用某個類的類方法（靜態方法）
Test.doSomething();
3）訪問某個類或介面的類變數，或為該類變數賦值。
int b=Test.a;
Test.a=b;
4）初始化某個類的子類。當初始化子類的時候，該子類的所有父類都會被初始化。
5）直接使用java.exe命令來運行某個主類。
除了上面幾種方式會自動初始化一個類，其他訪問類的方式都稱不會觸發類的初始化，稱為被動引用。
1、子類引用父類的靜態變數，不會導致子類初始化。
執行結果：
MIGU
用final修飾某個類變數時，它的值在編譯時就已經確定好放入常量池了，所以在訪問該類變數時，等於直接從常量池中獲取，並沒有初始化該類。
初始化的步驟
1、如果該類還沒有載入和連接，則程序先載入該類並連接。
2、如果該類的直接父類沒有載入，則先初始化其直接父類。
3、如果類中有初始化語句，則系統依次執行這些初始化語句。
在第二個步驟中，如果直接父類又有直接父類，則系統會再次重復這三個步驟來初始化這個父類，依次類推，JVM最先初始化的總是java.lang.Object類。當程序主動使用任何一個類時，系統會保證該類以及所有的父類都會被初始化。
⑷ java兩道題目——類的繼承和多態機制
//vehicle類， public class Vehicle { private float speed; private String kind; private String color; public float getSpeed() { return speed; } public void setSpeed(float speed) { this.speed = speed; } public String getKind() { return kind; } public void setKind(String kind) { this.kind = kind; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } } //汽車類； public class Car extends Vehicle { private int passenger; public int getPassenger() { return passenger; } public void setPassenger(int passenger) { this.passenger = passenger; } @Override public String toString() {//現實所有的屬性 return "speed="+this.getSpeed()+" kind="+this.getKind()+" color="+this.getColor()+" passenger="+this.getPassenger(); } public static void main(String[] args){//測試 Car car=new Car(); car.setSpeed(60.5f); car.setKind("汽車"); car.setColor("blue"); car.setPassenger(5); System.out.println(car.toString()); } } 下面個題馬上發上來，等下！
⑸ Java由已知類創建新類的機制是什麼
Java由已知類創建新類的機制是：繼承。
1、繼承的概念
繼承是java面向對象編程技術的一塊基石，因為它允許創建分等級層次的類。
繼承就是子類繼承父類的特徵和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。
2、類的繼承格式
在 Java 中通過 extends 關鍵字可以申明一個類是從另外一個類繼承而來的，一般形式如下：
class 父類 {
}
class 子類 extends 父類 {
}
3、為什麼要使用繼承
如果不使用繼承，則父類和子類代碼存在大量重復，導致代碼量大且臃腫，而且維護性不高
4、繼承類型
需要注意的是 Java 不支持多繼承（C++支持多繼承），但支持多重繼承。
⑹ Java類載入機制
1，類的載入
每個開發人員對java.lang.ClassNotFoundExcetpion這個異常肯定都不陌生，這背後就涉及到了java技術體系中的類載入。Java的類載入機制是技術體系中比較核心的部分，雖然和大部分開發人員直接打交道不多，但是對其背後的機理有一定理解有助於排查程序中出現的類載入失敗等技術問題，對理解java虛擬機的連接模型和java語言的動態性都有很大幫助。
那麼什麼是類的載入?
類的載入指的是將類的.class文件中的二進制數據讀入到內存中，將其放在運行時數據區的方法區內，然後在堆區創建一個java.lang.Class對象，用來封裝類在方法區內的數據結構。類的載入的最終產品是位於堆區中的Class對象，Class對象封裝了類在方法區內的數據結構，並且向Java程序員提供了訪問方法區內的數據結構的介面。
類載入器是Java語言的一個創新，也是Java語言流行的重要原因之一。它使得Java類可以被動態載入到Java虛擬機中並執行。類載入器從JDK1.0就出現了，最初是為了滿足JavaApplet的需要而開發出來的。JavaApplet需要從遠程下載Java類文件到瀏覽器中並執行。現在類載入器在Web容器和OSGi中得到了廣泛的使用，而類載入器並不需要等到某個類被「首次主動使用」時再載入它，JVM規范允許類載入器在預料某個類將要被使用時就預先載入它，如果在預先載入的過程中遇到了.class文件缺失或存在錯誤，類載入器必須在程序首次主動使用該類時才報告錯誤(LinkageError錯誤)如果這個類一直沒有被程序主動使用，那麼類載入器就不會報告錯誤。
2，類的生命周期
類載入的過程中包括有載入，驗證，准備，解析，初始化五個階段。而需要注意的是在這五個階段中，載入、驗證、准備和初始化這四個階段發生的順序是確定的，而解析階段則不一定，它在某些情況下可以在初始化階段之後開始，這是為了支持Java語言的運行時綁定(也成為動態綁定或晚期綁定)。另外注意這里的幾個階段是按順序開始，而不是按順序進行或完成，因為這些階段通常都是互相交叉地混合進行的，通常在一個階段執行的過程中調用或激活另一個階段。
載入：查找並載入類的二進制數據
載入時類載入過程的第一個階段，在載入階段，虛擬機需要完成以下三件事情：
1、通過一個類的全限定名來獲取其定義的二進制位元組流。(並沒有指明要從一個Class文件中獲取，可以從其他渠道，譬如：網路、動態生成、資料庫等)
2、將這個位元組流所代表的靜態存儲結構轉化為方法區的運行時數據結構。
3、在Java堆中生成一個代表這個類的java.lang.Class對象，作為對方法區中這些數據的訪問入口。
相對於類載入的其他階段而言，載入階段(准確地說，是載入階段獲取類的二進制位元組流的動作)是可控性最強的階段，電腦培訓http://www.kmbdqn.cn/發現因為開發人員既可以使用系統提供的類載入器來完成載入，也可以自定義自己的類載入器來完成載入。
⑺ java的反射機制是什麼
反射技術：其實就是動態載入一個指定的類，並獲取該類中的所有的內容。並將位元組碼文件中的內容都封裝成對象，這樣便於操作這些成員。簡單說：反射技術可以對一個類進行解剖。
反射的好處：大大的增強了程序的擴展性。
反射的基本步驟：
1、獲得Class對象，就是獲取到指定的名稱的位元組碼文件對象。
2、實例化對象，獲得類的屬性、方法或構造函數。
3、訪問屬性、調用方法、調用構造函數創建對象。
⑻ Java異常機制是什麼
異常指不期而至的各種狀況，如：文件找不到、網路連接失敗、非法參數等。異常是一個事件，它發生在程序運行期間，干擾了正常的指令流程。Java通 過API中Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是對象，是Throwable子類的實例，描述了出現在一段編碼中的 錯誤條件。當條件生成時，錯誤將引發異常。
一、相關知識
1、在 Java 中，所有的異常都有一個共同的祖先 Throwable（可拋出）。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。
Throwable： 有兩個重要的子類：Exception（異常）和 Error（錯誤），二者都是 Java 異常處理的重要子類，各自都包含大量子類。
Error（錯誤）:是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。這些錯誤表示故障發生於虛擬機自身、或者發生在虛擬機試圖執行應用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應用程序的控制和處理能力之 外，而且絕大多數是程序運行時不允許出現的狀況。對於設計合理的應用程序來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。
Exception（異常）:是程序本身可以處理的異常。Exception 類有一個重要的子類 RuntimeException。RuntimeException 類及其子類表示「JVM 常用操作」引發的錯誤。例如，若試圖使用空值對象引用、除數為零或數組越界，則分別引發運行時異常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
注意：異常和錯誤的區別：異常能被程序本身可以處理，錯誤是無法處理。
2、通常，Java的異常(包括Exception和Error)分為可查的異常（checked exceptions）和不可查的異常（unchecked exceptions）。
可查異常（編譯器要求必須處置的異常）：正確的程序在運行中，很容易出現的、情理可容的異常狀況。可查異常雖然是異常狀況，但在一定程度上它的發生是可以預計的，而且一旦發生這種異常狀況，就必須採取某種方式進行處理。除了RuntimeException及其子類以外，其他的Exception類及其子類都屬於可查異常。這種異常的特點是Java編譯器會檢查它，也就是說，當程序中可能出現這類異常，要麼用try-catch語句捕獲它，要麼用throws子句聲明拋出它，否則編譯不會通過。
不可查異常(編譯器不要求強制處置的異常):包括運行時異常（RuntimeException與其子類）和錯誤（Error）。
3、Exception 這種異常分兩大類運行時異常和非運行時異常(編譯異常)。程序中應當盡可能去處理這些異常。
運行時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應該從邏輯角度盡可能避免這類異常的發生。運行時異常的特點是Java編譯器不會檢查它，也就是說，當程序中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。
非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬於Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。
二、處理機制
在 Java 應用程序中，異常處理機制為：拋出異常，捕捉異常。
拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象並交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼並執行。
捕獲異常：在方法拋出異常之後，運行時系統將轉為尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即為合適 的異常處理器。運行時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合適異常處理器的方法並執行。當運行時系統遍歷調用棧而未找到合適 的異常處理器，則運行時系統終止。同時，意味著Java程序的終止。
對於運行時異常、錯誤或可查異常，Java技術所要求的異常處理方式有所不同。
由於運行時異常的不可查性，為了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程序忽略運行時異常。
對於方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因為，大多數Error異常屬於永遠不能被允許發生的狀況，也屬於合理的應用程序不該捕捉的異常。
對於所有的可查異常，Java規定：一個方法必須捕捉，或者聲明拋出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常。
能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由於自身語句所引發並拋出的異常，也可能是由某個調用的方法或者Java運行時 系統等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所拋出的異常。簡單地說，異常總是先被拋出，後被捕捉的。
任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。
從方法中拋出的任何異常都必須使用throws子句。
捕捉異常通過try-catch語句或者try-catch-finally語句實現。
總體來說，Java規定：對於可查異常必須捕捉、或者聲明拋出。允許忽略不可查的RuntimeException和Error。