理解继承是理解面向对象程序设计的关键。在Java中，通过关键字extends继承一个已有的类，被继承的类称为父类(超类，基类)，新的类称为子类(派生类)。在Java中不允许多继承。
(1)继承
class Animal{
void eat(){
System.out.println("Animal eat");
}
void sleep(){
System.out.println("Animal sleep");
}
void breathe(){
System.out.println("Animal breathe");
}
}
class Fish extends Animal{
}
public class TestNew {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal an = new Animal();
Fish fn = new Fish();
an.breathe();
fn.breathe();
}
}
在eclipse执行得：
Animal breathe!
Animal breathe!
.java文件中的每个类都会在文件夹bin下生成一个对应的.class文件。执行结果说明派生类继承了父类的所有方法。
(2)覆盖
class Animal{
void eat(){
System.out.println("Animal eat");
}
void sleep(){
System.out.println("Animal sleep");
}
void breathe(){
System.out.println("Animal breathe");
}
}
class Fish extends Animal{
void breathe(){
System.out.println("Fish breathe");
}
}
public class TestNew {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal an = new Animal();
Fish fn = new Fish();
an.breathe();
fn.breathe();
}
}
执行结果：
Animal breathe
Fish breathe
在子类中定义一个与父类同名，返回类型，参数类型均相同的一个方法，称为方法的覆盖。方法的覆盖发生在子类与父类之间。另外，可用super提供对父类的访问。
参考原文：http://blog.csdn.net/zhandoushi1982/article/details/5441126
Java 中extends与implements使用方法
Java 中extends与implements使用方法 标签: javaclassinterfacestring语言c 2011-04-14 14:57 33314人阅读 评论(7) 收藏 举报 分 ...
四种Java线程池用法解析
本文为大家分析四种Java线程池用法,供大家参考,具体内容如下 http://www.jb51.net/article/81843.htm 1.new Thread的弊端 执行一个异步任务你还只是如下 ...
设计模式 - 观察者模式(Observer Pattern) Java内置 用法
观察者模式(Observer Pattern) Java内置 用法 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26601659 ...
JAVA的continue用法
JAVA的continue用法: public class test{ public static void main(String [] args){  for(int i=0;i<=10;i ...
Java Spring AOP用法
Java Spring AOP用法 Spring AOP Java web 环境搭建 Java web 项目搭建 Java Spring IOC用法 spring提供了两个核心功能,一个是IoC(控制 ...
Java Spring IOC用法
Java Spring IOC用法 Spring IoC 在前两篇文章中,我们讲了java web环境搭建 和 java web项目搭建,现在看下spring ioc在java中的运用,开发工具为In ...
JAVA中extends 与implements区别
JAVA中extends 与implements有啥区别?1. 在类的声明中,通过关键字extends来创建一个类的子类.一个类通过关键字implements声明自己使用一个或者多个接口.extend ...
JAVA中ArrayList用法
JAVA中ArrayList用法 2011-07-20 15:02:03|  分类: 计算机专业 |  标签:java  arraylist用法  |举报|字号 订阅     Java学习过程中做题时 ...
java 关于extends 和implement的区别
在java中extends用于继承父类,只要父类不是声明为final或者为abstract类就可以,但是java不支持多重继承.可以使用接口实现多重继承implements,继承只能继承一个类,但im ...
随机推荐
Python-属性&lpar;property&rpar;
在2.6版本中,添加了一种新的类成员函数的访问方式--property. 原型 class property([fget[, fset[, fdel[, doc]]]]) fget:获取属性 fset ...
ios - cordova 简介
Cordova 是一个可以让 JS 与原生代码(包括 Android 的 java,iOS 的 Objective-C 等)互相通信的一个库,并且提供了一系列的插件类,比如 JS 直接操作本地数据库的 ...
centos could not retrieve mirrorlist
centos could not retrieve mirrorlist >>>>>>>>>>>>>>>&gt ...
用PHP添加购物商品
&lbrack;ZZ&rsqb; 如何在多版本anaconda python环境下转换spyder
https://www.zhihu.com/people/alexwhu/answers 使用anaconda的话,可以参考以下步骤: 1.打开anaconda navigator,选择左侧的环境菜单 ...
How to Read a Paper
How to Read a Paper 原文: https://www.yuque.com/lart/papers/yrkv5u 题目:How to Read a Paper 作者:S. Keshav ...
NModbus类库使用
通过串口进行通信 : 1.将 NMobus 类库导入工程中,添加引用.命名空间.工程属性必须配置 为 .NET 4.0. 2.创建 SerialPort 类的一个实例,配置参数,打开串口,如: pub ...
word&lowbar;宏示例
参考:https://jingyan.baidu.com/article/870c6fc3326588b03fe4beeb.html 内容自适应 Application.Browser.Target  ...
zookeeper 入门知识
作为开启分布式架构的基石,除了必会还有的选么 自己的一些理解,有错误的话请一定要给予指正! 一.是什么? 分布式数据一致性的解决方案. 二.有什么用 数据的发布/订阅(配置中心)  . 负载均衡(du ...
【Linux 网络编程】TCP网络编程中connect&lpar;&rpar;、listen&lpar;&rpar;和accept&lpar;&rpar;三者之间的关系
基于 TCP 的网络编程开发分为服务器端和客户端两部分,常见的核心步骤和流程如下: connect()函数:对于客户端的 connect() 函数,该函数的功能为客户端主动连接服务器,建立连接是通过三 ...

Java中继承用哪个关键字表示？extends！没错，这是Java小学生都知道的常识。可是extends有没有别的含义呢？它在任何情况下都一定代表继承吗？不一定。
我们知道Collections类有静态方法sort，用于List的排序，该方法要求List中的元素类必须实现Comparable接口。我们来看看源码：
...
@SuppressWarnings("unchecked")
public static > void sort(List list) {
list.sort(null);
}
...
显然，该方法的入參是一个List，List的泛型为T，可是这里写的是“T extends Comparable”(后面的“ super T>”我们暂时不考虑)，按照以往的思维，也就是说T这个class必须继承自Comparable。这和我们所熟知的Collections.sort()是有出入的。所以我们必须熟悉这样一个概念：
在Java的泛型中，extends关键字表示“继承或实现”。
也就是说，泛型的extends表示“是一个”的含义。那么为什么Java不新建一个“is”关键字表示这样的含义呢？要知道新增一个关键字的代价是很大的。
我们再来看一下泛型中的extends和super的区别：
 extends T>限定参数类型的上界：参数类型必须是T或T的子类型
 super T>限定参数类型的下界：参数类型必须是T或T的超类型
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对聚米学院的支持。如果你想了解更多相关内容请查看下面相关链接

基本用法可以参考下面这个问题中胖君的回答
Java 泛型 <? super T> 中 super 怎么 理解？与 extends 有何不同？​www.zhihu.com
胖君​www.zhihu.com
有些疑惑的点在这篇文章中再详细解决一下。
<? extends T>：上界通配符
        要点1：实例化时的类只能是定义时类本身或其子类，也就是说T是它的上界。
import java.util.*;

class Food{
	String name = "Food";
}
class Fruit extends Food{
	String name = "Fruit";
}
class Apple extends Fruit {
	String name = "Apple";
}

// 定义时指定T为Fruit
List<? extends Fruit> list;

// 实例化时类只能是T本身或它的子类
list= new ArrayList<Fruit>(); //可以
list= new ArrayList<Apple>(); //可以
list= new ArrayList<Food>();  //报错
        要点2：上界通配符add失效（只能add null），可以get
list = new ArrayList<Fruit>();
list.add(new Fruit()); //报错
list.add(null);  //可以
list.get(0); //可以
       既然不能add，那里面没东西又get什么呢？所以需要在实例化的时候就把东西都放进去：
list = new ArrayList<Fruit>(){{
	    	add(new Fruit()); // Fruit及其子类都可以放进去
	    	add(new Apple()); // Fruit及其子类都可以放进去
	    	}};
        要点3：能放进去的对象类型其上界为实例化时指定的T：
List<? extends Fruit> list list= new ArrayList<Apple>(){{
	    	add(new Fruit()); // 实例化时指定的T为Apple，放入Fruit对象会报错
	    	add(new Apple()); // Apple及其子类都可以放进去
	    	}};
        所以能放进去的对象不是看定义时T指定的类，而是看实例化时T指定的类。
2. <? superT>：下界通配符
        要点1：实例化时的类只能是定义时类本身或其父类，也就是说T是它的下界。
// 定义时指定T为Fruit
List<? super Fruit> list2;

// 实例化时只能是T本身或它的父类
list2 = new ArrayList<Fruit>(); // 可以
list2 = new ArrayList<Food>(); // 可以
list2 = new ArrayList<Apple>();  // 报错
         要点2：添加对象时，在实例化时添加和实例化后添加的对象限制不同（特别注意！）：
1. 在实例化时添加的对象只有一个限制：上界为实例化时指定的T。来看一个有趣的现象，即使定义时指定的T是Fruit，但实例化时可以用Fruit的邻居类：
class Food{
	String name = "Food";
}
// 新定义一个Meat类，和Fruit都继承Food
class Meat extends Food{
	String name = "Meat";
}
class Fruit extends Food{
	String name = "Fruit";
}
class Apple extends Fruit {
	String name = "Apple";
}

List<? super Fruit> list2 = new ArrayList<Food>(){{
	    	add(new Object()); // 报错，上界为Food
	    	add(new Meat()); // 可以，是Food的子类，即使不是Fruit
	    	add(new Food()); // 可以
	    	add(new Fruit()); // 可以，是Food的子类
	    	add(new Apple()); // 可以，是Food的子类
	    	}};
2. 在实例化后添加的对象，其上界是定义时指定的T：
list2.add(new Meat());   // 报错，不是Fruit或其子类
list2.add(new Food());   // 报错，不是Fruit或其子类
list2.add(new Fruit());  // 可以
list2.add(new Apple());  // 可以
        要点3：上界通配符get出来的对象默认是Object类型，可以做强制类型转换，可以add
Object object = list2.get(0);
Meat meat = (Meat)list2.get(0); // 如果不是Object，需要强制类型转换
System.out.println(meat.name); // 输出meat

作者：zhang siege
链接：https://www.zhihu.com/question/20400700/answer/91106397
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
首先，泛型的出现时为了安全，所有与泛型相关的异常都应该在编译期间发现，因此为了泛型的绝对安全，java在设计时做了相关的限制：
List extends E>表示该list集合中存放的都是E的子类型(包括E自身)，由于E的子类型可能有很多，但是我们存放元素时实际上只能存放其中的一种子类型(这是为了泛型安全，因为其会在编译期间生成桥接方法该方法中会出现强制转换，若出现多种子类型，则会强制转换失败)，例子如下：
List extends Number> list=new ArrayList();
list.add(4.0);//编译错误
list.add(3);//编译错误
上例中添加的元素类型不止一种，这样编译器强制转换会失败，为了安全，Java只能将其设计成不能添加元素。
虽然List extends E>不能添加元素，但是由于其中的元素都有一个共性--有共同的父类，因此我们在获取元素时可以将他们统一强制转换为E类型，我们称之为get原则。
对于List super E>其list中存放的都是E的父类型元素(包括E)，我们在向其添加元素时，只能向其添加E的子类型元素(包括E类型)，这样在编译期间将其强制转换为E类型时是类型安全的，因此可以添加元素，例子如下：
List super Number> list=new ArrayList();
list.add(2.0);
list.add(3.0);
但是，由于该集合中的元素都是E的父类型(包括E)，其中的元素类型众多，在获取元素时我们无法判断是哪一种类型，故设计成不能获取元素，我们称之为put原则。
实际上，我们采用extends，super来扩展泛型的目的是为了弥补例如List只能存放一种特定类型数据的不足，将其扩展为List extends E> 使其可以接收E的子类型中的任何一种类型元素，这样使它的使用范围更广。
List super E>同理。
? 通配符类型
 extends T> 表示类型的上界，表示参数化类型的可能是T 或是 T的子类
 super T> 表示类型下界(Java Core中叫超类型限定)，表示参数化类型是此类型的超类型(父类型)，直至Object
在Java的类型擦除我们提到过：类型擦除中第一步——将所有的泛型参数用其最左边界(最顶级的父类型)类型替换。
这里的左边届可以通过extends来体现。
当生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数 ()，它的擦除是 Object。对于上限类型参数(>)，它的擦除是其上限(在本例中是 Comparable)的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。
extends
上界用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。
比如，我们现在定义：List extends T>首先你很容易误解它为继承于T的所有类的集合，你可能认为，你定义的这个List可以用来put任何T的子类，那么我们看一下下面的代码：
importjava.util.LinkedList;importjava.util.List;/**
* @author hollis
*/publicclasstestGeneric {publicstaticvoidmain(String[]args){List<?extendsSeason>seasonList =newLinkedList<>();seasonList.add(newSpring());}}classSeason{}classSpringextendsSeason{}
seasonList.add(new Spring());这行会报错：The method put(Spring) is undefined for the type List
List extends Season> 表示 “具有任何从Season继承类型的列表”，编译器无法确定List所持有的类型，所以无法安全的向其中添加对象。可以添加null,因为null 可以表示任何类型。所以List 的add 方法不能添加任何有意义的元素，但是可以接受现有的子类型List 赋值。
你也许试图这样做：
List<?extendsSeason>seasonList =newLinkedList();seasonList.add(newSpring());
但是，即使指明了Spring，也不能用add方法添加一个Spring对象。
list中为什么不能加入Season类和Season类的子类呢，原因是这样的：
List extends Fruit>表示上限是Fruit,下面这样的赋值都是合法的
List<?extendsSeason>list1 =newArrayList();List<?extendsSeason>list2 =newArrayList();List<?extendsSeason>list3 =newArrayList();
如果List extends Season>支持add方法的方法合法的话
list1可以add Season和所有Season的子类
list2可以add Spring和所有Spring的子类
list3可以add Winter和所有Winter的子类
这样的话，问题就出现了
List extends Season>所应该持有的对象是Season的子类，而且具体是哪一个子类还是个未知数，所以加入任何Season的子类都会有问题，
因为如果add Spring的话，可能List extends Season>持有的对象是new ArrayList()
Spring的加入肯定是不行的，如果 如果add Winter的话，可能List extends Season>持有的对象是new ArrayList()
Winter的加入又不合法，所以List extends Season> list 不能进行add
但是，这种形式还是很有用的，虽然不能使用add方法，但是可以在初始化的时候一个Season指定不同的类型。比如：
List extends Season> list1 = getSeasonList();//getSeasonList方法会返回一个Season的子类的list
另外，由于我们已经保证了List中保存的是Season类或者他的某一个子类，所以，可以用get方法直接获得值：
List<?extendsSeason>seasonList =newLinkedList();Springspring =(Spring)seasonList.get(0);Seasonseason =seasonList.get(1);
super
下界用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object。
如：
Listfruits =newArrayList();List<?superApple>=fruits;fruits.add(newApple());//workfruits.add(newRedApple());//workfruits.add(newFruit());//compile error fruits.add(newObject());//compile error
这里的fruits是一个Apple的超类(父类,superclass)的List。同样地，出于对类型安全的考虑，我们可以加入Apple对象或者其任何子类(如RedApple)对象，但由于编译器并不知道List的内容究竟是Apple的哪个超类，因此不允许加入特定的任何超类型。
而当我们读取的时候，编译器在不知道是什么类型的情况下只能返回Object对象，因为Object是任何Java类的最终祖先类。
PECS原则
如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
如果既要存又要取，那么就不要使用任何通配符。