Java中的和？extends是什么意思

继承嘛，http://baike.baidu.com/view/745501.htm

从概念上来说，extends表示的是类与类或接口与接口的继承，implements表示的是类对接口的实现。也就是说，一个是扩展，另一个是实现。从设计思路来回答，就要讲明白为什么会有类和接口这两个不同的概念。事实上，仅仅通过类的单继承就可以解决绝大部分问题，而C++的多重继承可以解决任何面向对象问题。之所以要设计接口这个概念，主要还是为了使面向对象设计中的多态得到优美的解决。接口是一个特殊的抽象类。Java的设计者认为，多重继承增加了系统设计和实现时的复杂性，并且容易出错和产生歧义（例如A同时继承了B和C，而A定义了一个方法，在B和C中都存在这个方法的同名方法，此时A重写了B还是C的方法？），因此Java只允许单重继承，这完全是Java的设计者强加的限制。为了解决单重继承无法解决的问题（或者说不容易解决的问题），Java设计者设计了接口的概念，实际上，Java设计者鼓励使用接口而不是继承，因为接口的抽象性更加纯粹。总结：单继承+接口和多继承都是为了解决面向对象问题，只是方式不同。在Java设计者看来，单继承+接口的好处 > 多继承

ES6中有关 class 的继承方式，引入了 extends 关键字。 但其本质仍然是 构造函数 + 原型链的 组合式继承。 上述 B 类 （class）通过 extends 关键字，继承了 A 类 的所有属性和方法。 A 类 中的所有方法默认是添加到 B 的原型上，所以 extends 继承的实质仍然是原型链。 super 这个关键字，既可以当作函数使用，也可以当作对象使用。当作函数使用时 super 代表父类的构造函数，并在子类中执行 Parent.apply(this) ，从而将父类实例对象的属性和方法，添加到子类的 this 上面。 特别注意 因为类必须通过 new 关键字调用，所以在类的构造函数中 new.target 的值永远不会是 undefined 。

哈哈~1l小白来了，问题就解决了，就像他说的那样，下面只需要给a类增加一个无参数构造方法就行了。classa{protectedstringname;protectedintage;protectedstringgender="woman";publica(){}publica(inta){age=a;}publica(stringn){name=n;}publica(inta,stringn){age=a;name=n;}publicvoidshow(){system.out.println("name="+name);system.out.println("gender="+gender);system.out.println("age="+age);}}

哈哈，选我吧，implements关键字为对接口的继承extends关键字则是对类的继承该处直接将implements改为extends可以了。

“都说随便用extends 是个大忌”，这句话本身就不成立。任何优秀框架的源码，extends的使用都是非常之多，而且类继承、实现的关系，非常之深。如果一定要定义最适合用，那就是：功能 or 业务，归属于同一大类。

extends是继承impletements是接口java一个类最多只能继承一个，但是可以有多个接口，接口里的所有方法都要重写

extends

引用 和 再定义 的区别

给你顺序解释下泛型的意思哈：<T>：定义一个泛型 T ：定义方法返回的类型是之前定义的泛型类型 Class<? extends T> 这个是定义参数的类型为Class， 但是这个Class必须是和之前定义的泛型有继承关系的。？表示任意类的Class，不过后面跟了extends 表明了条件。

可以说没什么区别

public class son extends father{ //son code }public class father{ //father code}就是这么简单 多用用就会了。

看来你没理解面向对象的含义，重新去学习下什么是面向对象编程吧！ 学会了就理解的很透彻啦！

　　说JAVA继承有害，主要是因为实现继承(extends 关系)的关系，主要表现在以下几方面：　　1，实现类继承，将会失去灵活性，明确的使用具体类名将固定到特定的实现，给底层的改变增加了不必要的困难；　　2，耦合：就是那种程序的一部分对于另一部分的依赖；如果改变全局变量的类型，那么所有用到这个变量的函数也许都被影响，所有这些代码都要被检查，变更和重新测试。　　3，脆弱的基类问题：基础类被认为是脆弱的，是因为你在看起来安全的情况下修改基类，但是当从派生类继承时，新的行为也许引起派生类出现功能紊乱。　　

英语单复数问题，主语是单数

class 类 implements 接口1,接口2,...class 子类 extends 父类父类只能继承一个，java不允许多重继承。当然，可以使用内部类或其他方式间接实现多重继承。

extends，你需要知道父类的结构和代码。。感觉表述有点不清楚，应该就是这么个意思。。

不一定的 只需要继承 抽象方法 抽象类也可能有非抽象的方法

泛型中<? extends T>和<? super T> 差别<? extends T>和<? super T>含有JAVA5.0的新的概念。由于它们的外表导致了很多人误解了它们的用途： 1.<? extends T>首先你很容易误解它为继承于T的所有类的集合，这是大错特错的，相信能看下去你一定见过或用过List<? extends T>吧？为什么我说理解成一个集合是错呢？如果理解成一个集合那为什么不用List<T>来表示？所以<? extends T>不是一个集合，而是T的某一种子类的意思，记住是一种，单一的一种，问题来了，由于连哪一种都不确定，带来了不确定性，所以是不可能通过 add（）来加入元素。你或许还觉得为什么add(T)不行?因为<? extends T>是T的某种子类，能放入子类的容器不一定放入超类，也就是没可能放入T。2.<? super T>这里比较容易使用，没<? extends T>这么多限制，这里的意思是，以T类为下限的某种类，简单地说就是T类的超类。但为什么add(T)可以呢？因为能放入某一类的容器一定可以放入其子类，多态的概念。擦除也许泛型最具挑战性的方面是擦除（erasure），这是 Java 语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。通过擦除实现泛型的含意是很重要的，并且初看也是混乱的。尽管不能将List<Integer> 赋给List<Number>，因为它们是不同的类型，但是 List<Integer> 和 List<Number> 类型的变量是相同的类！要明白这一点，请评价下面的代码：new List<Number>().getClass() == new List<Integer>().getClass()编译器只为 List 生成一个类。当生成了 List 的字节码时，将很少剩下其类型参数的的跟踪。当生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数（<V>），它的擦除是 Object。对于上限类型参数（<K extends Comparable<K>>），它的擦除是其上限（在本例中是 Comparable）的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。如果检查生成的字节码，您无法说出 List<Integer> 和 List<String> 的代码之间的区别。类型限制 T 在字节码中被 T 的上限所取代，该上限一般是 Object。 多重限制一个类型参数可以具有多个限制。当您想要约束一个类型参数比如说同时为 Comparable 和 Serializable 时，这将很有用。多重限制的语法是用“与”符号分隔限制：class C<T extends Comparable<? super T>&Serializable>通配符类型可以具有单个限制 —— 上限或者下限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。类型形参和类型实参在参数化类的定义中，占位符名称（比如 Collection<V> 中的 V）叫做类型形参（type parameter），它们类似于方法定义中的形式参数。在参数化类的变量的声明中，声明中指定的类型值叫做类型实参（type argument），它们类似于方法调用中的实际参数。但是实际中二者一般都通称为“类型参数”。所以给出定义：interface Collection<V> { ... }和声明：Collection<String> cs = new HashSet<String>();那么，名称 V（它可用于整个 Collection 接口体内）叫做一个类型形参。在 cs 的声明中，String 的两次使用都是类型实参（一次用于 Collection<V>，另一次用于 HashSet<V>）。关于何时可以使用类型形参，存在一些限制。大多数时候，可以在能够使用实际类型定义的任何地方使用类型形参。但是有例外情况。不能使用它们创建对象或数组，并且不能将它们用于静态上下文中或者处理异常的上下文中。还不能将它们用作父类型（class Foo<T> extends T），不能用于 instanceof 表达式中，不能用作类常量。类似地，关于可以使用哪些类型作为类型实参，也存在一些限制。类型实参必须是引用类型（不是基本类型）、通配符、类型参数，或者其他参数化类型的实例化。所以您可以定义 List<String>（引用类型）、List<?>（通配符）或者 List<List<?>>（其他参数化类型的实例化）。在带有类型形参 T 的参数化类型的定义中，您也可以声明 List<T>（类型形参）。

泛型中<? extends T>和<? super T> 差别<? extends T>和<? super T>含有JAVA5.0的新的概念。由于它们的外表导致了很多人误解了它们的用途： 1.<? extends T>首先你很容易误解它为继承于T的所有类的集合，这是大错特错的，相信能看下去你一定见过或用过List<? extends T>吧？为什么我说理解成一个集合是错呢？如果理解成一个集合那为什么不用List<T>来表示？所以<? extends T>不是一个集合，而是T的某一种子类的意思，记住是一种，单一的一种，问题来了，由于连哪一种都不确定，带来了不确定性，所以是不可能通过 add（）来加入元素。你或许还觉得为什么add(T)不行?因为<? extends T>是T的某种子类，能放入子类的容器不一定放入超类，也就是没可能放入T。2.<? super T>这里比较容易使用，没<? extends T>这么多限制，这里的意思是，以T类为下限的某种类，简单地说就是T类的超类。但为什么add(T)可以呢？因为能放入某一类的容器一定可以放入其子类，多态的概念。擦除也许泛型最具挑战性的方面是擦除（erasure），这是 Java 语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。通过擦除实现泛型的含意是很重要的，并且初看也是混乱的。尽管不能将List<Integer> 赋给List<Number>，因为它们是不同的类型，但是 List<Integer> 和 List<Number> 类型的变量是相同的类！要明白这一点，请评价下面的代码：new List<Number>().getClass() == new List<Integer>().getClass()编译器只为 List 生成一个类。当生成了 List 的字节码时，将很少剩下其类型参数的的跟踪。当生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数（<V>），它的擦除是 Object。对于上限类型参数（<K extends Comparable<K>>），它的擦除是其上限（在本例中是 Comparable）的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。如果检查生成的字节码，您无法说出 List<Integer> 和 List<String> 的代码之间的区别。类型限制 T 在字节码中被 T 的上限所取代，该上限一般是 Object。多重限制一个类型参数可以具有多个限制。当您想要约束一个类型参数比如说同时为 Comparable 和 Serializable 时，这将很有用。多重限制的语法是用“与”符号分隔限制：class C<T extends Comparable<? super T>&Serializable>通配符类型可以具有单个限制 —— 上限或者下限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。类型形参和类型实参在参数化类的定义中，占位符名称（比如 Collection<V> 中的 V）叫做类型形参（type parameter），它们类似于方法定义中的形式参数。在参数化类的变量的声明中，声明中指定的类型值叫做类型实参（type argument），它们类似于方法调用中的实际参数。但是实际中二者一般都通称为“类型参数”。所以给出定义：interface Collection<V> { ... }和声明：Collection<String> cs = new HashSet<String>();那么，名称 V（它可用于整个 Collection 接口体内）叫做一个类型形参。在 cs 的声明中，String 的两次使用都是类型实参（一次用于 Collection<V>，另一次用于 HashSet<V>）。关于何时可以使用类型形参，存在一些限制。大多数时候，可以在能够使用实际类型定义的任何地方使用类型形参。但是有例外情况。不能使用它们创建对象或数组，并且不能将它们用于静态上下文中或者处理异常的上下文中。还不能将它们用作父类型（class Foo<T> extends T），不能用于 instanceof 表达式中，不能用作类常量。类似地，关于可以使用哪些类型作为类型实参，也存在一些限制。类型实参必须是引用类型（不是基本类型）、通配符、类型参数，或者其他参数化类型的实例化。所以您可以定义 List<String>（引用类型）、List<?>（通配符）或者 List<List<?>>（其他参数化类型的实例化）。在带有类型形参 T 的参数化类型的定义中，您也可以声明 List<T>（类型形参）。

就效果来说和直接<T>其实效果一样，因为java有多态自带子类转父类的强制转换，- -不过那样会有一个强制转换的过程。其实用泛型通配符就是存储的时候起到约束和提高性能的作用。平时除了bat大厂代码和java源码基本看不到这玩意。

泛型中<? extends T>和<? super T> 差别<? extends T>和<? super T>含有JAVA5.0的新的概念。由于它们的外表导致了很多人误解了它们的用途： 1.<? extends T>首先你很容易误解它为继承于T的所有类的集合，这是大错特错的，相信能看下去你一定见过或用过List<? extends T>吧？为什么我说理解成一个集合是错呢？如果理解成一个集合那为什么不用List<T>来表示？所以<? extends T>不是一个集合，而是T的某一种子类的意思，记住是一种，单一的一种，问题来了，由于连哪一种都不确定，带来了不确定性，所以是不可能通过 add（）来加入元素。你或许还觉得为什么add(T)不行?因为<? extends T>是T的某种子类，能放入子类的容器不一定放入超类，也就是没可能放入T。2.<? super T>这里比较容易使用，没<? extends T>这么多限制，这里的意思是，以T类为下限的某种类，简单地说就是T类的超类。但为什么add(T)可以呢？因为能放入某一类的容器一定可以放入其子类，多态的概念。擦除也许泛型最具挑战性的方面是擦除（erasure），这是 Java 语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。通过擦除实现泛型的含意是很重要的，并且初看也是混乱的。尽管不能将List<Integer> 赋给List<Number>，因为它们是不同的类型，但是 List<Integer> 和 List<Number> 类型的变量是相同的类！要明白这一点，请评价下面的代码：new List<Number>().getClass() == new List<Integer>().getClass()编译器只为 List 生成一个类。当生成了 List 的字节码时，将很少剩下其类型参数的的跟踪。当生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数（<V>），它的擦除是 Object。对于上限类型参数（<K extends Comparable<K>>），它的擦除是其上限（在本例中是 Comparable）的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。如果检查生成的字节码，您无法说出 List<Integer> 和 List<String> 的代码之间的区别。类型限制 T 在字节码中被 T 的上限所取代，该上限一般是 Object。多重限制一个类型参数可以具有多个限制。当您想要约束一个类型参数比如说同时为 Comparable 和 Serializable 时，这将很有用。多重限制的语法是用“与”符号分隔限制：class C<T extends Comparable<? super T>&Serializable>通配符类型可以具有单个限制 —— 上限或者下限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。类型形参和类型实参在参数化类的定义中，占位符名称（比如 Collection<V> 中的 V）叫做类型形参（type parameter），它们类似于方法定义中的形式参数。在参数化类的变量的声明中，声明中指定的类型值叫做类型实参（type argument），它们类似于方法调用中的实际参数。但是实际中二者一般都通称为“类型参数”。所以给出定义：interface Collection<V> { ... }和声明：Collection<String> cs = new HashSet<String>();那么，名称 V（它可用于整个 Collection 接口体内）叫做一个类型形参。在 cs 的声明中，String 的两次使用都是类型实参（一次用于 Collection<V>，另一次用于 HashSet<V>）。关于何时可以使用类型形参，存在一些限制。大多数时候，可以在能够使用实际类型定义的任何地方使用类型形参。但是有例外情况。不能使用它们创建对象或数组，并且不能将它们用于静态上下文中或者处理异常的上下文中。还不能将它们用作父类型（class Foo<T> extends T），不能用于 instanceof 表达式中，不能用作类常量。类似地，关于可以使用哪些类型作为类型实参，也存在一些限制。类型实参必须是引用类型（不是基本类型）、通配符、类型参数，或者其他参数化类型的实例化。所以您可以定义 List<String>（引用类型）、List<?>（通配符）或者 List<List<?>>（其他参数化类型的实例化）。在带有类型形参 T 的参数化类型的定义中，您也可以声明 List<T>（类型形参）。

关闭服务器中的php 错误提示

一个导入包，一个是继承

1、如果父类和子类中都没有显式的定义__construct，在实例化子类对象时，只会隐含的调用子类自己的构造方法。2、如果父类中有显式的构造方法__construct，而子类中没有定义__construct，在实例化子类对象时，就会调用父类中的构造方法。3、如果父类和子类中都显式的定义了__construct，在实例化子类对象时，只会调用子类自己的构造方法(这就像是子类重构了父类的构造方法)，而如果也想要调用父类的构造方法的话，就需要在子类的__construct 方法中显式的调用，（如 __construct(){ parent::_construct();}）。扩展资料子类的构造函数名与子类名相同。在子类里父类的构造函数不会自动执行。要在子类里执行父类的构造函数，必须执行类似以下语句：$this->[父类的构造函数名()]类的构造函数统一命名为__construct()。子类的构造函数名也是__construct()（也是废话）。在子类里父类的构造函数会不会执行，分两种情况：1、如子类不定义构造函数 __construct()，则父类的构造函数默认会被继承下来，且会自动执行。2、如子类定义了构造函数 __construct()，因为构造函数名也是__construct()，所以子类的构造函数实际上是覆盖(override)了父类的构造函数。这时执行的是该子类的构造函数。这时如果要在子类里执行父类的构造函数，必须执行类似以下语句：parent::__construct();参考资料来源：百度百科——继承

在itjob学习时出现过public static void amethod() throws FileNotFounfException{}-->这里异常名错误，应为FileNotFoundException另外Stream.in错误，是否应该是系统标准输入？System.in两个都改了之后就可以正确编译了。

导入类，就是使用那个类的一些方法或变量，继承类是实现代码的重用，导入类无法实现这个功能的

首先,android开发中很多界面都需要用的方法,类似于初始化,生命周期的管理或者activity堆栈的管理都需要每个activity进行写,这些工作可以写一个base让别的继承,减少工作量并方便管理.就例如你想要写一个activitymanager控制程序退出和堆栈管理,在每个activity创建或者销毁的时候都需要去添加,删除.这种情况下如果使用base的话是不是在别的界面就不用再写而且方便呢?

大多数好的设计者象躲避瘟疫一样来避免使用实现继承(extends 关系)。实际上80%的代码应该完全用interfaces写，而不是通过extends。“JAVA设计模式”一书详细阐述了怎样用接口继承代替实现继承。这篇文章描述设计者为什么会这么作。Extends是有害的；也许对于Charles Manson这个级别的不是，但是足够糟糕的它应该在任何可能的时候被避开。“JAVA设计模式”一书花了很大的部分讨论用interface继承代替实现继承。好的设计者在他的代码中，大部分用interface，而不是具体的基类。本文讨论为什么设计者会这样选择，并且也介绍一些基于interface的编程基础。接口（Interface）和类（Class）?一次，我参加一个Java用户组的会议。在会议中，Jams Gosling（Java之父）做发起人讲话。在那令人难忘的QA部分，有人问他：“如果你重新构造Java，你想改变什么？”。“我想抛弃classes”他回答。在笑声平息后，它解释说，真正的问题不是由于class本身，而是实现继承(extends 关系)。接口继承（implements关系）是更好的。你应该尽可能的避免实现继承。失去了灵活性为什么你应该避免实现继承呢？第一个问题是明确的使用具体类名将你固定到特定的实现，给底层的改变增加了不必要的困难。在当前的敏捷编程方法中，核心是并行的设计和开发的概念。在你详细设计程序前，你开始编程。这个技术不同于传统方法的形式----传统的方式是设计应该在编码开始前完成----但是许多成功的项目已经证明你能够更快速的开发高质量代码，相对于传统的按部就班的方法。但是在并行开发的核心是主张灵活性。你不得不以某一种方式写你的代码以至于最新发现的需求能够尽可能没有痛苦的合并到已有的代码中。胜于实现你也许需要的特征，你只需实现你明确需要的特征，而且适度的对变化的包容。如果你没有这种灵活，并行的开发，那简直不可能。对于Inteface的编程是灵活结构的核心。为了说明为什么，让我们看一下当使用它们的时候，会发生什么。考虑下面的代码：f(){ LinkedList list = new LinkedList();//...g( list );}g( LinkedList list ){list.add( ... );g2( list )}现在，假设一个对于快速查询的需求被提出，以至于这个LinkedList不能够解决。你需要用HashSet来代替它。在已有代码中，变化不能够局部化，因为你不仅仅需要修改f()也需要修改g()（它带有LinkedList参数），并且还有g()把列表传递给的任何代码。象下面这样重写代码:f(){ Collection list = new LinkedList();//...g( list );}g( Collection list ){list.add( ... );g2( list )}这样修改Linked list成hash，可能只是简单的用new HashSet()代替new LinkedList()。就这样。没有其他的需要修改的地方。作为另一个例子，比较下面两段代码： f(){ Collection c = new HashSet();//...g( c );}g( Collection c ){for( Iterator i = c.iterator(); i.hasNext() )do_something_with( i.next() );}和f2(){ Collection c = new HashSet();//...g2( c.iterator() );}g2( Iterator i ){ while( i.hasNext() )do_something_with( i.next() );}g2()方法现在能够遍历Collection的派生，就像你能够从Map中得到的键值对。事实上，你能够写iterator，它产生数据，代替遍历一个Collection。你能够写iterator，它从测试的框架或者文件中得到信息。这会有巨大的灵活性。耦合对于实现继承，一个更加关键的问题是耦合---令人烦躁的依赖，就是那种程序的一部分对于另一部分的依赖。全局变量提供经典的例子，证明为什么强耦合会引起麻烦。例如，如果你改变全局变量的类型，那么所有用到这个变量的函数也许都被影响，所以所有这些代码都要被检查，变更和重新测试。而且，所有用到这个变量的函数通过这个变量相互耦合。也就是，如果一个变量值在难以使用的时候被改变，一个函数也许就不正确的影响了另一个函数的行为。这个问题显著的隐藏于多线程的程序。作为一个设计者，你应该努力最小化耦合关系。你不能一并消除耦合，因为从一个类的对象到另一个类的对象的方法调用是一个松耦合的形式。你不可能有一个程序，它没有任何的耦合。然而，你能够通过遵守OO规则，最小化一定的耦合（最重要的是，一个对象的实现应该完全隐藏于使用他的对象）。例如，一个对象的实例变量（不是常量的成员域），应该总是private。我意思是某段时期的，无例外的，不断的。（你能够偶尔有效地使用protected方法，但是protected实例变量是可憎的事）同样的原因你应该不用get/set函数---他们对于是一个域公用只是使人感到过于复杂的方式（尽管返回修饰的对象而不是基本类型值的访问函数是在某些情况下是由原因的，那种情况下，返回的对象类是一个在设计时的关键抽象）。这里，我不是书生气。在我自己的工作中，我发现一个直接的相互关系在我OO方法的严格之间，快速代码开发和容易的代码实现。无论什么时候我违反中心的OO原则，如实现隐藏，我结果重写那个代码（一般因为代码是不可调试的）。我没有时间重写代码，所以我遵循那些规则。我关心的完全实用?我对干净的原因没有兴趣。脆弱的基类问题现在，让我们应用耦合的概念到继承。在一个用extends的继承实现系统中，派生类是非常紧密的和基类耦合，当且这种紧密的连接是不期望的。设计者已经应用了绰号“脆弱的基类问题”去描述这个行为。基础类被认为是脆弱的是，因为你在看起来安全的情况下修改基类，但是当从派生类继承时，新的行为也许引起派生类出现功能紊乱。你不能通过简单的在隔离下检查基类的方法来分辨基类的变化是安全的；而是你也必须看（和测试）所有派生类。而且，你必须检查所有的代码，它们也用在基类和派生类对象中，因为这个代码也许被新的行为所打破。一个对于基础类的简单变化可能导致整个程序不可操作。让我们一起检查脆弱的基类和基类耦合的问题。下面的类extends了Java的ArrayList类去使它像一个stack来运转：class Stack extends ArrayList{ private int stack_pointer = 0;public void push( Object article ){ add( stack_pointer++, article );}public Object pop(){ return remove( --stack_pointer );}public void push_many( Object[] articles ){ for( int i = 0; iarticles.length; ++i )push( articles[i] );}}甚至一个象这样简单的类也有问题。思考当一个用户平衡继承和用ArrayList的clear()方法去弹出堆栈时：Stack a_stack = new Stack();a_stack.push("1");a_stack.push("2");a_stack.clear();这个代码成功编译，但是因为基类不知道关于stack指针堆栈的情况,这个stack对象当前在一个未定义的状态。下一个对于push（）调用把新的项放入索引2的位置。（stack_pointer的当前值），所以stack有效地有三个元素-下边两个是垃圾。（Java的stack类正是有这个问题，不要用它）.对这个令人讨厌的继承的方法问题的解决办法是为Stack覆盖所有的ArrayList方法，那能够修改数组的状态，所以覆盖正确的操作Stack指针或者抛出一个例外。(removeRange()方法对于抛出一个例外一个好的候选方法)。这个方法有两个缺点。第一，如果你覆盖了所有的东西，这个基类应该真正的是一个interface，而不是一个class。如果你不用任何继承方法，在实现继承中就没有这一点。第二，更重要的是，你不能够让一个stack支持所有的ArrayList方法。例如，令人烦恼的removeRange()没有什么作用。唯一实现无用方法的合理的途径是使它抛出一个例外，因为它应该永远不被调用。这个方法有效的把编译错误成为运行错误。不好的方法是，如果方法只是不被定义，编译器会输出一个方法未找到的错误。如果方法存在，但是抛出一个例外，你只有在程序真正的运行时，你才能够发现调用错误。#p#副标题#e#对于这个基类问题的一个更好的解决办法是封装数据结构代替用继承。这是新的和改进的Stack的版本：class Stack{private int stack_pointer = 0;private ArrayList the_data = new ArrayList();public void push( Object article ){the_data.add( stack_poniter++, article );}public Object pop(){return the_data.remove( --stack_pointer );}public void push_many( Object[] articles ){for（ int i = 0; io.length; ++i ）push( articles[i] );}}到现在为止，一直都不错，但是考虑脆弱的基类问题，我们说你想要在stack创建一个变量， 用它在一段周期内跟踪最大的堆栈尺寸。一个可能的实现也许象下面这样:class Monitorable_stack extends Stack{private int high_water_mark = 0;private int current_size;public void push( Object article ){if( ++current_sizehigh_water_mark )high_water_mark = current_size;super.push( article );}publish Object pop(){--current_size;return super.pop();}public int maximum_size_so_far(){return high_water_mark;}}这个新类运行的很好，至少是一段时间。不幸的是，这个代码发掘了一个事实，push_many()通过调用push()来运行。首先，这个细节看起来不是一个坏的选择。它简化了代码，并且你能够得到push()的派生类版本，甚至当Monitorable_stack通过Stack的参考来访问的时候，以至于high_water_mark能够正确的更新。#p#副标题#e#

貌似接口只能继承接口，不能继承非接口包括抽象类在内的其它类，object祖先类貌似是体现在接口的实现类之上。

class a{}class b extends a{}那么b就继承了a,是a 的子类要说快捷方法的话 就是new -> class 那个对话框superclass-> Browse ->然后打父类的名字 会自动映射出符合的类名或者新建完类 然后手打extends 用Alt+/ 映射出所有父类名

只需要理解 覆盖并非真正的覆盖 父类的构造函数还是存在的，只是不能自动调用而已。所以必须在子类构造函数声明才能调用父类的构造函数。继承相当于copy了一份 不会真正改变父类的代码。要不然多个子类继承同一个父类，不是就乱套了吗。

符合要求的对象的类必须是同时是 A 和 B 的子类

默认继承Object类，所以拥有Object类的所有方法

？是“任意类”的意思，extends继承不多说，E是指定类型。 首先，楼上说的不错，是泛型。这是java 1.5以后引入的。 从此以后，定义一个空的ArrayList需要这样，比如我需要一个MyClass的顺序表，则： ArrayList myList = new ArrayList(); 这是因为...

extends是继承的关键词Coffee类继承了Drink类Coffee是子类，Drink是父类

java不能多继承 但是可以实现多个接口

e 是element 元素,用来定义泛型,可以不写,但是取值的时候要强转,用了泛型就不需要强转(强制类型转换)

1、private修饰词，表示成员是私有的，只有自身可以访问； 2、protected，表示受保护权限，体现在继承，即子类可以访问父类受保护成员，同时相同包内的其他类也可以访问protected成员。 3、无修饰词（默认），表示包访问权限（friendly， java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++ ），同一个包内可以访问，访问权限是包级访问权限； 4、public修饰词，表示成员是公开的，所有其他类都可以访问；泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

错误啊。接口A extends 接口B 没错接口B extends 接口A 没错但是 接口A extends 接口B 且 接口B extends 接口A 错了 不能循环继承

<? extends T>代表方括号中必须是任意的T的子类或者T自己

父类或子类的实例。当使用list=约束一个类时，在类中使用该类的属性或方法，PHP会自动识别它是一个子类，可以访问父类和子类共有的属性和方法。因此，当使用list=约束一个类时，拿出来的是一个父类或子类的实例。在PHP中，是一个泛型类型约束的语法，用于指定一个类或接口必须是另一个类或接口的子类或子接口。

object是默认基类，不用显式声明。

其中funnytest是其中一个app,funnytest 目录下设置了一个Urls, 内容为: --- from django.conf.urls import patterns, include, url from views impor

你试试在服务里有个“print spooler”，右击，点属性，将“登录”选项中的“允许服务与桌面交互”的勾去掉，重启服务。另外，在共享里面，在“端口”页中把“启动双向支持”取消掉也行开始-控制面板-计算机管理-服务，print spooler这个服务是否设置“自动”然后点“启动”在360里把这个程序给禁止了。重新打开就好了： 360高级工具-开机加速-服务选项下的“系统关键服务” 把print spooler找出来点“恢复启动”即可。用其它类似软件途径类似。

本诗开头四句，写卖炭翁的炭来之不易。“伐薪、烧炭”，概括了复杂的工序和漫长的劳动过程。“满面尘灰烟火色，两鬓苍苍十指黑”，活画出卖炭翁的肖像，写出劳动的艰辛，也得到了形象的表现。“南山中”点出劳动场所，这“南山”就是王维所写的“欲投人处宿，隔水问樵夫”的终南山，豺狼出没，荒无人烟。在这样的环境里披星戴月，凌霜冒雪，一斧一斧地“伐薪”，一窑一窑地“烧炭”，好容易烧出“千余斤”，每一斤都渗透着心血，也凝聚着希望。写出卖炭翁的炭是自己艰苦劳动的成果，这就把他和贩卖木炭的商人区别了开来。但是，假如这位卖炭翁还有田地，凭自种自收就不至于挨饿受冻，只利用农闲时间烧炭卖炭，用以补贴家用的话，那么他的一车炭被掠夺，就还有别的活路。然而情况并非如此。诗人的高明之处在于没有自己出面向读者介绍卖炭翁的家庭经济状况，而是设为问答：“卖炭得钱何所营？身上衣裳口中食。”这一问一答，不仅化板为活，使文势跌宕，摇曳生姿，而且扩展了反映民间疾苦的深度与广度，使读者清楚地看到：这位劳动者已被剥削得贫无立锥，别无衣食来源；“身上衣裳口中食”，全指望他千辛万苦烧成的千余斤木炭能卖个好价钱。这就为后面写宫使掠夺木炭的罪行做好了有力的铺垫。“可怜身上衣正单，心忧炭贱愿天寒。”这两句诗用同情的口吻，写出了卖炭翁艰难的处境和复杂的内心矛盾。当时正是“夜来城外一尺雪”的寒冬季节，身上只穿着单衣的老翁照理应该盼望着天气和暖起来，可是他却巴望着更冷一些，因为天气一暖，他的炭也就不值钱了。两句诗只写了老翁的一个心理活动，便把当时在饥寒交迫中挣扎的劳动人民的痛苦有力地揭示了出来。“夜来城外一尺雪，晓驾炭车辗冰辙。”幸而天公作美，夜里突降大雪，而且有“一尺”之厚，天气是足够寒冷了。因此这位老翁一大早就赶着牛车沿着那结了冰的车道向集市赶去。“牛困人饥日已高，市南门外泥中歇。”他希望能卖个好价钱，所以他来得很早，此时集市大门尚未打开，他不得不在门外的泥地中休息一会儿。人饿了，拉车的牛也累了，但他心里是高兴的，充满了希望，他差不多可以如愿以偿买上冬衣了。读到这儿，也许读者会怜悯他寒冷天气中只穿着那单薄的衣裳，但一想到他的炭因此可能卖个好价钱，也会不由替他高兴。然而，天有不测风云，就在卖炭翁心里盘算着怎样才能卖个好价钱的时候，远处两骑人马翩翩而来，原来是“黄衣使者白衫儿”驾到。“翩翩”二字本来是用以形容英俊潇洒之态，用在这里却含有讽刺、挖苦的意味，揭露了这两员太监趾高气扬，目中无人的嘴脸。因为是皇帝派来的，所以称“使者”。他们手里高举皇帝颁布的文告，口称皇帝的命令，不由分说，强行扭转车头，驱赶着老牛向皇宫方向走去。千余斤炭就这样被太监拉走了，留给老翁的不过是半匹红纱一丈绫而已。唐代商品交易，多用绢帛等丝织品充作一般等价物来代替货币，宫廷购买货物，往往按照官方高抬丝织品价格计算，而不依民间流行的实价，因此太监们仅用半匹纱一丈绫来支付千余斤炭钱，实际等于强行掠夺。读至此处，不由令人想起诗人的另一首诗《宿紫阁山北村》中，描写宦官们掌握的神策军强盗般抢劫百姓财物的野蛮行径。他们都是为宫廷官府服务的，然而他们的共同特点却是置平民百姓的身家性*命于不顾，强行掠夺民间财物。从“南山中”到长安城，路那么遥远，又那么难行，当卖炭翁“市南门外泥中歇”的时候，已经是“牛困人饥”；如今又“回车叱牛牵向北”，把炭送进皇宫，当然牛更困、人更饥了。那么，当卖炭翁饿着肚子，走回终南山的时候，他会想些什么呢，他往后的日子又怎样过法呢，这一切，诗人都没有写，然而读者却不能不想。当想到这一切的时候，就不能不同情卖炭翁的遭遇，不能不憎恨统治者的罪恶，而诗人“苦宫市”的创作意图，也就收到了预期的效果。这首诗的艺术特点，首先在于白描艺术手法的成功运用。作者通篇没发一句议论，说宫市给人民带来怎样的苦处，人民在这种残暴的掠夺下，怎样难以生活。而是通过一个卖炭老人的身世、磨难、烧炭、卖炭以及炭车被抢的前后经过，向人们讲述了一个催人涕下的悲剧故事，把老人的遭遇和宫市给人民带来的苦难形象地告诉了人们，从而使人们更加清楚、深刻地了解到当时阶级对立的现实，激起人们强烈的爱憎感情。这是作者发多少议论也难以达到的艺术效果。其次，诗中对人物形象的描写刻画细腻、逼真，使人们从人形象中受到强烈的感染。一是对人物外貌的刻画，二是对内心世界的描写。试看，“满面尘灰烟火色，两鬓苍苍十指黑”，简单而深情的十四个字，活活地勾画出卖炭老人的辛苦、贫困、衰老、遭难的外貌，使人见之同情，思之痛心。“可怜身上衣正单，心忧炭贱愿天寒”，又是简单而深情的十四个字，把老人瑟缩、委曲、矛盾、希求的心理又描写得多么深刻、细腻。使人仿佛看到一个蜷缩在屋角冻得发颤的老人，在愁苦地思索筹划着自己可怜的生活。从而更加拽拉人们的心灵，使人感到残酷的现实对老人是多么不公平！

说到北京的这个SOLANA蓝色港湾灯光节，这个目前已经举办了十三届了，今天将会是第十四届，不得不说这个SOLANA蓝色港湾灯光节确实是看起来非常的美丽，灯光颜色都是五彩绚丽的。那么本届的灯光节什么时候开始呢？门票多少钱？ 蓝色港湾灯光节开始时间2021年12月3日-2022年2月28日 地点介绍朝阳公园路6号SOLANA蓝色港湾门票价格免费 蓝色港湾灯光节游玩推荐1.与奇趣冰雪家族装置合照由西班牙艺术家MiguelAngelCamprubi设计的冬日户外运动冰雪乐园，色彩缤纷、造型奇异的卡通人物演绎着各种冬季运动，点缀于商区各个位置，充满愉悦有趣和活力!推荐位置：西广场门头、阿迪达斯广场、下沉广场、爱神广场大台阶2.观看演出除了SOLANA蓝色港湾第十四届灯光节，12月3日至12月5日期间，还有开幕表演点燃全场哦!大型巡游《冬日极限漫游》、互动舞剧《冰雪护卫队》、《LIGHTBURST》DJ表演等，带你开启年末倒计时模式!3.购物优惠SOLANA蓝色港湾周年庆福利来袭，临近年末，剁手来犒赏下自己!

_解的读音是：wùjiě。_解的拼音是：wùjiě。结构是：_(左右结构)解(左右结构)。_解的具体解释是什么呢，我们通过以下几个方面为您介绍：一、词语解释【点此查看计划详细内容】误解wùjiě。(1)理解得不对。(2)错误的理解。二、国语词典理解错误、判断错误。如：「我原本是一番好意，想不到你却误解了我的意思。」词语翻译英语tomisunderstand,tomisread,misunderstanding德语Missverst_ndnis,missverstehen,etw.,jmd.falschverstehen(S)法语malcomprendre,seméprendre,malentendu三、网络解释误解（汉语词汇）误解是认识与对象的不一致，即行为人对民事行为的内容或其他有关情况产生认识上的错误，意思表示与内心意志不一致。例如，买受人对出卖物的价格发生误解（价格为10000元，误解为1000元）等。关于_解的近义词误会关于_解的成语冰解冻释半解一知解衣般礴解甲归田放心解体解语花解衣卸甲妙语解颐妙语解烦老妪能解关于_解的词语妙语解颐解甲归田解衣卸甲解衣磅礴半解一知解衣般礴百思不解解语花放心解体冰解冻释点此查看更多关于_解的详细信息

卖炭翁是一个凄楚悲苦，痛恨官吏残暴的老人

三字经起源于宋末，现在市面上的都是增补版，其实就是增补了历史那段。也有增补常识的那段。以下是原版的三字经。即并未遭人修改过的。当然这也是我认为的。毕竟是否还有更早的版本，现在还不清楚。宋 原版人之初，性本善。性相近，习相远。苟不教，性乃迁。教之道，贵以专。昔孟母，择邻处。子不学，断机杼。窦燕山，有义方，教五子，名俱扬。养不教，父之过；教不严，师之惰。子不学，非所宜。幼不学，老何为？玉不琢，不成器；人不学，不知义。为人子，方少时，亲师友，习礼仪。香九龄，能温席。孝於亲，所当执。融四岁，能让梨。弟於长，宜先知。首孝弟，次见闻。知某数，识某文。一而十，十而百，百而千，千而万。三才者，天地人。三光者，日月星。三纲者，君臣义，父子亲，夫妇顺。曰春夏，曰秋冬，此四时，运不穷。曰南北，曰西东，此四方，应乎中。曰水火，木金土，此五行，本乎数。曰仁义，礼智信，此五常，不容紊。稻梁菽，麦黍稷，此六谷，人所食。马牛羊，鸡犬豕，此六畜，人所饲。曰喜怒，曰哀惧，爱恶欲，七情具。匏土革，木石金，与丝竹，乃八音。高曾祖，父而身，身而子，子而孙。自子孙，至玄曾，乃九族，人之伦。父子恩，夫妇从；兄则友，弟则恭；长幼序，友与朋；君则敬，臣则忠。此十义，人所同。凡训蒙，须讲究。详训诂，明句读。为学者，必有初。小学终，至四书。论语者，二十篇；群弟子，记善言。孟子者，七篇止；讲道德，说仁义。作中庸，子思笔；自修齐，至平治。孝经通，四书熟，如六经，始可读。诗书易，礼春秋，号六经，当讲求。有连山，有归藏，有周易，三易详。有典谟，有训诰，有誓命，书之奥。我周公，作周礼，著六官，存治体。大小戴，注礼记，述圣言，礼乐备。曰国风，曰雅颂，号四诗，当讽咏。诗既亡，春秋作，寓褒眨，别善恶。三传者，有公羊，有左氏，有榖梁。经既明，方读子。撮其要，记其事。五子者，有荀扬，文中子，及老庄。经子通，读诸史，考世系，知终始。自羲农，至黄帝，号三皇，居上世。唐有虞，号二帝，相揖逊，称盛世。夏有禹，商有汤，周文武，称三王。夏传子，家天下，四百载，迁夏社。汤伐夏，国号商，六百载，至纣亡。周武王，始诛纣，八百载，最长久。周辙东，王纲坠，逞干戈，尚游说。始春秋，终战国，五霸彊，七雄出。嬴秦氏，始兼并，传二世，楚汉争。高祖兴，汉业建，至孝平，王莽篡。光武兴，为东汉，四百年，终於献。蜀魏吴，分汉鼎，号三国，迄两晋。宋齐继，梁陈承，为南朝，都金陵。北元魏，分东西，宇文周，与高齐。迨至隋，一土宇，不再传，失统绪。唐高祖，起义师，除隋乱，创国基。二十传，三百载，梁灭之，国乃改。梁唐晋，及汉周，称五代，皆有由。炎宋兴，受周襌，十八传，南北混。十七史，全在兹。载治乱，知兴衰。读史者，考实录。通古今，若亲目。口而诵，心而惟。朝於斯，夕於斯。昔仲尼，师项橐，古圣贤，尚勤学。赵中令，读鲁论，彼既仕，学且勤。披蒲编，削竹简，彼无书，且知勉。头悬梁，锥刺股，彼不教，自勤苦。如囊萤，如映雪，家虽贫，学不辍。如负薪，如挂角，身虽劳，犹苦卓。蘇老泉，二十七，始发愤，读书籍。彼既老，犹悔迟；尔小生，宜早思。若梁灝，八十二，对大廷，魁多士。彼既成，众称异；尔小生，宜立志。莹八岁，能咏诗；泌七岁，能赋碁。彼颖悟，人称奇；尔幼学，当效之。蔡文姬，能辨琴；谢道韫，能咏吟。彼女子，且聪敏；尔男子，当自警。唐刘晏，方七岁，举神童，作正字，彼虽幼，身已仕；尔幼学，勉而致。有为者，亦若是。犬守夜，鸡司晨。苟不学，曷为人？蚕吐丝，蜂酿蜜。人不学，不如物。幼而学，壮而行。上致君，下泽民。扬名声，显父母。光於前，裕於後。人遗子，金满籯；我教子，惟一经。勤有功，戏无益。戒之哉，宜勉力。