标签：至少1个，最多5个
和现实世界中：子女可以继承父母的一些特征(如：基因)、财产等一样。OOP 中也有提供类似的特性，一个类完全可以从其它类里获得一些属性和方法，而不需要我们自己重新定义。这种特性简单但强大 (Simple and powerful)。
快速了解继承
在Java的继承关系里：子类可以从获取父类的所有的公共和受保护成员(字段、方法和内部类)。当然，构造方法不是成员 (members) ，所以不能被继承。同时，在 Java 的继承里，子类可以做如下事情:
直接使用继承来的字段
直接使用继承来的方法
声明和父类同名字段，隐藏 掉父类字段
通过父类提供的共有/受保护的方法访问父类的私有成员
创建新的字段
重写父类同方法签名的实例方法，隐藏 掉父类方法
重写父类同方法签名的静态方法，隐藏 掉父类方法
编写父类中不存在的方法
使用 super 关键字，利用父类构造方法
当子类拥有和父类(或接口)同样方法签名的方法，这种现象叫做覆盖。如以下代码:
class Father
public void doSomthing(){
// Father do something
class Son extends Father{
public void doSomething(){
// Son do something
Java 规定了子类有以下覆盖行为:
覆盖父类实例方法
覆盖父类静态方法
覆盖接口默认方法 (JDK8+)
对于实例方法的覆盖，实际是子类拥有自己的方法。对于静态方法的覆盖，要记住：静态方法时属于类的，在多态中，调用的始终是类的方法。
Father father = new Son();
Father.staticMethod(); // 这里使用的是父类Father的静态方法
对于接口方法的覆盖，遵循以下原则:1.实例方法的优先级大于接口方法 (JDK8+)
interface Animal{
default void saySomething(){
// Animal say something
interface Cow extends Animal{
default void saySomething(){
// Cow say something
class MyCow implements Cow{
public void saySomething(){
// MyCow say something
Animal myCow = new MyCow();
myCow.saySomething(); // MyCow say something
2.有共同祖先的接口，先被覆盖的方法(继承深度低)会被后覆盖的方法(继承级别高)覆盖
interface Animal{
default void saySomething(){
// Animal say something
interface Pig extends Animal{
default void saySomething(){
// Pig say something
interface BigPig extends Pig{
default void saySomething(){
// BigPig say something
class MyPig implements Pig, BigPig{
public static void main(String...args){
MyPig myPig = new MyPig();
myPig.saySomething(); // BigPig saySomething()
P.S. 如果出现同一继承级别(上例中 BigPig 和 Pig 都继承 Animal 接口)或者子类继承的接口无相关关系，但是接口间有同方法签名的方法，就会出现覆盖冲突。需要用super关键字指明具体实现哪个接口的方法或者直接覆盖。
interface Run{
default void run(){
// Run run
interface Car{
default void run(){
// Car run
class MyCar implements Run, Car{
public void run(){
Car.super.run();
同时，我们需要注意，Java 子类覆盖父类方法，应该:
方法的访问权限大于等于父类
方法的返回值小于等于父类
方法抛出的异常小余等于父类
我们已经知道，子类可以覆盖父类的方法。如果有一个类继承自另外一个类，我们完全可以用一个父类来引用一个子类，如：
class Person{
public void saySomething(){
// Person say something
class Father{
public void saySomething(){
// Father say something
class Test{
pubilc static void main(String...args){
Father father = new Father();
Person person = // 父类引用子类对象
像这种父类引用子类对象的现象，Java 里叫做多态 (Polymorphism)。在 Java 里，只有满足如下三个条件，才能叫多态:
父类引用子类对象
对于多态方法的运行，编译器会列举所有父类和子类符合调用方法签名(方法名+参数列表)的方法，然后以以下原则编译、调用方法：
成员变量(编译和运行都看左边)
成员方法(编译看左边，运行看右边)
静态方法(编译和运行都看左边)
其中，调用 private, final, static 方法的过程叫静态绑定,否则叫动态绑定。在使用多态的过程中，最有效的判断语句能否通过编译的方法是：
右边的类是否是(IS-A)左边的类
如示例代码里的 father(Father) IS-A Person。
有些情况下，我们可能不希望子类覆盖父类的方法，这时候，用final关键字修饰方法即可实现该目的。编译器可以对用final的方法进行优化处理。
在多态里，我们知道一个父类可以引用一个子类对象：
Father father = new Son();
但是，反过来就不行了:
Son son = new Father();
如果需要让编译器不报错，我们就得进行强制类型转换操作：
Son son = (Son)new Father();
不过，这么做有风险，我们一般要使用 instanceof关键字先判断，能否将父类“安全”转换成子类：
Father f = ...;
if (f instanceof Son){
Son son = (Son)f;
抽象类与接口
在继承体系里，比较常用的就是抽象类和接口。它们比较相似：
都能被继承
都包含抽象方法
都不能被实例化
然而，它们还是有不同的，例如：
抽象类可以声明非final&&static的字段，接口不行(默认public static final)
抽象类可以声明非public方法，接口不行(默认方法是public)
一个类只能继承一个抽象类，可以继承多个接口
然后，抽象类和接口有不同的使用场景:P抽象类:
在相关类里共享代码
规定了一系列通用的方法和属性
需要定义非静态、非共有的方法
定义属性，如可比较 (Comparable)、可飞(Flyable)
定义行为，不关心具体实现
希望是多继承的一部分
继承的技巧
在 Java 里，我们一般按照如下规则使用继承：
将公共操作放在超类（父类）中
不要使用受保护的域
继承严格遵循is-a原则
不要过多得使用反射
0 收藏&&|&&2
你可能感兴趣的文章
4 收藏，169
4 收藏，536
分享到微博？
技术专栏，帮你记录编程中的点滴，提升你对技术的理解收藏感兴趣的文章，丰富自己的知识库
明天提醒我
我要该，理由是：
扫扫下载 App关于JAVA中继承相关面试extends
如题，面试题如下：
请输入下面代码的运行结果--------extends-----------
class HelloA {
public HelloA(){
System.out.println(HelloA);
{System.out.println(I'm A class);}
static{System.out.println(static A);}
public class HelloB extends HelloA{
public HelloB(){
System.out.println(HelloB);
{System.out.println(I'm B class);}
static{System.out.println(static B);}
public static void main(String[] args) {
new HelloB();
运行结果如下：
I'm A class
I'm B class> 问题详情
下面关于继承的叙述正确的是______。
A．在Java中只允许单一继承
B．在Java中一个类只能实现一个接口
悬赏：0&答案豆
提问人：匿名网友
发布时间：
下面关于继承的叙述正确的是______。&&A．在Java中只允许单一继承&&B．在Java中一个类只能实现一个接口&&C．在Java中一个类不能同时继承一个类和实现一个接口&&D．Java的单一继承使代码更可靠
为您推荐的考试题库
网友回答（共2条）展开
匿名网友&&&&&&&&提问收益：0.00&答案豆
您可能感兴趣的试题
1在LC正弦波振荡电路中，不用通用型集成运算放大器作放大电路的原因是其上限截止频率太低，难以产生高频振荡信号。
)2当集成运放工作在非线性区时，输出电压不是高电平，就是低电平。
)3一般情况下，电压比较器的集成运算放大器工作在开环状态，或者引入了正反馈。
我有更好的答案
相关考试课程
请先输入下方的验证码查看最佳答案
图形验证：
验证码提交中……
找答案会员
享三项特权
找答案会员
享三项特权
找答案会员
享三项特权
选择支付方式：
支付宝付款
郑重提醒：支付后，系统自动为您完成注册
请使用微信扫码支付(元)
支付后，系统自动为您完成注册
遇到问题请联系在线客服QQ：
请您不要关闭此页面,支付完成后点击支付完成按钮
遇到问题请联系在线客服QQ：
恭喜您！升级VIP会员成功
常用邮箱：
用于找回密码
确认密码：31795人阅读
Java（31）
1、什么是继承，继承的特点？
子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。
特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。
在继承关系中。父类和子类需要满足is-a的关系。子类是父类。
表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。
2、为什么需要继承？什么时候应该继承？
使用继承可以有效实现代码复用，避免重复代码的出现。
当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。
继承实现了面向对象的原则：write once,only once（编写一次、且编写一次
3、如何实现继承？
在java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。
在父类中只定义一些通用的属性和方法。
子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。
4、什么是方法重写？
如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。
方法重写在不同类，是实现多态的必要条件。
5、super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？
在子类的构造方法中，通过super关键字调用父类的构造方法。
如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。
public xinxin1(String name,String sex)
&&&&&&&&&&
this.name=
&&&&&&&&&&
public void hello(){
&&&&&&&&&&&&&&&&&&
System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);
public xinxin2(String name,String sex)
&&&&&&&&&&
//调用父类的构造方法
&&&&&&&&&&
super(name,sex);
public void hello(){
&&&&&&&&&&&&&&&&&&
System.out.println(“我是新来的！”);
&&&&&&&&&&
//调用父类的方法
&&&&&&&&&&
super.hello();
位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。
因为创建对象的时候，需要先创建父类对象，再创建子类对象。
注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。
6、一切类的老大（祖先）Object。
所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。
一个类如果没有使用extends关键字，那么这个类直接继承自Object类。
7、什么是多态？
多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。
8、为什么需要使用多态？多态的好处？
可以增强程序的可扩展性及可维护性，使代码更加简洁。
不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。
9、如何实现多态？
一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new
一个对象）。
更具体的说：
（1）、子类重写父类的方法。使子类具有不同的方法实现。
（2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。
（3）、运行时，根据实际创建的对象类型动态决定使用那个方法。
在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。
10、多态小结：多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。
新新：http://blog.csdn.net/xinxin/article/details/2944760
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：901383次
积分：7150
积分：7150
排名：第2975名
原创：108篇
转载：35篇
评论：113条
(1)(1)(1)(1)(1)(1)(2)(2)(3)(1)(11)(1)(3)(1)(1)(4)(2)(1)(1)(1)(1)(1)(2)(2)(1)(2)(1)(7)(3)(38)(1)(1)(3)(2)(6)(4)(24)(3)(1)JAVA中方法和变量在继承中的覆盖和隐藏 - 任延伟的JAVA日记 - ITeye博客
博客分类：
我们知道，在JAVA中，子类可以继承父类，如果子类声明的方法与父类有重名的情况怎么办，大伙儿都知道要是重写，但是实际上这又分为两种情况，就是方法和变量在继承时的覆盖和隐藏问题，这些概念性的东西看似无聊，但是在面试或者是SCJP认证题中围绕这些是会经常碰到的，所以这里来讨论下
首先我们来看几个概念
：child隐藏了parent的变量和方法，那么，child不能访问parent被隐藏的变量或者方法，但是，讲B转换成A中，可以访问A被隐藏的变量或者方法
：child覆盖了parent的变量或者方法，那么，child不能访问parent被覆盖的变量或者方法，将child转换成parent后同样不能访问parent被覆盖的变量或者方法
首先看一下JAVA中方法和变量在继承时的覆盖和隐藏规则
1.父类的实例变量和静态变量能被子类的同名变量隐藏
2.父类的静态方法被子类的同名静态方法隐藏
3.父类的实例方法被子类的同名实例变量覆盖
还有几点需要注意的是
1.不能用子类的静态方法隐藏
父类中同样标示（也就是返回值 名字 参数都一样）的实例方法
2.不能用子类的实例方法覆盖
父类中同样标示的静态方法
3.这点儿请注意，就是变量只会被隐藏
不会被覆盖
，无论他是实例变量还是静态变量，而且，子类的静态变量可以隐藏
父类的实例变量，子类的实例变量可以隐藏
父类的静态变量
O(∩_∩)O哈哈~ 是不是有点儿绕口，没关系 我们看一个实例
创建两个父子类关系的类
class Parent
public static String kind="javastudy.extendsstudy.parent";
public static int age=50;
public String name="Parent";
//静态方法，返回包名
public static String getKind()
System.out.println("parent的getKind()方法被调用了");
//静态方法，返回年龄
public static int getAge()
System.out.println("Parent的getAge()方法被调用了");
//实例方法，返回姓名
public String getName()
System.out.println("Parent的getName()方法被调用了");
return this.
class Child extends Parent
public static String kind="javastudy.extendsstudy.child";
public int age=25;
public String name="child";
//隐藏父类静态方法
public static String getKind()
System.out.println("child的getkind()方法被调用了");
//获取父类包名
public static String getParentKind()
return Parent.
//覆盖父类实例方法
public String getName()
System.out.println("child的getName()被调用了");
return this.
//获取父类名称
public String getParentName()
return super.
*错误，实例方法不能覆盖父类的静态方法
public int getAge()
return this.
然后测试下
class Test
public static void main(String[] args)
Child child=new Child();
System.out.printf("子类名称：%s,年龄：%d,包名:%s%n",child.name,child.age,child.kind);
//输出：子类名称：child,年龄：25,包:javastudy.extendsstudy.child
//把child转换成parent对象
Parent parent=
System.out.printf("转换后的名称:%s,年龄：%d,包名：%s%n",parent.name,parent.age,parent.kind);
//输出：转换后的名称:Parent,年龄：50,包：javastudy.extendsstudy.parent
System.out.printf("子类访问父类被隐藏的实例变量name:%s%n",child.getParentName());
//输出：子类访问父类被隐藏的实例变量name:Parent
System.out.printf("子类访问父类被隐藏的静态变量kind:%s",child.getParentKind());
//输出：子类访问父类被隐藏的静态变量kind:javastudy.extendsstudy.parent
child.getName();
//输出：child的getName()被调用了
//**************注意看这个方法，返回的还是子类的getName
parent.getName();
//输出：child的getName()被调用了
child.getKind();
//输出：child的getkind()方法被调用了
parent.getKind();
//输出：parent的getKind()方法被调用了
好了，看了结果后总结下吧
1.同名的实例方法被覆盖
，同名的静态方法被隐藏
，child类的getName实例方法覆盖
了parent的getName实例方法,chind的getKind方法隐藏
了parent类的getKind方法
的区别在于，子类对象转换成父类对象后，能够访问父类被隐藏
的变量和方法，而不能访问父类被覆盖
3.如果需要访问父类被隐藏
的实例变量，加上super就好了，比如访问父类的name，写上super.name就好了
本文不是教会大家重写父类变量的，而是重点说明方法和变量的隐藏和覆盖，这些个小知识点虽然在做项目的时候不怎么会用到，但是一定要记住，不然的话很多错误会感到莫名其妙，还有就是SCJP的题库里这类题大大存在，所以本人觉得这些细小的知识还是记住为好
浏览 10821
浏览: 57738 次
来自: 郑州
谢谢，虽然有点绕口，但是解释的很清楚
当所替换的字符串很长的时候，速度太慢了~~
比喻很生动，很好理解[b][/b]
隐藏和覆盖不明白的值得一看
phoenix007 写道不错，学习了。+1收藏着}