成員變量的隱藏：當父類和子類有相同的成員變量時，即定義了與父類相同的成員變量時，就會發生子類對父類變量的隱藏。對於子類的對象來說，父類中的同名成員變量被隱藏起來，子類就會優先使用自己的成員變量，父類成員隱藏。
public class yincang {
public static void main(String []args)
{
SonA son=new SonA();
son.showson();
FatherA father=new FatherA();
father.showfather();
}
}
class FatherA{
int x1=1;
int x2=2;
void showfather(){
System.out.print("x1="+x1+"\n");
System.out.print("x2="+x2+"\n");
}
}
class SonA extends FatherA
{
int x1=11;
int y1=22;
void showson(){
System.out.print("x1="+x1+"\n");
System.out.print("x2="+x2+"\n");
System.out.print("y1="+y1+"\n");
}
}
ps：該程序隱藏了父類中的x1輸出了子類中的x1.隱藏和類型無關，當父類中的x1改為double型，子類還是int型，那么輸出的還是子類的int型。
隱藏與修飾符無關，父類中的x1 的修飾符該為protected子類x1 的修飾符還是不變，保持默認。
方法的覆蓋：子類和父類可以定義相同的方法名，這時候，對於子類的對象，調用的是自己的成員，覆蓋的是父類的成員方法。
public class fugai {
public static void main(String []args)
{
FatherB father=new FatherB();
father.show();
SonB son=new SonB();
son.show();
}
}
class FatherB{
int x1=10;
int x2=20;
void show(){
System.out.print("x1="+x1+"\n");
System.out.print("x2="+x2+"\n");
}
}
class SonB extends FatherB{
int y1=30;
int y2=40;
void show(){
System.out.print("y1="+y1+"\n");
System.out.print("y2="+y2+"\n");
}
}
ps：在該程序中，在父類FatherB中有一個成員方法show（），在子類SonB中也有一個成員方法show（），那么創建子類的對象son，調用的是自己的成員方法show（），父類中的成員方法就被覆蓋了。只有創建父類的對象father，調用的才是自己的成員方法。成員變量的覆蓋必須是方法名，參數類型，順序，個數，返回值完全相同。
如果方法名相同，參數類型，個數，順序不一樣是時子類繼承下來形成的是重載。重載要求方法名相同，參數類型，個數，順序不同。
public class chongzai {
int get(int x){
return x;
}
class B extends chongzai{
int get(int x,int y){
return x+y;
}
}
class test1{
public void main(String []args){
B bb=new B();
System.out.print(bb.get(4));
System.out.print(bb.get(4,5));
}
}
}
ps：在該程序中，父類的get（)方法帶一個參數，子類的get（）方法帶兩個參數，子類把父類中的方法繼承下來，兩個get（）方法形成重載關系。創建子類的對象，語句“bb.get（4）”匹配的是父類中的get（）方法。而語句“bb.get（4,5）”匹配的是子類自己的方法。
如果方法名，參數類型，個數，順序完全相同，只有返回值不同那么不是重載也不是覆蓋。
不能覆蓋父類中的final方法，如果父類中的方法為final，表示為最終方法，不能 被子類覆蓋，也就是說最終方法能被子類繼承和使用，但不能在子類中修改或重新定義它，這和常量的概念類似。
不能覆蓋父類中的static方法但可以隱藏。也就是說，在子類中聲明的同名靜態方法實際上隱藏了父類的靜態方法。
super關鍵字：如果子類和父類有相同的成員變量和方法時，子類會隱藏和覆蓋或父類的成員變量和成員方法，使用子類自己的成員變量和方法。但如果子類想訪問父類的成員變量和成員方法，怎么解決呢？解決的方法就是使用super關鍵字，要使用父類中被隱藏和覆蓋的成員時，使用super，格式如下：
super.父類成員變量名
super.父類成員方法名
例如：
public class superlei {
public static void main(String []args)
{
Employee emp=new Employee();
emp.sete();
emp.show();
}
}
class Person{
protected String name;
protected char sex;
void show(){
System.out.println("父類中的名字為："+name);
System.out.println("性別為："+sex);
}
}
class Employee extends Person{
protected int salary;
protected String name;
void sete(){
name="張倩";
super.name="李斯";
salary=3000;
sex='男';
}
void show(){
System.out.println("子類中的名字為："+name);
System.out.println("性別為："+sex);
}
}
ps：要給父類的成員變量name賦值，必須采用一個super調用給父類的成員變量name賦值“super.name="李斯"”。同樣，子類和父類有相同的輸出方法show（）方法，在子類的show（）方法中，要調用父類的show（）方法也必須通過super來調用“super.show();”.
子類構造方法：在前面的 程序中，父類都沒有寫構造方法，這時候父類默認有一個無參的構造方法。定義子類時，必須無條件繼承父類中的無參構造，也就是說子類默認調用父類中的默認無參構造。當父類存在有參數的構造方法時，子類必須調用父類中的構造方法。子類調用父類的構造方法原則是：
1：對於父類中不含參數構造方法，子類無條件繼承。
2：如果父類中是有參數的構造方法，子類這時不能默認繼承無參構造，必須寫super調用父類構造方法。
3：如果在子類構造方法中通過this（）調用本類中其他構造方法，就不再默認調用super（）。
public class gouzaofangfa {
public static void main(String []args)
{
Qun qun=new Qun(3,4,5,4.5f);
qun.show();
qun.quntity();
}
}
class Rect{
int length;
int width;
int high;
Rect(int l,int w,int h){
this.length=l;
this.width=w;
this.high=h;
}
int vert(){
int v=length*width*high;
return v;
}
}
class Qun extends Rect{
float p;
Qun(int lx,int wx,int hx,float px){
super(lx,wx,hx);
p=px;
}
void quntity(){
float m;
m=p*vert();
System.out.println("質量為"+m);
}
void show(){
System.out.println("長為："+length);
System.out.println("寬為："+width);
System.out.println("高為："+high);
}
}
ps：父類Rect長方形類中定義了一個有參數的構造方法，給長，寬，高賦值。在他的派生類Qun類中，必須定義一個有參數的構造方法，並且一般要帶4個參數，這是因為子類的構造方法需要給父類中的長寬高和自己的密度賦值。在子類的構造方法中，第一句語句必須是用super調用父類的構造方法“super（lx,wx,hx）;”,他不能放在其他語句“p=px”后面。