『壹』 java的覆蓋重寫隱藏和C#中的不同
區別如下:
1)重寫:C#用override關鍵字重寫父類同名且被virtual或abstract關鍵字修飾的方法。而JAVA則不必。
2)隱藏:C#可以用new關鍵字隱藏父類的同名方法，而JAVA則不存在這個概念。
『貳』 Java語言中隱藏，覆蓋，重載的含義！
多態性
通過繼承，一個類可以用作多種類型：可以用作它自己的類型、任何基類型，或者在實現介面時用作任何介面類型。這稱為多態性
重載
每個類型成員都有一個唯一的簽名。方法簽名由方法名稱和一個參數列表（方法的參數的順序和類型）組成。只要簽名不同，就可以在一種類型內定義具有相同名稱的多種方法。當定義兩種或多種具有相同名稱的方法時，就稱作重載。即重載時相同名稱成員的參數列表是不相同的（參數順序和類型）。
繼承，重寫和隱藏成員
派生的類型繼承其基本類型的所有成員；也就是說，這些成員是在派生類型之上定義的，並可用於派生類型。繼承成員的行為和質量可以通過以下兩種方式來修改：
1、派生類型可通過使用相同的簽名定義一個新成員，從而隱藏繼承的成員。將先前的公共成員變成私有成員，或者為標記為 final 的繼承方法定義新行為時，可以採取這種方法。
2、派生類型可以重寫繼承的虛方法。重寫方法提供了對方法的一種新定義，將根據運行時的值的類型，而不是編譯時已知的變數類型來調用方法。只有當虛方法沒有標記為 final 且新方法至少可以像虛方法一樣進行訪問的情況下，成員才能重寫虛方法。
方法名,參數相同形成重寫，重寫的方法不能降低原方法的"可見度"，也不能改變原方法的返回值類型。
方法名相同，參數不同(個數、類型)形成重載，重載的方法可看成一個全新的方法，與原方法相比它可以有不同的"可見度"和「返回值類型」。如下例：
class A {
protected int method1(int a, int b) { return 0; }
}
public class B extends A{
public int method1(int a, int b) { return 0; } //正確，重寫父類方法，可以擴大訪問許可權
//private int method1(int a, int b) { return 0; } //錯誤，重寫父類方法，不能降低了訪問許可權
//private long method1(int a, int b) { return 0; } //錯誤，重寫父類方法，不能改變返回值類型
public short method1(int a, long b) { return 0; }//正確，重載自身的方法，可以有不同的訪問許可權和返回值類型
private int method1(int a, long b) { return 0; }//正確，重載自身的方法，可以有不同的訪問許可權和返回值類型
}
但這里 方法public short method1(int a, long b) { return 0; }和 方法private int method1(int a, long b) { return 0; }不能同時存在，因為在同一類中，不允許存在相同名字和參數類型的方法(重寫的方法)。
override可以翻譯為覆蓋，從字面就可以知道，它是覆蓋了一個方法並且對其重寫，以求達到不同的作用。對我們來說最熟悉的覆蓋就是對介面方法的實現，在介面中一般只是對方法進行了聲明，而我們在實現時，就需要實現介面聲明的所有方法。除了這個典型的用法以外，我們在繼承中也可能會在子類覆蓋父類中的方法。在覆蓋要注意以下的幾點：
1、覆蓋的方法的標志必須要和被覆蓋的方法的標志完全匹配，才能達到覆蓋的效果；
2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；
3、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；
4、被覆蓋的方法不能為private，否則在其子類中只是新定義了一個方法，並沒有對其進行覆蓋。
overload對我們來說可能比較熟悉，可以翻譯為重載，它是指我們可以定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然後再調用時，VM就會根據不同的參數樣式，來選擇合適的方法執行。在使用重載要注意以下的幾點：
1、在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序（當然，同一方法內的幾個參數類型必須不一樣，例如可以是fun(int,float)，但是不能為fun(int,int)）；
2、不能通過訪問許可權、返回類型、拋出的異常進行重載；
3、方法的異常類型和數目不會對重載造成影響；
4、對於繼承來說，如果某一方法在父類中是訪問許可權是priavte，那麼就不能在子類對其進行重載，如果定義的話，也只是定義了一個新方法，而不會達到重載的效果。
下面是對override和overload的測試程序，其中注釋中的內容都是會產生編譯錯誤的代碼，我們將注釋去掉，看看在編譯時會產生什麼效果。
//對overload測試的文件：OverloadTest.java
publicnewOverrideTest1();
try{
test.fun();
test.fun1();
}catch(Exceptione){}
}
}
{
//以下正常Override
publicvoidfun()throwsTestException2{
System.out.println("funinOverrideTest1");
}
//不能Override父類中的方法，因為它定義了不同的異常類型和
//返回值。
//publicintfun()throwsTestException1{
//System.out.println("methodfuninTest");
//return1;
//}
//不能Override父類中的方法，因為它拋出了比父類中非法范圍
//更大的異常。
//publicvoidfun()throwsException{
//System.out.println("funinOverrideTest1");
//}
//這個方法並沒有Override父類中的fun1方法，因為這個方法在
//父類是private類型，所以這里只是相當於定義了一個新方法。
publicvoidfun1(){
System.out.println("methodfun1inTest");
}
}
{
publicTestException(Stringmsg){
super(msg);
}
}
{
publicTestException1(Stringmsg){
super(msg);
}
}
{
publicTestException2(Stringmsg){
super(msg);
}
『叄』 JAVA方法的覆蓋與域的隱藏有何不同
方法的覆蓋出現在父類與子類之間，若子類中定義的某個方法特徵與父類中定義的某個方法特徵完全一樣，那麼就說子類中的這個方法覆蓋了父類中的相應的那個方法。
父類中定義了：public
void
todo(String
str);
子類也定義了：public
void
todo(String
str);
則子類的todo方法覆蓋了父類的todo方法！！
域的隱藏，你是指private么，私有的變數、方法只能在自己家裡調用，兒子老爹都不能用，其他人更不能用。
class
A
{
private
int
num;
//num只能在A裡面用，例如：num
=
num
+
1;
}
class
B
{
//num不能在這里用：a.num
=
a.num
+
1;
}
『肆』 方法隱藏和方法覆蓋的區別和用法
屬性的隱藏是指實例變數和方法內部變數相同時，實例變數在該方法內會被隱藏，比如你在方法內直接輸出變數，前面不加this，那麼只會輸出方法內那個變數的值。
方法的覆蓋是指子類繼承父類時，對父類的方法進行重寫，要求返回類型，參數都要與父類一致，當然返回類型可以返回原來返回類型的子類。
一個是對變數而言一個是對方法而言，對於變數，你在方法內可以是任何的類型，和實例變數的類型沒有關系。
小弟不才,學java一段時間了,從來沒有看到過屬性的隱藏會出現在繼承中。在繼承時,子類中出現與父類相同的屬性時,那個屬性和父類中的屬性沒有關系,如果父類中的屬性可以被子類繼承,子類自然繼承了那個屬性,出現屬性名字相同時,那隻是只類的一個自己的屬性而已。在子類中用super當然能區別是那個屬性,這沒有什麼奇怪的,繼承的一個特點而已。
除了靜態變數外，你要訪問屬性得要有實例對象，你在一個類中同時初始化父類對象和子類對象，他們互不影響，除非你用多態的方式調用，就算用多態調用，使用的屬性也只會是父類的屬性！調用的方法則是子類重寫的方法！
『伍』 如何理解Java中的隱藏與覆蓋
隱藏與覆蓋類方法
在講清這個問題之前，先明白什麼是隱藏？什麼是覆蓋？
所謂隱藏，是指運行時系統調用當前對象引用的編譯時類型中定義的方法；對於覆蓋，則指運行時系統調用當前對象引用運行時類型中定義的方法。
所以在執行Student1
s
=
new
Graate1();和Graate1
g
=
new
Graate1();時，（1）先進行Student1類的構造，這里包括兩個方法study()和exercise()，由於study()方法被覆蓋，所以先執行Graate1里study()，再執行Student1里的exercise()；（2）再進行Graate1類的構造，同樣包括兩個方法study()和exercise()，所以執行順序為先Graate1里的study()方法，再Graate1里的exercise()方法。
2.
隱藏與覆蓋成員變數
如果子類中的變數和父類中的變數具有相同的名字，那麼子類中的變數就會隱藏父類中的變數，不管他們的類型是什麼，也不管他們是類變數還是實例變數。
所以在執行諸如System.out.print(s.math);之類的s實例的程序時，顯示為Student1類的成員變數，而執行諸如System.out.print(g.math);之類的g實例的程序時，顯示為Graate1類的成員變數。
『陸』 java中重載，覆蓋和隱藏的區別
重載是發生在同一個類中，許多名稱相同而簽名不同或返回類型不同的方法。簽名指的是方法的參數類型，參數個數等。比如在某個類中，有一個CreateStudent(int no,string name) 方法。現在我再寫一個包含三個參數，名稱也叫CreateStudent的方法CreateStudent(int no,string name,string sex)那麼我現在寫的這個方法(三個參數)就是剛剛那個方法(兩個參數)的重載。當然不一定非得參數個數不同，參數類型不同或者返回類型不同也都是可以的，但是名稱必須相同。
而覆蓋，又叫重寫，是發生在子類中，來覆蓋(重寫)父類的方法。注意子類中的方法名稱和簽名跟父類是一模一樣的，返回值也與父類相同或是父類的子類。比如我現在有一個類B繼承父類A。Class B extends A 在A類中有一個方法int Math(int a,int b){return a+b;} 現在我在子類B中也寫一個跟父類A返回類型、名稱、簽名都一樣的方法 int Math(int a,int b){return a-b;} 現在我創建一個B的實例 B b = new B(); 調用Math方法 b.Math,此時b調用的方法是 子類中的a-b 而不是父類中的a+b 因為子類的方法把父類覆蓋了。換句話說也就是子類重寫了父類的 int Math方法。
『柒』 java的覆蓋和隱藏的區別
一個被覆蓋，那麼另一個就被隱藏
『捌』 JAVA成員變數隱藏和方法的覆蓋
從入口程序main開始看，第一句話是
Subclass Subc=new Subclass();
其作用是實例化Subclass類的一個實例出來，使用的構造函數是無參構造函數。
現在轉向看Subclass類，在這個類的無參數構造函數中代碼如下：
Subclass(){
super();//A
x=5;//B
System.out.println("in Subclass:x="+x);//②
}
可以看得見第一句使用的是super()方法，起作用是繼承父類Superclass的構造方法：
Superclass(){
x=3;
System.out.println("in Superclass:x="+x);//①
}
也就是說Subclass（）方法代碼內容是如下的內容：
Subclass(){
x=3;
System.out.println("in Superclass:x="+x);//①
x=5;//B
System.out.println("in Subclass:x="+x);//②
}
所以現在這里有兩個輸出語句，結果如下：
in Superclass:x=3
in Subclass:x=5
現在返回入口程序main()方法，開始執行該方法中的第二句話：
Subc.dosomething();
這句話的作用是執行Subclass類中的dosomething方法，所以我們查看Subclass類的方法void dosomething()內容如下：
super.dosomething();
System.out.println("in Subclass.dosomething()");
System.out.println("super.x="+super.x+"\tsub.x="+x);
可以看到，第一句話super.dosomething();是繼承父類的dosomething()方法,用父類的這個方法內容替換掉這句話,void dosomething()內容如下：
System.out.println("in Superclass.dosomething()");//③
System.out.println("in Subclass.dosomething()");//④
System.out.println("super.x="+super.x+"\tsub.x="+x);//⑤
所以這里就是連續輸出三句話：
in Superclass.dosomething()
in Subclass.dosomething()
super.x=3 sub.x=5
一定要知道super的作用，super()就是使用父類的構造函數，super.屬性/s uper.方法，就是使用父類屬性/方法。
『玖』 JAVA多態中的隱藏和覆蓋
Java的引用變數有兩個類型，一個是編譯時類型，一個是運行時類型
編譯時類型：由聲明該變數時使用的類型決定
運行時類型：由該變數指向的對象類型決定
如果編譯時類型和運行時類型不一致，會出現所謂的多態。因為子類其實是一種特殊的父類，因此java允許把一個子類對象直接賦值給一個父類引用變數，無須任何類型轉換，或者被稱為向上轉型，由系統自動完成。
如 Father f = new Son(); Son是Father的子類
引用變數f就會出現編譯時類型和運行時類型不一致的情況 編譯時是Father類型的 運行時是Son類型的
當變數的編譯時類型和運行時類型不一致時，通過變數訪問它所引用的對象的實例時，該實例變數的值由聲明該變數的類型決定。
通過變數訪問它所引用的對象的方法時，該方法的行為由所引用的對象實際類型所決定。
『拾』 有關java中覆蓋和隱藏的問題
隱藏一般是對靜態的屬性和方法來說的。
你看一下下面的這段代碼：
class
planet
{
public
static
void
hide()
{
system.out.println("the
hide
method
in
planet.");
}
public
void
override()
{
system.out.println("the
overrid
method
in
planet.");
}
};
public
class
earth
extends
planet
{
public
static
void
hide()
{
system.out.println("the
hide
method
in
earth.");
}
public
void
override()
{
system.out.println("the
override
method
in
earth.");
}
public
static
void
main(string[]
args)
{
earth
myearth
=
new
earth();
planet
myplanet
=
(planet)
myearth;
myplanet.hide();
myplanet.override();
}
}
覆蓋就是子類的方法跟父類的方法具有完全一樣的簽名和參數。我們看到上面那兩個類，父類的override在子類中重寫了，因為有跟父類有相同的簽名和參數，所以叫做覆蓋，但是hide方法，因為是靜態的，所以在這里叫做隱藏。