『壹』 java怎麼獲取本機的用戶名或域
java怎麼獲取本機的用戶名或域可通過System.getEnv（）得到。
System.getenv("USERNAME");System.getenv("USERDOMAIN");
它常和System.getProperties（）配合使用，它們的區別是：
從概念上講，系統屬性 和環境變數 都是名稱與值之間的映射。兩種機制都能用來將用戶定義的信息傳遞給 Java 進程。環境變數產生更多的全局效應，因為它們不僅對Java 子進程可見，而且對於定義它們的進程的所有子進程都是可見的。在不同的操作系統上，它們的語義有細微的差別，比如，不區分大小寫。因為這些原因，環境變數更可能有意料不到的副作用。最好在可能的地方使用系統屬性。環境變數應該在需要全局效應的時候使用，或者在外部系統介面要求使用環境變數時使用（比如 PATH）。
Map<String, String> map = System.getenv();
String userName = map.get("USERNAME");// 獲取用戶名
String computerName = map.get("COMPUTERNAME");// 獲取計算機名
String userDomain = map.get("USERDOMAIN");// 獲取計算機域名
System.out.println("自定義變數getenv CONF_LOCATION:" +System.getenv("conf.location"));
System.out.println("操作系統的名稱:"+System.getProperty("os.name"));
其它常用的屬性參數如下：
java.version Java 運行時環境版本 java.vendor Java 運行時環境供應商 java.vendor.url Java 供應商的 URL java.home Java 安裝目錄 java.vm.specification.version Java 虛擬機規范版本 java.vm.specification.vendor Java 虛擬機規范供應商 java.vm.specification.name Java 虛擬機規范名稱 java.vm.version Java 虛擬機實現版本 java.vm.vendor Java 虛擬機實現供應商 java.vm.name Java 虛擬機實現名稱 java.specification.version Java 運行時環境規范版本 java.specification.vendor Java 運行時環境規范供應商 java.specification.name Java 運行時環境規范名稱 java.class.version Java 類格式版本號 java.class.path Java 類路徑 java.library.path 載入庫時搜索的路徑列表 java.io.tmpdir 默認的臨時文件路徑 java.compiler 要使用的 JIT 編譯器的名稱 java.ext.dirs 一個或多個擴展目錄的路徑 os.name 操作系統的名稱 os.arch 操作系統的架構 os.version 操作系統的版本 file.separator 文件分隔符（在 UNIX 系統中是「/」 ） path.separator 路徑分隔符（在 UNIX 系統中是「:」 ） line.separator 行分隔符（在 UNIX 系統中是「/n」 ） user.name 用戶的賬戶名稱 user.home 用戶的主目錄 user.dir 用戶的當前工作目錄
『貳』 java 數組也算一個類嗎
不管在其他語言中是什麼，數組在Java中可得看作一個對象，它有一些值得探討的特性。
Java中的數組其實是一個對象，但是確實是一個特殊的對象，實在是太特殊了，以致我們都不好把它多做對象處理。
java是純面向對象的語言，數組也是一個對象。
首先我們看一下表面現象，數組創建的時候採用的是如下語句：
MyClass[] arr = new MyClass[9];
而普通類採用的是如下語句：
MyClass obj = new MyClass();
就是說，創建數組的時候不使用小括弧傳參。使得數組和普通類看起來就有很多不同，因為小括弧里的參數是傳遞給構造方法的，進而讓人感覺數組類是沒有構造方法的。
2）java中數組是對象的依據：
數組的父類是Object，
new Object[0].getClass().getSuperClass() 是Object.class
數組沒有對應的類文件，String對應String.class.數組卻沒有，而且他們的 類名字很古怪，可以這樣獲得 new int[2].getClass().getName();
這是和其他對象最大的不同點，因為數組類是在運行時生成的。
java.lang.reflect.Array是final的，所以數組肯定不是它的子類，這個類用來動態生成數組或者操作數組(獲得長度等)
再往深了想，還有很多讓人感覺不自然的東西。可以肯定的是，java確實將數組作為了一個類來處理。還是用上面的例子說明：
可以通過以下方法得到MyClass[]的Class實例：arr.getClass()或MyClass[].class。這樣，我就可以向數組類裡面「窺探」了。
Class clazz = MyClass[].class;
System.out.println(clazz.getConstructors().length);
列印出來的結果是0；證明數組類確實沒有構造方法。
數組類的「廬山真面目」：
System.out.println(clazz);
輸出是：
[Larraytest.MyClass
對Java
Class文件結構稍有了解就知道，這個字元串的意思就是一個元素類型為arraytest.MyClass的一維數組。也就是說，數組類型不是和普通類
一樣，以一個全限定路徑名+類名來作為自己的唯一標示的，而是以[+一個或者多個L+數組元素類全限定路徑+類來最為唯一標示的。這個()也是數組和普通
類的區別。而這個區別似乎在某種程度上說明數組和普通java類在實現上有很大區別。因為java虛擬機(java指令集)在處理數組類和普通類的時候，
肯定會做出區分。我猜想，可能會有專門的java虛擬機指令來處理數組。
分析到這里，基本上可以肯定：java對數組對象化的操作的支持是指令級的，也就是說java虛擬機有專門針對數組的指令。數組的Class類實例是java虛擬機動態創建動態載入的，其結構與普通java類的Class實例有一些不同。
JDK API中有一個java.lang.reflect.Array類，這個類提供了很多方法(絕大多數是native方法，這在另一個方面證明了java對數組的支持是專用指令支持的，否則用本地方去幹嘛，用來彌補我們對數組操作的局限性。
下面這句話用來創建一個一維的、長度為10的、類型為arraytest.MyClass的數組：
arraytest.MyClass[] arr = (arraytest.MyClass[]) Array.newInstance(arraytest.MyClass, 10);
下面這句話用來創建一個二維的、3乘5的、類型為arraytest.MyClass的數組：
int[] arrModel = new int[]{3,5};
Object arrObj = Array.newInstance(Sub.class, arrModel);
當然你可以用一個數組的引用指向上面的二維數組，這里我們用一個Object的引用指向他。
使用的時候，我們也是可以利用Array類提供的方法來實現：
System.out.println(Array.getLength(arrObj);//第一維長度為3
System.out.println(Array.getLength(Array.get(arrObj, 2)));//第二維長度為5，這里如果寫3，就會得到你意想之中的java.lang.
列印結果是如我所想的：
3
5
對於數組的Class類實例，還有一些奇怪的現象：
在運行代碼 java.lang.reflect.Field fieldarr =
clazz.getField("length");的時候，會拋出異常：java.lang.NoSuchFieldException:
length，這似乎在說數組類沒有length這個域，而這個域其實是我們用的最多的一個（也就是說這個域是肯定存在的）。我想關於數組的Class類
實例、數組的實現等，還有很多「貓膩」在裡面。
順便說一句，java數組最多隻能是255維的。這個讓人看到了C的影子，嘿嘿。
「Java把數組當作一個java類來處理」說起來容易，用起來自然，但是細細想來，還是有很多不簡單的地方呀。
從對數組對象的進一步探討，可以稍微了解Java對對象處理的一些方法。首先來看看一維數組的引用名稱的定義：
int[] arr = null;
在這個定義中，arr表示一個可以參考引用自一維數組對象的變數名稱，但是目前將這個名稱參考引用自null，表示還沒有指定這個名稱參考引用自實際的對
象。在Java中，=運算用於基本數據類型時，是將值復制給變數，但當它用於對象時，則是將對象指定給參考引用名稱來參考引用。也可以將同一個對象指定給
兩個參考引用名稱，當對象的值由其中一個參考引用名稱進行操作而變更時，另一個參考引用名稱所參考引用到的值也會變動。下面來看看範例5.8的示範。
ü 範例5.8 AdvancedArray.java
public class AdvancedArray {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] tmp1 = arr1;
int[] tmp2 = arr1;
System.out.print("通過tmp1取出數組值：");
for(int i = 0; i < tmp1.length; i++)
System.out.print(tmp1[i] + " ");
System.out.print("\n通過tmp2取出數組值：");
for(int i = 0; i < tmp2.length; i++)
System.out.print(tmp2[i] + " ");
tmp1[2] = 9;
System.out.print("\n\n通過tmp1取出數組值：");
for(int i = 0; i < tmp1.length; i++)
System.out.print(tmp1[i] + " ");
System.out.print("\n通過tmp2取出數組值：");
for(int i = 0; i < tmp2.length; i++)
System.out.print(tmp2[i] + " ");
System.out.println();
}
}
執行結果：
通過tmp1取出數組值：1 2 3 4 5
通過tmp2取出數組值：1 2 3 4 5
通過tmp1取出數組值：1 2 9 4 5
通過tmp2取出數組值：1 2 9 4 5
在這個範例中，通過tmp1名稱改變了索引2的元素值，由於tmp2也引用自同一數組對象，所以tmp2取出索引2的元素值是改變後的值。事實上在範例
5.8中，有三個引用名稱引用自同一個數組對象，也就是arr1、tmp1與tmp2，所以，如果取出arr1索引2的元素，元素值也會是9。
了解到在Java中數組是一個對象，而使用=指定時是將對象指定給數組名來引用，而不是將數組進行復制。如果想將整個數組的值復制給另一個數組該如
何作呢？可以使用循環，將整個數組的元素值遍歷一遍，並指定給另一個數組相對應的索引位置。範例5.10示範了進行數組復制的方法。
Ü範例5.10 ArrayCopy.java
public class ArrayCopy {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = new int[5];
for(int i = 0; i < arr1.length; i++)
arr2[i] = arr1[i];
for(int i = 0; i < arr2.length; i++)
System.out.print(arr2[i] + " ");
System.out.println();
}
}
執行結果：
1 2 3 4 5
另一個進行數組復制的方法是使用System類提供的array()方法。其語法如下：
System.array(來源, 起始索引, 目的, 起始索引, 復制長度);
範例5.11改寫了範例5.10，使用System.array()進行數組復制，執行結果與範例5.10是相同的。
Ü範例5.11 ArrayCopy2.java
public class ArrayCopy2 {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = new int[5];
System.array(arr1, 0, arr2, 0, arr1.length);
for(int i = 0; i < arr2.length; i++)
System.out.print(arr2[i] + " ");
System.out.println();
}
}
四、 Java中的數組作為對象帶來的好處
1）越界檢查
2）length field：與傳統的C++中的數組相比，length欄位可以方便的得到數組的大小；但要注意，僅僅可以得到數組的大小，不能得到數組中實際包含多少個元素，因為length 只會告訴我們最多可將多少元素置入那個數組。
3） 初始化：對象數組在創建之初會自動初始化成null，由原始數據類型構成的數組會自動初始化成零（針對數值類型），(Char)0 （針對字元類型）或者false （針對布爾類型）。
4） 數組作為返回值：首先，既然數組是對象，那麼就可以把這個對象作為返回值；而且，不必擔心那個數組的是否可用只要需要它就會自動存在而且垃圾收集器會在我們完成後自動將其清除
『叄』 java的介面、類、屬性、方法各有哪些修飾符
1、 介面的修飾符只有：public 2、 類的修飾符分為：可訪問控制符和非訪問控制符兩種。 可訪問控制符是：公共類修隱氏手飾符 public 非訪問控制符有：抽象類修飾符 abstract ；最終類修飾符 final 1、公共類修飾符public： Java 語言中類 的可訪問控制符只有一個： public 即公共的。每個 Java 程序的主類都必須是 public 類作為公共工具供其它類和程序使用的應定義為 public 類。 2 、抽象類修飾符abstract：凡是用 abstract 修飾符修飾的類，被稱為抽象類。所謂抽象類是指這種類沒有具體對象的一種概念類。這樣的類就是 Java 語言的 abstract 類。 3、最終類修飾符final：當一個類不可能有子類時可用修飾符 final 把它說明為最終類。被定義為 final 的類通常是一些有固定作用、用來完成某種標准功能的類。 4、類預設訪問控制符：如果一個類沒有訪問控制符，說明它具有預設的訪問控制符特性。此時，這個類只能被同一個包中的類訪問或引用。這一訪問特性又稱為包訪問性。 3、屬性的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。 可訪問控制符有 4 種：公共訪問控制符： public ；私有訪問控制符： private ；保護訪問控制符： protected ；私有保護訪問控制符： private protected 非訪問控制符有 4 種：靜態域修飾符： static ；最終域修飾符： final ；易失 ( 共享 ) 域修飾符： volatile ；暫時性域修飾符： transient 1、公共訪問控制符 public ：用 public 修飾的域稱為公共域。如果公共域屬於一個公共類，則可以被所有其它類所引用。由於 public 修飾符會降低運行的安全性和數據的封裝性，所以一般應減少 public 域的使用。 2、私有訪問控制符 private ： 用 private 修飾的成員變數 ( 域 ) 只能被該類自身所訪問，而不能被任何其它類 ( 包括子類 ) 所引用。 3、保護訪問控制符 protected ：用 protected 修飾的成員變數可以被三種類所引用：①該類自身；②與它在同一個包中的其它類；③在其它包中的該類的子類。使用修飾符 protected 的主要作用是允許其它包中它的子類來訪問父類的特定屬性。 4、私有保護訪問控制符 private protected ：用修飾符 private protected 修飾的成員變數可以被該類本身或該類的子類兩種類訪問和引用。 5、靜態域修飾符 static ：用 static 修飾的成員變數僅屬於類的變數，而不屬於任何一個具體的對象，靜態成員變數的值是保存在類的內存區域的公共存儲單元，而不是保存在某一個對象的內存區間。任何一個類的對象訪問它時取到的都是相同的數據；任何一個類的對象修改它時 , 也都是對同一個內存單元進行操作。 6、最終域修飾符 final ：最終域修飾符 final 是用來定義符號常量的。一個類的域 ( 成員變數 ) 如果被修飾符 final 說明，則它的取值在程序的整個執行過程中都是不變的。 7、易失 ( 共享 ) 域修飾符 volatile ：易失 ( 共享 ) 域修飾符 volatile 是用來說明這個成員變數可能被幾個線程所控制和修改。也就是說在程序運行過灶嫌程中，這個成員變數有可能被其它的程序影響或改變它的取值。因此，在使用中要注意這種成員變數取值的變化。通常 volatile 用來修飾接受外部輸入的域。 8、暫時性域修飾符 transient ：暫時性域修飾符 transient 用來定義一個暫時性變數。其特點是：用修飾符 transient 限定的暫時性變數，將指定 Java 虛擬機認定該暫時性變數不屬於永久狀態，以實現不同對象核慎的存檔功能。否則，類中所有變數都是對象的永久狀態的一部分，存儲對象時必須同時保存這些變數。 4、方法的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。 可訪問控制符有 4 種：公共訪問控制符： public ；私有訪問控制符： private ；保護訪問控制符： protected ；私有保護訪問控制符： private protected 非訪問控制符有 5 種：抽象方法控制符： abstract ；靜態方法控制符： static ；最終方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized 1、抽象方法控制符 abstract ：用修飾符 abstract 修飾的方法稱為抽象方法。抽象方法是一種僅有方法頭，沒有方法體和操作實現的一種方法。 2、靜態方法控制符 static ：用修飾符 static 修飾的方法稱為靜態方法。靜態方法是屬於整個類的類方法；而不使用 static 修飾、限定的方法是屬於某個具體類對象的方法。 由於 static 方法是屬於整個類的，所以它不能操縱和處理屬於某個對象的成員變數，而只能處理屬於整個類的成員變數，即 static 方法只能處理 static 的域。 3、最終方法控制符 final ：用修飾符 final 修飾的方法稱為最終方法。最終方法是功能和內部語句不能更改的方法，即最終方法不能重載。這樣，就固定了這個方法所具有的功能和操作，防止當前類的子類對父類關鍵方法的錯誤定義，保證了程序的安全性和正確性。所有被 private 修飾符限定為私有的方法，以及所有包含在 final 類 ( 最終類 ) 中的方法，都被認為是最終方法。 4、本地方法控制符 native ：用修飾符 native 修飾的方法稱為本地方法。為了提高程序的運行速度，需要用其它的高級語言書寫程序的方法體，那麼該方法可定義為本地方法用修飾符 native 來修飾； 5、同步方法控制符 synchronized ：該修飾符主要用於多線程共存的程序中的協調和同步。
『肆』 Java中的四種訪問控制域是什麼
private,public,protected,默認不寫（firendly)
1、Class類的訪問許可權：
public：可以供所有的類訪問。
默認：默認可以稱為friendly但是，java語言中是沒有friendly這個修飾符的，這樣稱呼應該是來源於c++。默認的訪問許可權是包級訪問許可權。
即如果寫了一個類沒有寫訪問許可權修飾符，那麼就是默認的訪問許可權，同一個包下的類都可以訪問到，即使可以實例化該類
（當然如果這個類不具有實例化的能力除外，比如該類沒有提供public的構造函數）。
說明：
1、每個編譯單元（類文件）都僅能有一個public class
2、public class的名稱（包含大小寫）必須和其類文件同名。
3、一個類文件(*.java)中可以不存在public class。
這種形式的存在的場景：如果我們在某個包內撰寫一個class，僅僅是為了配合同包內的其他類工作，而且
我們不想再為了撰寫說明文檔給客戶（不一定是現實意義的客戶，可能是調用這個類的類）看而傷腦筋，而且有可能過一段時間之後
有可能會徹底改變原有的做法，並完全舍棄舊版本，以全新的版本代替。
4、class不可以是private和protected。
5、如果不希望那個任何產生某個class的對象，可以將該類得所有構造函數設置成private。但是即使這樣也可以生成該類的對象，就是class的static的成員（屬性和方法）可以辦到。
2、類成員變數的訪問許可權：
public：緊接public的屬性任何類都可以訪問到。可以直接使用ClassName.propertyName。但是從類的封裝性上來考慮將一個類的屬性定義成public一般很少使用，
在定義靜態常量的時候通暢會這樣定義。如：public static final int PAGE_SIZE=10;
private：只有類本身內部的方法可以訪問類的private屬性，當然內部類也可以訪問其外部類的private成員的。（屬性和方法）
默認（friendly）：包級可見，同一個包內的類可以訪問到這個屬性，可以直接使用className.propertyName來訪問，但是從類的封裝性特性來說很少這樣使用類的屬性的。
protected：關鍵字所處理的是所謂「繼承」的觀念。對於同一包的其他類，protected＝默認，對於不同包的類，如果存在繼承關系，而baseClass存在protected屬性，則可以被其自繼承，而不同包的其他類
則不能訪問類的protected屬性。
3、類的成員方法的訪問許可權：
其從語法角度來講，這些訪問許可權控制符作用於類的方法和作用於類的屬性上的效果是一樣的。
public：所有類可見。
pirvate：只有同一類內部的方法可見，在有就是內部類也可以訪問到。
默認（friendly）：包內可見。
protected:繼承可見。
4、訪問許可權存在的理由
1、「讓使用者無法碰觸到他們不該碰觸的東西。」這些東西僅供類的內部機制使用。將某些成員聲明成private，對於使用者來說可以說是一種服務，
因為這樣使用者可以知道哪些是他關注的哪些是不重要的，不需要關注，如此歷來對於使用來說降低了對使用對象認識的難度。
2、（最終要的理由）讓程序設計者可以更動class內部運作方式，而無須擔心波及到客戶端程序。
5、java的「訪問許可權修飾符」賦予classes開發者極具有價值的控制能力。身為classes開發者，如果你的任何改變可以完全不幹擾你的使用者，
你便可以安心改變你的底層實現，因為客戶端程序員無法訪問class的這一部分。
通過今天學習訪問許可權的問題了解到，介面或者抽象等等策略所謂的「實現隱藏」其根本原因並不是說為了隱藏實現的代碼和思路，而是降低使用者的使用難度，以及從維護角度來說可見范圍的控制給程序維護帶來了極大的安全性。