成员变量的隐藏：当父类和子类有相同的成员变量时，即定义了与父类相同的成员变量时，就会发生子类对父类变量的隐藏。对于子类的对象来说，父类中的同名成员变量被隐藏起来，子类就会优先使用自己的成员变量，父类成员隐藏。
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+"
");
System.out.print("x2="+x2+"
");
}
}
class SonA extends FatherA
{
int x1=11;
int y1=22;
void showson(){
System.out.print("x1="+x1+"
");
System.out.print("x2="+x2+"
");
System.out.print("y1="+y1+"
");
}
}
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+"
");
System.out.print("x2="+x2+"
");
}
}
class SonB extends FatherB{
int y1=30;
int y2=40;
void show(){
System.out.print("y1="+y1+"
");
System.out.print("y2="+y2+"
");
}
}
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”后面。