精华内容
下载资源
问答
  • 在Java中,通过关键字extends继承一个已有类,被继承类称为父类(超类,基类),新类称为子类(派生类)。在Java中不允许多继承。(1)继承classAnimal{voideat(){System.out.println("Animaleat");}voidsleep(){...

    理解继承是理解面向对象程序设计的关键。在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排序,该方法...

    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&...

    基本用法可以参考下面这个问题中胖君的回答

    Java 泛型 <? super T> 中 super 怎么 理解?与 extends 有何不同?www.zhihu.com
    b22227b4fcd721775a96211b43bfeaea.png
    胖君www.zhihu.com
    7d8780f944b672d1413af487c66a923e.png

    有些疑惑的点在这篇文章中再详细解决一下。

    1. <? 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链接:...首先,泛型出现时为了安全,所有与泛型相关异常都应该编译期间发现,因此为了泛型绝对安全,java在设计时做了相关限制:List extends E>表示该list集...

    作者: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)

    如果既要存又要取,那么就不要使用任何通配符。

    展开全文
  • 平时看源码时候我们经常看到泛型,且经常会看到extends和super使用,看过其他文章里也有讲到上界通配符和下届通配符,总感觉讲不够明白。这里备注一下,以免忘记。extends也成为上界通配符,就是指定上...
  • java中extends与implements区别浅谈 1. 声明,通过关键字extends来创建一个类子类。一个类通过关键字implements声明自己使用一个或者多个接口。 extends 是继承某个类, 继承之后可以使用父类...
  • Java的extends用法

    2019-09-16 14:41:56
    理解继承是理解面向对象程序...在Java中,通过关键字extends继承一个已有类,被继承类称为父类(超类,基类),新类称为子类(派生类)。在Java中不允许多继承。 (1)继承 [java] view plain copy ...
  • JAVA的extends用法

    2019-11-21 15:57:39
    在Java中,通过关键字extends继承一个已有类,被继承类称为父类(超类,基类),新类称为子类(派生类)。在Java中不允许多继承。 (1)继承 [java] view plain copy 在CODE上查看代码片派生到我代码片 class ...
  • java继承extends

    2020-11-29 00:57:59
    在Java,如果要实现继承关系,可以使用如下语法: class 子类 extends 父类 {} 子类又被称为派生类; 父类又被称为超类(Super Class)。C++里似乎没有超类这个说法,一般是说基类。 可见,java使用extends...
  • 本文是看了几篇网络博客后,加上自己理解所得。...java中extends和implements区别主要有以下两点: 1.extends表示类继承:如Class Dog entends Class Animal表示子类Dog继承父类Animal;类继承
  • 1. 声明,通过关键字extends来创建一个类子类。一个类通过关键字implements声明自己使用一个或者多个接口。 extends 是继承某个类, 继承之后可以使用父类方法, 也可以重写父类方法; implements 是...
  • 泛型 <? extends T> 代表是T子类,一个子类而不是集合 应为不能确定是哪一种子类, <? extends T> 表达意思是 存储都为T子类 ...[这里插入图片描述](https://img-blog.csdnimg.cn/20191211...
  • 最近重新学习Android,发现用到了很多类之间的extends与implements,这里就浅谈一下它们之间的区别 extends(继承类) implements(实现接口) 区别: 1)Java中继承类只能继承一个,而实现接口则可以实现多个 2)...
  • 1、声明,通过关键字extends来创建一个类子类。 一个类通过关键字implements声明自己使用一个或者多个接口。  extends 是继承某个类, 继承之后可以使用父类方法, 也可以重写父类方法;  ...
  • java中extends与implements区别浅谈,需要朋友可以参考一下 1. 声明,通过关键字extends来创建一个类子类。一个类通过关键字implements声明自己使用一个或者多个接口。 extends 是继承某个类, 继承...
  • 环境 java:1.7+ 前言 主要讲是&amp;... extends T&...区别!...这个是我打算封装一段通用代码时,发现经常用&... extends T&...从stackoverflow看到一个很好解释,这里记下笔记; exten
  • JAVA中extends 与implements

    2012-10-06 18:09:24
    1. 声明,通过关键字extends来创建一个类子类。一个类通过关键字implements声明自己使用一个或者多个接口。 extends 是继承某个类, 继承之后可以使用父类方法, 也可以重写父类方法; implements 是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,206
精华内容 4,082
关键字:

在java的extends中

java 订阅