『壹』 弱弱的問下,java里什麼情況下用public,什麼情況下用private
一．Java訪問許可權飾詞（access specifiers）
Java有public、protect、friendly、private四種訪問許可權，並且這四訪問許可權的訪問范圍越來越小。
1． friendly
1） 果一個class內的數據成員或方法沒有任何許可權飾詞，那麼它的預設訪問許可權就是friendly。同一個package內的其它所有classes都可以訪問friendly成員，但對package以外的classes則形同private。
2）對於同一個文件夾下的、沒有用package的classes，Java會自動將這些classes初見為隸屬於該目錄的default package，可以相互調用class中的friendly成員。如以下兩個class分別在同一個文件夾的兩個文件中，雖然沒有引入package， 但隸屬於相同的default package。
class Sundae{
//以下兩個方法預設為friendly
Sundae(){}
Void f() {System.out.println(「Sundae.f()」);
}
public class IceCream{
public static void main(String[] args){
Sundae x = new Sundae();
x.f();
}
}
2． public：可以被任何class調用
3． private：private成員只能在成員所屬的class內被調用，如：
class Sundae{
private Sundae(){}//只能在Sundae class中被調用
Sundae(int i) {}
static Sundae makASundae() {
return new Sundae();
}
}
public class IceCream{
public static void main(String[] args){
// Sundae class中構造函數Sundae()是private，
// 所以不能用它進行初始化
//Sundae x = new Sundae();
Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此調用
Sundae z = Sundae.makASundae();
}
}
4． protected：具有friendly訪問許可權的同時，又能被subclass（當然包括子孫類，即子類的子類）所訪問。即，既能被同一package中的classes訪問，又能被protected成員所在class的subclass訪問。
二．Class的訪問許可權
1．Class同樣具有public、protect、friendly、private四種訪問訪問許可權：
1）public：在任何地方都可被使用
2）protect、private：除了它自己，沒有任何class可以使用，所以class不能是
protected或private（inner class除外）
3） friendly：同一個package中的classes能用
2． 如何調用構造函數被聲明為private的class
1） 用static函數
2） 用Singteton模式
class Soup{
private Soup(){}
//（1）靜態函數方法
public static Soup makeSout(){
return new Soup();
}
//（2）The "Singleton" pattern:
private static Soup ps1 = new Soup();
public static Soup access(){
return ps1;
}
public void f(String msg){
System.out.println("f(" + msg + ")");
}
}
public class Lunch{
public static void main(String[] args){
//Soup priv1 = new Soup();編譯錯誤
Soup priv2 = Soup.makeSout();
Soup priv3 = Soup.access();
priv2.f("priv2");
priv3.f("priv3");
}
『貳』 JAVA 兩個類能寫在同一個.java文件下嗎
一個搏昌java文件可以包含多個類，但是只有一個public的類，而且這個public的類名基山扒應該跟唯嘩文件名相同，否則會有編譯錯誤。
『叄』 java嵌套類型無法隱藏外層類型怎麼解決
你這個介面如果是定義在別的類內部, 不能用public,只有頂層類才能是public的.
『肆』 Java中，如果父類子類關系超過2層，中間層次的類中有同名欄位，怎麼在底層子類中訪問頂層父類的欄位
很簡單團指，只要把當前行或碼對象轉換成你最上級的類型就可以了
不如
B繼承A，
C繼承了B
那麼在檔哪C里訪問A的變數，只要寫
A
a
=
(A)this;
然後就可以了
因為強制類型轉換會舍棄子集的所有內容，所以會忽略掉C和B的欄位值
『伍』 java的最頂層類是
頂層類就是頂層類，不能說最字，一個類只要不是內部類就可以說是頂層類，object是頂級父乎液類舉畢，所有沒歲答物有繼承其他父類的類都默認繼承object
『陸』 Java內部類的問題
你這個內部類是在method方法中定義的，就只能在這個方法中才能使用
在方法外面的時候相當於是沒有這個內部類的
你報錯的地方相當於在強轉一個不存在的類，所以報錯
『柒』 JAVA面向對象六大原則是什麼
1) Open-Close Principle（OCP），開-閉原則，講的是設計要對擴展有好的支持，而對修改要嚴格限制。這是最重要也是最為抽象的原則，基本上我們所說的Reusable Software既是基於此原則而開發的。其他的原則也是對它的實現提供了路徑。
2) Liskov Substituition Principle（LSP），里氏代換原則，很嚴格的原則，規則是「子類必須能夠替換基類，否則不應當設計為其子類。」也就是說，子類只能去擴展基類，而不是隱藏或覆蓋基類.
3) Dependence Inversion Principle（DIP），依賴倒換原則，「設計要依賴於抽象而不是具體化」。換句話說就是設計的時候我們要用抽象來思考，而不是一上來就開始劃分我需要哪些哪些類，因為這些是具體。這樣做有什麼好處呢？人的思維本身實際上就是很抽象的，我們分析問題的時候不是一下子就猜含考慮到細節，而是很抽象的將整個問題都構思出來，所以面向抽象設計是符合人的思維的。另外這個原則會很好悉兆州的支持OCP，面向抽象的設計使我們能夠不必太多依賴於實現，這樣擴展就成為了可能，這個原則也是另一篇文章《Design by Contract》的基石。
4) Interface Segregation Principle（ISP），「將大的介面打散成多個小介面」，這樣做的好處很明顯，我不知道有沒有必要再繼續描述了，為了節省篇幅，實際上我對這些原則只是做了一個小總結，如果有需要更深入了解的話推薦看《Java與模式》，MS MVP的一本巨作！^_^
5) Composition/Aggregation Reuse Principle（CARP），設計者首先應當考慮復合/聚合，而不是繼承（因為它很直觀，第一印象就是「哦，這個就是OO啊」）。這個就是所謂的「Favor Composition over Inheritance」，在實踐中復合/聚合會帶來比繼承更大的利益，所以睜蔽要優先考慮。
6) Law of Demeter or Least Knowlegde Principle（LoD or LKP），迪米特法則或最少知識原則，這個原則首次在Demeter系統中得到正式運用，所以定義為迪米特法則。它講的是「一個對象應當盡可能少的去了解其他對象」。也就是又一個關於如何松耦合（Loosely-Coupled）的法則。
『捌』 Java中Object類是最頂層的類
可以這么說，在java中，一切亂祥皆對象，最簡單的測試，new一個list存放,存放嘩滲搏的是Object類型，然後無論你new什喊空么對象，都可以直接往這個list存放，這就說明，Object是那個對象的父類
『玖』 java圖形界面設計中怎樣設置頂層底層
用滑鼠點兩下就OK
用JBuilder 打開山則你的類
在切換到圖形界面（代碼區域的下面點Design）
然後在選擇你要設置控制項，滲猜右擊滑鼠
選擇 move to fist（逗喊棚放到頂層） 或者 move to last (放到底層)
『拾』 談談你對Java中的多態的理解.(為什麼要使用多態，有什麼好處，一般用在什麼場合)
面向對象編程有三大特性：封裝、繼承、多態。
封裝隱藏了類的內部實現機制，可以在不影響使用的情況下改變類的內部結構，同時也保護了數據。對外界而已它的內部細節是隱藏的，暴露給外界的只是它的訪問方法。
繼承是為了重用父類代碼。兩個類若存在IS-A的關系就可以使用繼承。，同時繼承也為實現多態做了鋪墊。
那麼什麼是多態呢？多態的實現機制又是什麼？請看我一一為你揭開：
所謂多態
就是指程序中定義的引用變數所指向的具體類型和通過該引用變數發出的方法調用在編程時並不確定，而是在程序運行期間才確定，即一個引用變數倒底會指向哪個類的實例對象，該引用變數發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變數綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。
比如你是一個酒神，對酒情有獨鍾。某日回家發現桌上有幾個杯子裡面都裝了白酒，從外面看我們是不可能知道這是些什麼酒，只有喝了之後才能夠猜出來是何種酒。你一喝，這是劍南春、再喝這是五糧液、再喝這是酒鬼酒….在這里我們可以描述成如下：
酒 a = 劍南春
酒 b = 五糧液
酒 c = 酒鬼酒
…
這里所表現的的就是多態。劍南春、五糧液、酒鬼酒都是酒的子類，我們只是通過酒這一個父類就能夠引用不同的子類，這就是多態——我們只有在運行的時候才會知道引用變數所指向的具體實例對象。
誠然，要理解多態我們就必須要明白什麼是「向上轉型」。在繼承中我們簡單介紹了向上轉型，這里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父類，劍南春（JNC）、五糧液（WLY）、酒鬼酒（JGJ）是子類。我們定義如下代碼：
JNC a = new JNC();
對於這個代碼我們非常容易理解無非就是實例化了一個劍南春的對象嘛！但是這樣呢？
Wine a = new JNC();
在這里我們這樣理解，這里定義了一個Wine 類型的a，它指向JNC對象實例。由於JNC是繼承與Wine，所以JNC可以自動向上轉型為Wine，所以a是可以指向JNC實例對象的。這樣做存在一個非常大的好處，在繼承中我們知道子類是父類的擴展，它可以提供比父類更加強大的功能，如果我們定義了一個指向子類的父類引用類型，那麼它除了能夠引用父類的共性外，還可以使用子類強大的功能。
但是向上轉型存在一些缺憾，那就是它必定會導致一些方法和屬性的丟失，而導致我們不能夠獲取它們。所以父類類型的引用可以調用父類中定義的所有屬性和方法，對於只存在與子類中的方法和屬性它就望塵莫及了。
publicclassWine{
publicvoidfun1(){
System.out.println("Wine的Fun.....");
fun2();
}
publicvoidfun2(){
System.out.println("Wine的Fun2...");
}
}
publicclassJNCextendsWine{
/**
*@desc子類重載父類方法
*父類中不存在該方法，向上轉型後，父類是不能引用該方法的
*@parama
*@returnvoid
*/
publicvoidfun1(Stringa){
System.out.println("JNC的Fun1...");
fun2();
}
/**
*子類重寫父類方法
*指向子類的父類引用調用fun2時，必定是調用該方法
*/
publicvoidfun2(){
System.out.println("JNC的Fun2...");
}
}
publicclassTest{
publicstaticvoidmain(String[]args){
Winea=newJNC();
a.fun1();
}
}-------------------------------------------------
Output:
Wine的Fun.....
JNC的Fun2...
從程序的運行結果中我們發現，a.fun1()首先是運行父類Wine中的fun1().然後再運行子類JNC中的fun2()。
分析：在這個程序中子類JNC重載了父類Wine的方法fun1()，重寫fun2()，而且重載後的fun1(String a)與 fun1()不是同一個方法，由於父類中沒有該方法，向上轉型後會丟失該方法，所以執行JNC的Wine類型引用是不能引用fun1(String a)方法。而子類JNC重寫了fun2() ，那麼指向JNC的Wine引用會調用JNC中fun2()方法。
所以對於多態我們可以總結如下：
指向子類的父類引用由於向上轉型了，它只能訪問父類中擁有的方法和屬性，而對於子類中存在而父類中不存在的方法，該引用是不能使用的，盡管是重載該方法。若子類重寫了父類中的某些方法，在調用該些方法的時候，必定是使用子類中定義的這些方法（動態連接、動態調用）。
對於面向對象而已，多態分為編譯時多態和運行時多態。其中編輯時多態是靜態的，主要是指方法的重載，它是根據參數列表的不同來區分不同的函數，通過編輯之後會變成兩個不同的函數，在運行時談不上多態。而運行時多態是動態的，它是通過動態綁定來實現的，也就是我們所說的多態性。
多態的實現
2.1實現條件
在剛剛開始就提到了繼承在為多態的實現做了准備。子類Child繼承父類Father，我們可以編寫一個指向子類的父類類型引用，該引用既可以處理父類Father對象，也可以處理子類Child對象，當相同的消息發送給子類或者父類對象時，該對象就會根據自己所屬的引用而執行不同的行為，這就是多態。即多態性就是相同的消息使得不同的類做出不同的響應。
Java實現多態有三個必要條件：繼承、重寫、向上轉型。
繼承：在多態中必須存在有繼承關系的子類和父類。
重寫：子類對父類中某些方法進行重新定義，在調用這些方法時就會調用子類的方法。
向上轉型：在多態中需要將子類的引用賦給父類對象，只有這樣該引用才能夠具備技能調用父類的方法和子類的方法。
只有滿足了上述三個條件，我們才能夠在同一個繼承結構中使用統一的邏輯實現代碼處理不同的對象，從而達到執行不同的行為。
對於Java而言，它多態的實現機制遵循一個原則：當超類對象引用變數引用子類對象時，被引用對象的類型而不是引用變數的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。
2.2實現形式
在Java中有兩種形式可以實現多態。繼承和介面。
2.2.1、基於繼承實現的多態
基於繼承的實現機制主要表現在父類和繼承該父類的一個或多個子類對某些方法的重寫，多個子類對同一方法的重寫可以表現出不同的行為。
publicclassWine{
privateStringname;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicWine(){
}
publicStringdrink(){
return"喝的是"+getName();
}
/**
*重寫toString()
*/
publicStringtoString(){
returnnull;
}
}
publicclassJNCextendsWine{
publicJNC(){
setName("JNC");
}
/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}
/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}
publicclassJGJextendsWine{
publicJGJ(){
setName("JGJ");
}
/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}
/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}
publicclassTest{
publicstaticvoidmain(String[]args){
//定義父類數組
Wine[]wines=newWine[2];
//定義兩個子類
JNCjnc=newJNC();
JGJjgj=newJGJ();
//父類引用子類對象
wines[0]=jnc;
wines[1]=jgj;
for(inti=0;i<2;i++){
System.out.println(wines[i].toString()+"--"+wines[i].drink());
}
System.out.println("-------------------------------");
}
}OUTPUT:
Wine:JNC--喝的是JNC
Wine:JGJ--喝的是JGJ
在上面的代碼中JNC、JGJ繼承Wine，並且重寫了drink()、toString()方法，程序運行結果是調用子類中方法，輸出JNC、JGJ的名稱，這就是多態的表現。不同的對象可以執行相同的行為，但是他們都需要通過自己的實現方式來執行，這就要得益於向上轉型了。
我們都知道所有的類都繼承自超類Object，toString()方法也是Object中方法，當我們這樣寫時：
Objecto=newJGJ();
System.out.println(o.toString());
輸出的結果是Wine : JGJ。
Object、Wine、JGJ三者繼承鏈關系是：JGJ—>Wine—>Object。所以我們可以這樣說：當子類重寫父類的方法被調用時，只有對象繼承鏈中的最末端的方法才會被調用。但是注意如果這樣寫：
Objecto=newWine();
System.out.println(o.toString());
輸出的結果應該是Null，因為JGJ並不存在於該對象繼承鏈中。
所以基於繼承實現的多態可以總結如下：對於引用子類的父類類型，在處理該引用時，它適用於繼承該父類的所有子類，子類對象的不同，對方法的實現也就不同，執行相同動作產生的行為也就不同。
如果父類是抽象類，那麼子類必須要實現父類中所有的抽象方法，這樣該父類所有的子類一定存在統一的對外介面，但其內部的具體實現可以各異。這樣我們就可以使用頂層類提供的統一介面來處理該層次的方法。
2.2.2、基於介面實現的多態
繼承是通過重寫父類的同一方法的幾個不同子類來體現的，那麼就可就是通過實現介面並覆蓋介面中同一方法的幾不同的類體現的。
在介面的多態中，指向介面的引用必須是指定這實現了該介面的一個類的實常式序，在運行時，根據對象引用的實際類型來執行對應的方法。
繼承都是單繼承，只能為一組相關的類提供一致的服務介面。但是介面可以是多繼承多實現，它能夠利用一組相關或者不相關的介面進行組合與擴充，能夠對外提供一致的服務介面。所以它相對於繼承來說有更好的靈活性。