请问java中继承的英文应该是什么？

继承嘛，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一个类最多只能继承一个，但是可以有多个接口，接口里的所有方法都要重写

引用 和 再定义 的区别

给你顺序解释下泛型的意思哈：<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，脆弱的基类问题：基础类被认为是脆弱的，是因为你在看起来安全的情况下修改基类，但是当从派生类继承时，新的行为也许引起派生类出现功能紊乱。　　

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

这就是范型。。就是说你这个集合就是DemoModule类型的

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

点击[http://pinyin.cn/1cShq0AA0JF] 查看这张图片。

* 回复内容中包含的链接未经审核，可能存在风险，暂不予完整展示！ PT-FDZ680采用WUXGA(1920x200)高分辨率，能够兼容宽屏幅信号源。采用两个300W的UHM灯泡，能提供6000流明的亮度，对比度为2000:1。同时还具有强光色彩补正功能，适合在亮度渐进的黑暗部位产生清晰的对比度高的图像。第二代强光色彩补正功能，即使在明亮的环境下，也能塑造出更清晰的图象。这种全新的控制技术来对色轮的色彩段进行控制，同时还加入了10比特深度画面处理系统，能使画面效果更加自然。更多请查看IT168 http://product.i***.com/detail/doc/372681/index.shtml

发给孔

《卖炭翁》是白居易《新乐府》组诗中的第三十二首，自注云：“苦宫市也。”“宫市”的“宫”指皇宫，“市”是买的意思。皇宫所需的物品，本来由官吏采买。中唐时期，宦官专权，横行无忌，连这种采购权也抓了过去，常有数十百人分布在长安东西两市及热闹街坊，以低价强购货物，甚至不给分文，还勒索“进奉”的“门户钱”及“脚价钱”。名为“宫市”，实际是一种公开的掠夺（其详情见韩愈《顺宗实录》卷二、《旧唐书》卷一四○《张建封传》及《通鉴》卷二三五），其受害者当然不止一个卖炭翁。诗人以个别表现一般，通过卖炭翁的遭遇，深刻地揭露了“宫市”的本质，对统治者掠夺人民的罪行给予有力的鞭挞。 开头四句，写卖炭翁的炭来之不易。“伐薪、烧炭”，概括了复杂的工序和漫长的劳动过程。“满面尘灰烟火色，两鬓苍苍十指黑”，活画出卖炭翁的肖像，而劳动之艰辛，也得到了形象的表现。“南山中”点出劳动场所，这“南山”就是王维所写的“欲投人处宿，隔水问樵夫”的终南山，豺狼出没，荒无人烟。在这样的环境里披星戴月，凌霜冒雪，一斧一斧地“伐薪”，一窑一窑地“烧炭”，好容易烧出“千余斤”，每一斤都渗透着心血，也凝聚着希望。 写出卖炭翁的炭是自己艰苦劳动的成果，这就把他和贩卖木炭的商人区别了开来。但是，假如这位卖炭翁还有田地，凭自种自收就不至于挨饿受冻，只利用农闲时间烧炭卖炭，用以补贴家用的话，那么他的一车炭被掠夺，就还有别的活路。然而情况并非如此。诗人的高明之处在于没有自己出面向读者介绍卖炭翁的家庭经济状况，而是设为问答：“卖炭得钱何所营？身上衣裳口中食。”这一问一答，不仅化板为活，使文势跌宕，摇曳生姿，而且扩展了反映民间疾苦的深度与广度，使我们清楚地看到：这位劳动者已被剥削得贫无立锥，别无衣食来源：“身上衣裳口中食”，全指望他千辛万苦烧成的千余斤木炭能卖个好价钱。这就为后面写宫使掠夺木炭的罪行做好了有力的铺垫。 “可怜身上衣正单，心忧炭贱愿天寒。”这是脍炙人口的名句。“身上衣正单”，自然希望天暖。然而这位卖炭翁是把解决衣食问题的全部希望寄托在“卖炭得钱”上的，所以他“心忧炭贱愿天寒”，在冻得发抖的时候，一心盼望天气更冷。诗人如此深刻地理解卖炭翁的艰难处境和复杂的内心活动，只用十多个字就如此真切地表现了出来，又用“可怜”两字倾注了无限同情，怎能不催人泪下！ 这两句诗，从章法上看，是从前半篇向后半篇过渡的桥梁。“心忧炭贱愿天寒”，实际上是期待朔风凛冽，大雪纷飞。“夜来城外一尺雪”，这场大雪总算盼到了！也就不再“心忧炭贱”了！“天子脚下”的达官贵人、富商巨贾们为了取暖，难道还会在微不足道的炭价上斤斤计较吗？当卖炭翁“晓驾炭车辗冰辙”的时候，占据着他的全部心灵的，不是埋怨冰雪的道路多么难走，而是盘算着那“一车炭”能卖多少钱，换来多少衣和食。要是在小说家笔下，是可以用很多笔墨写卖炭翁一路上的心理活动的，而诗人却一句也没有写，这因为他在前面已经给读者开拓了驰骋想象的广阔天地。 卖炭翁好容易烧出一车炭、盼到一场雪，一路上满怀希望地盘算着卖炭得钱换衣食。然而结果呢？他却遇上了“手把文书口称敕”的“宫使”。在皇宫的使者面前，在皇帝的文书和敕令面前，跟着那“叱牛”声，卖炭翁在从“伐薪”、“烧炭”、“愿天寒”、“驾炭车”、“辗冰辙”，直到“泥中歇”的漫长过程中所盘算的一切、所希望的一切，全都化为泡影！ 从“南山中”到长安城，路那么遥远，又那么难行，当卖炭翁“市南门外泥中歇”的时候，已经是“牛困人饥”；如今又“回车叱牛牵向北”，把炭送进皇宫，当然牛更困、人更饥了。那么，当卖炭翁饿着肚子、�喝着困牛走回终南山的时候，又想些什么呢？他往后的日子，又怎样过法呢？这一切，诗人都没有写，然而读者却不能不想。当想到这一切的时候，就不能不同情卖炭翁的遭遇，不能不憎恨统治者的罪恶，而诗人“苦宫市”的创作意图，也就收到了预期的效果。 这首诗具有深刻的思想性，艺术上也很有特色。诗人以“卖炭得钱何所营，身上衣裳口中食”两句展现了几乎濒于生活绝境的老翁所能有的唯一希望，——又是多么可怜的希望！这是全诗的诗眼。其他一切描写，都集中于这个诗眼。在表现手法上，则灵活地运用了陪衬和反衬。以“两鬓苍苍”突出年迈，以“满面尘灰烟火色”突出“伐薪、烧炭”的艰辛，再以荒凉险恶的南山作陪衬，老翁的命运就更激起了人们的同情。而这一切，正反衬出老翁希望之火的炽烈：卖炭得钱，买衣买食。老翁“衣正单”，再以夜来的“一尺雪”和路上的“冰辙”作陪衬，使人更感到老翁的“可怜”。而这一切，正反衬了老翁希望之火的炽烈：天寒炭贵，可以多换些衣和食。接下去，“牛困人饥”和“翩翩两骑”，反衬出劳动者与统治者境遇的悬殊：“一车炭，千余斤”和“半匹红纱一丈绫”，反衬出“宫市”掠夺的残酷。而就全诗来说，前面表现希望之火的炽烈，正是为了反衬后面希望化为泡影的可悲可痛。

Ladies and Gentlemen, Good morning! I"m very glad to stand here and give you a short speech. Man"s life is a process of growing up, actually I"m standing here is a growth. If a person"s life must constituted by various choices, then I grow up along with these choices. Once I hope I can study in a college in future, however that"s passed, as you know I come here, now I wonder what the future holds for me. When I come to this school, I told to myself: this my near future, all starts here. Following I will learn to become a man, a integrated man, who has a fine body, can take on important task, has independent thought, an open mind, intensive thought, has the ability to judge right and wrong, has a perfect job. Once my teacher said :” you are not sewing, you are stylist; never forget which you should lay out to people is your thought, not craft.” I will put my personality with my interest and ability into my study, during these process I will combine learning with doing. If I can achieve this “future”, I think that I really grow up. And I deeply believe kindred, good-fellowship and love will perfection and happy in the future. How to say future? Maybe it"s a nice wish. Lets make up our minds, stick to it and surely well enjoy our life.

弈棋（精）（锐）