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

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

这就是范型。。就是说你这个集合就是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

Another summer day Has come and gone away In Paris or Rome... But I wanna go home ...uhm Home 那一个巴黎和罗马的夏天，来了又去。而我只想回家，哦……我的家。 May be surrounded by A million people I Still feel all alone Just wanna go home Oh I miss you, you know 也许有许多人会陪伴着我，但我还是觉得孤独。因为我只想回到我的家。你知道吗，我好想念你。 And I"ve been keeping all the letters That I wrote to you Each one a line or two I"m fine baby, how are you I would s them but I know that It"s just not enough My words were cold and flat And you deserve more than that 所有写给你的信我都留着，留着每封信的那一句又一句：“亲爱的我很好，你呢？”我要把这些甜言蜜语都送给你，但我知道这远远不够。我的语言是多么的冰冷而无力。而你，却应该得到比这更多的关怀。 Another aeroplane another sunny place I"m lucky I know But I wanna go home I got to go home Let me go home 又一架飞机起飞了，朝着那幸福的方向。我知道我是幸运的，但我还是要回家，回到我的家。 I"m just too far from where you are I wanna come home 我要回家。我虽然离你很遥远，但我知道你会理解这一切。 And I feel just like I"m living Someone else"s life It"s like I just stepped outside When everything was going right And I know just why You could not come along with me This was not your dream But you always believed in me... 我觉得我生活在另外一个人的世界里，就像我过上了另一种生活。当所有都如愿以偿，我也懂得了为什么。你没有陪伴在我身边，也许这并不是你的心愿，但是你总是很相信我…… Another winter day Has come and gone away In either Paris or Rome And I wanna go home Let me go home 那一个巴黎和罗马的冬天，来了又去。而我只想回家，回家…… And I"m surrounded by A million people I I still feel alone Let me go home I miss you , you know 尽管我周围有很多人相伴，但我仍然觉得孤独。因为我想回家，你知道的

stay

分类: 文化/艺术 >> 文学 >> 小说 解析: 卖炭翁 卖炭翁，伐薪烧炭南山中。满面尘灰烟火色，两鬓苍苍十指黑。卖炭得钱何所营？身上衣裳口中食。可怜身上衣正单，心忧炭贱愿天寒。 夜来城外一尺雪，晓驾炭车辗冰辙。牛困人饥日已高，市南门外泥中歇。翩翩两验来是谁？黄衣使者白衫儿。手把文书口称敕，回车叱牛牵向北。 一车炭重千余斤，宫使驱将惜不得。半匹红纱一丈绫，系向牛头充炭直。 简析： 白居易《新乐府》组诗一共五十首。这一组诗，绝大部分是唐宪宗元和四年（809）他担任左拾遗时作的。《卖炭翁》是这组诗当中的一首。它通过一个卖炭翁的不幸遭遇，揭露唐代“宫市”的罪恶，反映劳动人民的痛苦。所谓“宫市”，就是官吏强买人民的货物。 《卖炭翁》是通过卖炭翁这一人物形象来揭露社会现实的。它和《轻肥》、《买花》两诗以一批权责为描写题材的稍有不同。作者对这老翁的刻画，先写他的外貌，次写他的思想活动，再次就写他赶车的行动及其不幸的遭遇。不管是对外貌的描写，心理的刻画，或是环境的渲染，都颇见功夫。比如，“满面”二句，仅仅十四个字就把卖炭老翁的外貌特征勾画出来了，既体现了烧炭劳动的特点，又体现了人物的年龄、体质。“夜来”二句，写出了北方天寒地冻的景象，也体现了冰天雪地的赶车之苦。特别是对心理矛盾的刻画，更有其独到之处，“可怜身上衣正单，心忧炭贱愿天寒”，这种不愿而又不能不愿的心理矛盾有力地反衬出卖炭翁生活的极端困苦。借助于这一矛盾来揭露封建社会生活本质，既深刻，又显得新鲜动人，不落旧套。至于诗的结尾，也有别于其他诗篇，作者没有在诗末发议论，而是在叙述事实中结束，让事实本身来说话，这就显得更含蓄，更发人深思。

卖炭翁白居易《卖炭翁》的全诗是：卖炭翁，伐薪烧炭南山中。满面尘灰烟火色，两鬓苍苍十指黑。卖炭得钱何所营？身上衣裳口中食。可怜身上衣正单，心忧炭贱愿天寒。夜来城外一尺雪，晓驾炭车辗冰辙。牛困人饥日已高，市南门外泥中歇。翩翩两骑来是谁？黄衣使者白衫儿。手把文书口称敕，回车叱牛牵向北。一车炭，千余斤，宫使驱将惜不得。半匹红纱一丈绫，系向牛头充炭直。译文：有位卖炭的老翁，整年在南山里砍柴烧炭。他满脸灰尘，显出被烟熏火燎的颜色，两鬓头发灰白，十个手指也被炭烧得很黑。卖炭得到的钱用来干什么？买身上穿的衣裳和嘴里吃的食物。可怜他身上只穿着单薄的衣服，心里却担心炭卖不出去，还希望天更寒冷。夜里城外下了一尺厚的大雪，清晨，老翁驾着炭车碾轧冰冻的车轮印往集市上赶去。牛累了，人饿了，但太阳已经升得很高了，他们就在集市南门外泥泞中歇息。那得意忘形的骑着两匹马的人是谁啊？是皇宫内的太监和太监的手下。太监手里拿着文书，嘴里却说是皇帝的命令，吆喝着牛朝皇宫拉去。一车的炭，一千多斤，太监差役们硬是要赶着走，老翁是百般不舍，但又无可奈何。那些人把半匹红纱和一丈绫，朝牛头上一挂，就充当炭的价钱了。作者：唐·白居易诗歌赏析此诗为唐代白居易《新乐府》第三十二首。作者在自序中说：“苦宫市也”。“宫市”是唐代最高统治者掠夺百姓财物的一种制度。原来，由官吏主管购买东西；贞元末年，由宦官专管此事。他们派几百“白望”去市场，看见卖的东西就以“宫市”名义拿走，只付很少代价；同时还要索取“门户”和“脚价”钱，致使有些卖主空手而回。本诗就控诉了“宫市”之苦。诗中写一个老头，为了生活在南山砍柴烧炭。他虽然衣服单薄，但为了炭多卖点钱还是希望天寒。终于盼来了“夜来城外一尺雪”，于是一早就赶上牛车把炭拉到市场。然而这时来了宦官派的“使者”，强令他把炭送进宫去，一千多斤炭才换了“半匹红纱一丈绫”。作品通过这一典型事例，揭露和批判了当时不合理的“宫市”制度。《卖炭翁》古诗带拼音卖炭翁拼音版正版如下：卖炭翁，màitànwēng，伐薪烧炭南山中。fáxīnshāotànnánshānzhōng。满面尘灰烟火色，mǎnmiànchénhuīyānhuǒsè，两鬓苍苍十指黑。liǎngbìncāngcāngshízhǐhēi。卖炭得钱何所营？màitàndéqiánhésuǒyíng？身上衣裳口中食。shēnshàngyīshangkǒuzhōngshí可怜身上衣正单，kěliánshēnshàngyīzhèngdān，心忧炭贱愿天寒。xīnyōutànjiànyuàntiānhán。夜来城外一尺雪，yèláichéngwàiyìchǐxuě，晓驾炭车辗冰辙。xiǎojiàtànchēniǎnbīngzhé。牛困人饥日已高，niúkùnrénjīrìyǐgāo，市南门外泥中歇。shìnánménwàinízhōngxiē。翩翩两骑来是谁？piānpiānliǎngjìláishìshuí？黄衣使者白衫儿。huángyīshǐzhěbáishānér。手把文书口称敕，shǒubǎwénshūkǒuchēngchì，回车叱牛牵向北。huíchēchìniúqiānxiàngběi。一车炭，千余斤，yìchētàn，qiānyújīn，宫使驱将惜不得。gōngshǐqūjiāngxībúdé。半匹红绡一丈绫，bànpǐhóngxiāoyízhànglíng，系向牛头充炭直。jìxiàngniútóuchōngtànzhí。卖炭翁白居易拼音版卖炭翁拼音版正版如下：卖炭翁，màitànwēng，伐薪烧炭南山中。fáxīnshāotànnánshānzhōng。满面尘灰烟火色，mǎnmiànchénhuīyānhuǒsè，两鬓苍苍十指黑。liǎngbìncāngcāngshízhǐhēi。卖炭得钱何所营？màitàndéqiánhésuǒyíng？身上衣裳口中食。shēnshàngyīshangkǒuzhōngshí可怜身上衣正单，kěliánshēnshàngyīzhèngdān，心忧炭贱愿天寒。xīnyōutànjiànyuàntiānhán。夜来城外一尺雪，yèláichéngwàiyìchǐxuě，晓驾炭车辗冰辙。xiǎojiàtànchēniǎnbīngzhé。牛困人饥日已高，niúkùnrénjīrìyǐgāo，市南门外泥中歇。shìnánménwàinízhōngxiē。翩翩两骑来是谁？piānpiānliǎngjìláishìshuí？黄衣使者白衫儿。huángyīshǐzhěbáishānér。手把文书口称敕，shǒubǎwénshūkǒuchēngchì，回车叱牛牵向北。huíchēchìniúqiānxiàngběi。一车炭，千余斤，yìchētàn，qiānyújīn，宫使驱将惜不得。gōngshǐqūjiāngxībúdé。半匹红绡一丈绫，bànpǐhóngxiāoyízhànglíng，系向牛头充炭直。jìxiàngniútóuchōngtànzhí。卖炭翁原文全文全文：卖炭翁，伐薪烧炭南山中。满面尘灰烟火色，两鬓苍苍十指黑。卖炭得钱何所营？身上衣裳口中食。可怜身上衣正单，心忧炭贱愿天寒。夜来城外一尺雪，晓驾炭车辗冰辙。牛困人饥日已高，市南门外泥中歇。翩翩两骑来是谁？黄衣使者白衫儿。手把文书口称敕，回车叱牛牵向北。一车炭，千余斤，宫使驱将惜不得。半匹红绡一丈绫，系向牛头充炭直。译文：有位卖炭的老翁，整年在南山里砍柴烧炭。他满脸灰尘，显出被烟熏火燎的颜色，两鬓头发灰白，十个手指也被炭烧得很黑。卖炭得到的钱用来干什么？买身上穿的衣裳和嘴里吃的食物。可怜他身上只穿着单薄的衣服，心里却担心炭卖不出去，还希望天更寒冷。夜里城外下了一尺厚的大雪，清晨，老翁驾着炭车碾轧冰冻的车轮印往集市上赶去。牛累了，人饿了，但太阳已经升得很高了，他们就在集市南门外泥泞中歇息。那得意忘形的骑着两匹马的人是谁啊？是皇宫内的太监和太监的手下。太监手里拿着文书，嘴里却说是皇帝的命令，吆喝着牛朝皇宫拉去。一车的炭，一千多斤，太监差役们硬是要赶着走，老翁是百般不舍，但又无可奈何。那些人把半匹红纱和一丈绫，朝牛头上一挂，就充当炭的价钱了。《卖炭翁》是唐代诗人白居易创作的。扩展资料此诗以个别事例来表现普遍状况，描写了一个烧木炭的老人谋生的困苦，通过卖炭翁的遭遇，深刻地揭露了“宫市”的腐败本质，对统治者掠夺人民的罪行给予了有力的鞭挞与抨击，讽刺了当时腐败的社会现实。表达了作者对下层劳动人民的深切同情，有很强的社会典型意义。全诗描写具体生动，历历如绘，结尾戛然而止，含蓄有力，在事物细节的选择上和人物心理的刻画上有独到之处。这首诗具有深刻的思想性，艺术上也很有特色。诗人以“卖炭得钱何所营，身上衣裳口中食”两句展现了几乎濒于生活绝境的老翁所能有的唯一希望。这是全诗的诗眼。其他一切描写，都集中于这个诗眼。在表现手法上，则灵活地运用了陪衬和反衬。以“两鬓苍苍”突出年迈，以“满面尘灰烟火色”突出“伐薪、烧炭”的艰辛，再以荒凉险恶的南山作陪衬，老翁的命运就更激起了人们的同情。而这一切，正反衬出老翁希望之火的炽烈：卖炭得钱，买衣买食。老翁“衣正单”，再以夜来的“一尺雪”和路上的“冰辙”作陪衬，使人更感到老翁的“可怜”。而这一切，正反衬了老翁希望之火的炽烈：天寒炭贵，可以多换些衣和食。接下去，“牛困人饥”和“翩翩两骑”，反衬出劳动者与统治者境遇的悬殊；“一车炭，千余斤”和“半匹红纱一丈绫”，反衬出“宫市”掠夺的残酷。而就全诗来说，前面表现希望之火的炽烈，正是为了反衬后面希望化为泡影的可悲可痛。参考资料来源：百度百科-卖炭翁

终于做了这个决定zhong yu zuo le zhe ge jue ding 别人怎么说我不理bie ren zen me shuo wo bu li只要你也一样的肯定zhi yao ni ye yi yang de ken ding我愿意天涯海角都随你去wo yuan yi tian ya hai jiao dou sui ni qu我知道一切不容易wo zhi dao yi qie bu rong yi我的心一直温习说服自己wo de xin yi zhi wen xi shui fu zi ji最怕你忽然说要放弃zui pa ni hu ran shuo yao fang qi爱真的需要勇气ai zhen de xu yao yong qi来面对流言蜚语lai mian dui liu yan fei yu只要你一个眼神肯定zhi yao ni yi ge yan shen ken ding 我的爱就有意义wo de ai jiu you yi yi我们都需要勇气wo men dou xu yao yong qi去相信会在一起qu xiang xin hui zai yi qi 人潮拥挤我能感觉你ren chao yong ji wo neng gan jue ni放在我手心你的真心fang zai wo shou xin ni de zhen xin如果我的坚强任性ru guo wo de jian qiang ren xing会不小心伤害了你hui bu xiao xin shang hai le ni 你能不能温柔提醒ni neng bu neng wen rou ti xing我虽然心太急更害怕错过你wo sui ran xin tai ji geng hai pa cuo guo ni

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