看完这个，个人最为详细的总结，继承你就懂了 - 黑马程序员技术交流社区

/*
继承：多个类有相同属性，行为，可以用现有类去构建一个新类。
原因：发现了一个问题，假如将来有很多这样的类似的类，那么，代码的重复度是很高的。
final
很多时候，有些内容，是不能被子类重写的。而我们又知道，只要方法声明(public void show())相同。
子类就可以重写父类方法。这样就让父类的方法不安全了。
这样，有效代码其实并不多
作用：
1，提高代码复用。
2，让类与类之间产生了一个关系，是多态的前提
格式：
class 类A extends 类B
{
}
注意事项：
final关键字：最终的意思。它可以修饰类，修饰成员变量，修饰成员方法。
它修饰的成员方法，是不可以被子类重写的。
它修饰的成员变量，其实是一个常量。
常量：
字面值常量 'a',"hello",123
定义常量
和定义变量的格式一致，不过，加了final修饰。
它修饰的类，不能被继承。
1，子类可以直接访问父类中的非私有的属性和行为。
2，Java只支持单继承，不支持多继承。
3，Java支持多层(重)继承(继承体系)
4，父类方法重写的注意问题:
A：父类中的私有方法不可以被重写。
B：子类方法访问权限一定要大于等于父类方法访问权限
C：静态的方法只能被静态方法重写。这个其实不能算对象的关系。
D：覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，
可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
执行顺序：
静态代码块 -- > 构造代码块 -- > 构造方法。
注意：
不要为了获取部分功能，而去使用继承
静态代码块只执行一次。
继承中的构造关系:
子类的构造方法默认都去访问了父类的无参构造方法：
在子类中的构造方法中都有一行默认语句:super()
为什么要这样呢?
因为子类会自动具备父类中非私有数据，那么，这个数据的初始化
靠父类完成。所以，会去先调用父类的构造方法对数据进行初始化。
我现在要在子类中，输出局部范围的值，输出成员范围的值，输出父亲成员变量的值,该怎么办?
A:局部范围的值直接输出变量名即可。
B:成员范围输出this.变量名即可。
C:父的成员变量输出super.变量名即可。
this和super的使用： this作用于本类，super作用于父类
成员变量：
this.变量 -- 当前类的变量
super.变量 -- 父类的变量
构造方法：用在构造方法中的。
this(参数) -- 本类的构造方法
super(参数) -- 父类的构造方法
成员方法：
this.方法名() -- 本类的方法
super.方法名() -- 父类的方法
注意：
如果父类中没有无参构造方法，那么，该怎么办呢?
A:可以通过super(参数)去访问父类中的带参构造方法。
B:可以通过this(参数...)去访问本类中的其他构造方法。不推荐使用。
如何成员变量被私有了，那么，在子类中怎么使用呢?
A:儿子通过父亲的set方法可以给父亲的成员变量赋值。
B:通过子类调用父类的带参构造方法。
*/
class Person
{
String name;
private int age;
final int a=10;
static
{
System.out.println("父类代码静态代码块优先加载");
}
public Person()
{
System.out.println("父类无参的构造函数永远手动写上，父类方法区在子类静态加载后加载");
}
public Person(int age)
{
this.age=age;
System.out.println("父类有参的构造函数:"+age);
}
public void setName(String name)
{
this.name=name;
System.out.println("设置父类属性："+name);
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age=age;
System.out.println("设置父类属性1："+age);
}
public int getAge()
{
return age;
}
public void show()
{
System.out.println("调用了父类方法："+name+"..."+age);
}
final public void speak() //被final的方法是不能被子类重写的
{
System.out.println("被final的方法是不能被子类重写的");
}
}
class Student extends Person //不要忘记了继承
{
int age=10;
static
{
System.out.println("子类的静态代码块加载了");
}
public Student()
{
System.out.println("子类无参的构造函数加载了");
//super(); 必须是第一句，每一个子类都默认调用了父类的无参构造方法。
}
//重写静态的方法只能被静态重写
public void show() //父类有什么子类就要有什么修饰，父类权限一定大于子类权限
{
//int age=30; 现在局部范围找，再找成员范围，再从父类找，找不到报错。
System.out.println("就近原则:"+age);
super.setName("子类赋名");
super.setAge(20);//父类age私有化了，可以通过调用父类赋值，间接访问
System.out.println("子类重写了父类属性:"+super.name+"..."+age);
super.show();
System.out.println("就近原则:"+this.age);//虽然age被赋值了，但是this调用的是成员变量
System.out.println(a);//被final修饰的变量会变成常量
//a=20;//错误: 无法为最终变量a分配值，因为a被修饰了，变量成常量
System.out.println(a);
}
/*
这种写法，不是重写。重写必须返回值类型，列表参数，返回值类型都要一样。
重载方法名和类名相同，参数列表相同，与返回值无关。
public int show()
{
System.out.println("zi show");
return 10;
}
*/
}
class Teacher extends Person//,student 这是错误的，不支持多继承//自动调用父类的无参构造
{
/*
public void speak()//被final的方法是不能被子类重写的
{
}
*/
}
/*
final class mother //已结扎
{
}
class son extends mother //加了final的类不能重写
{
}
*/
class PersonText
{
public static void main(String[] args)
{
Student s=new Student();
s.show();
//Teacher.show();只有静态的才可以这样调用;
Teacher t=new Teacher();
t.show();//继承了父类
Person p =new Person();
p.show();//重写不是子类重新修改父类，而是重写子类继承父类的属性。
}
}

复制代码