重写-override
java多态之Override
Override（重写）是子类与父类的一种多态性体现。
Override允许子类改变父类的一些行为。
为什么需要Override：当父类不满足子类的一些要求时我们就需要子类对父类的一些行为进行重写。
例如：某公司里的员工的电话号码不允许对外公开，而销售人员（员工）的电话号码则需要对外公开。
这时我们就可以这样做：
Java代码
1.public class Employee {
2.
3.private String mobile;
4.
5.public Employee(String mobile) {
6.this.mobile = mobile;
7. }
8.
9.protected String showMess(){
10.return"电话号码："+mobile;
11. }
12.}
员工类的showMess方法是protected的，所以位于其他包的对象是访问不到的。
然后定义一个销售人员的类（Sales）,并继承Employee类
Java代码
1.public class Sales extends Employee{
2.
3.//子类除了具有父类的一些属性，也可以有自己的一些属性
4.private String msn;
5.
6.public Sales(String mobile,String msn) {
7.super(mobile);
8.this.msn = msn;
9. }
10.
11.@Override
12.public String showMess() {
13.return super.showMess()+"==msn:"+this.msn;
14. }
15.}
注意这时被覆盖的showMess方法的访问级别是public，可以被任何其他对象访问到。
关于Override有几点要注意的地方：
1.被覆盖方法的访问控制级别可以不一样。
例如上例父类的showMess方法的访问级别为protected的，而子类覆盖的showMess方法访问级别则为public的。
但子类的访问级别必须要高于父类被覆盖方法的访问级别，如果父类是public的而子类是protected的则是错误的。
2.方法被定义为private或static或final的则不能被覆盖。
3.方法的返回类型：子类的返回类型可以是更具体的对象，例如可以将Employee类的返回类型改为Object也正确。而倒过来则错误。
4.在方法调用时先会在子类中找覆盖的方法，如果子类中没有则会在父类中去找。
Java代码
1.public class Parent {
2.
3.private int num(int i,int j){
4.return i+j;
5. }
6.
7.public static void main(String[] args) {
8. Parent p = new Child();
9. System.out.println(p.num(1, 2));
10. }
11.}
12.class Child extends Parent{
13.
14.public int num(int x,int y){
15.return x-y;
16. }
17.}
这段代码的执行结果为什么呢？如果你回答-1则错了，正确答案是3。
为什么呢？因为父类的num方法是private的，所以不能被覆盖，所以子类的num方法不是一种Override，因此在子类找不到被覆盖的num方法就会执行父类的num方法。所以结果输出为3.
Java代码
1.
2.
3.public int test(){
4.//执行子类的num方法
5.return num(1,2);
6. }
7.
8.protected int num(int i,int j){
9.return i+j;
10. }
11.
12.public static void main(String[] args) {
13. Parent p = new Child();
14. System.out.println(p.test());
15. }
16.
17.}
18.class Child extends Parent{
19.
20.public int num(int x,int y){
21.return x-y;
22. }
23.}
那么这段代码的执行结果是-1，因为父类test方法调用的是子类的num方法。
Java中关于==和equal的区别+以及equals()方法重写
Java中关于==和equal的区别以及equals()方法重写 例子i: string1="aaa"; string2="aaa"; String string3=new String("aaa"); String string4=new String("aaa"); string1==string2 // true; . string1.equals(string2);//true; string3==string4;//false 因为用new创建了2个对象,所以是两个不同的内存地址 string3.equals(string4);//true 而String类的是不可改变的,所以会指向同一个内存地址,所以返回为true equals()是object的方法,所以只是适合对象,不适合于基本类型,equals()默认是用"=="比较两个对象的内存地址,如果想要比较两个对象的内容,要重写equals()方法才可...而==可以比较两个基本类型,也可以是对象... String的equals()方法重写: public boolean equals(Object object){ if( this==anObject) {return true;} if(anObject instancdOf String) {String anotherString =(String)anObject; int n= count; if(n==anotherString.count) { char V1[]=value; char V2[]=anotherString.value; int i=offset; int j=anotherString.offset; while(n--!=0) { if (v1[i++]!=V2[j++] return false;} return true;} }
如果重写了对象的equals()方法,需要考虑什么
如果重写了对象的equals()方法，需要考 虑什么 1、用ibatis的原因 2、jdbc、hibernate、ibatis的区别 3、ibatis 的核心配置文件 4、ibatis的核心类 1、在myeclipse加入hibernate环境的全过程是什么? 2、hibernate的核心配置文件是什么及其作用? 3、hibernate的核心类是什么，它们的相互关系是什么?重要的方法是什么? 4、关联: 5、hibernate中的one-to-many或many-to-one中常用的方式是什么? 6、Criteria 的 1、JDBC如何做事务处理？ 2、写出几个在Jdbc中常用的接口 3、简述你对Statement,PreparedStatement,CallableStatement 的理解 4、Java中访问数据库的步骤？ 5、JDBC中的核心类及其作用是什么? 6、执行存储过程用那一个类，如何操作输出参数?(操作) 8、可能会让 1.列举出10个JAVA语言的优势 2.列举出JAVA中10个面向对象编程的术语 3.列举出JAVA中6个比较常用的包 4.JAVA中的标识符有什么作用和特点 5.JAVA中的关键字有什么特点,列举出至少20个关键字 6.JAVA中数据类型如何分类？ 7.JAVA中运算符的分类及举例 8.super,th 1、java中有几种类型的流？JDK为每种类型的流提供了一些抽
象类以供继承，请说出他们分别是哪些类？2、启动一个线程是用run()还是start()? 3、线程的基本概念、线程的基本状态以及状态之间的关系4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什 1. super()与this()的区别？ 2. 作用域public,protected,private,以及不写时的区别？ 3. 编程输出如下图形。 4. JAVA的事件委托机制和垃圾回收机制 5. 在JAVA中，如何跳出当前的多重嵌套循环？ 6. 什么是java序列化，如何实现java 序列化？(写一个实例) 7. 一
java重写与方法重载实例
package basetest; /** * * @author Administrator *案例分析：对于main最后一行代码有两个坑 *1.调用的是Test类的哪一个方法？ *这一步看重载 *2.对于传递的参数（son），方法体重调用的是谁的方法 *这一步看重写调用的是子类的方法 * * */ public class OverrideDemo { public static void main(String[] args) { Father father = new Son(); father.show();//运行期绑定：重写看对象（new的是谁调谁的方法） Test test = new Test(); test.test(father);//编译器绑定：重载看引用（等号前的类型是谁调谁的方法）} } class Test {
void test(Father father){ System.out.println("父型参数"); father.show(); } void test(Son son){ System.out.println("子型参数"); son.show(); } } class Father { protected void show(){ System.out.println("我是老子！"); } } class Son extends Father{ /** * Cannot reduce the visibility of the inherited method from Father 不能减少来自继承方法的可见性 子类访问权限要大于父类 */ /* void show(){ }*/ public void show(){ System.out.println("我是儿子!"); } public void show(String name){ System.out.println("我是儿子：名字是"+name); } }
转载C#中继承实现父类方法、重写、重载
【转】C#中继承实现父类方法、重写、重载 继承是派生类（）去实现（重写
方法重写(覆盖)
方法重写(overriding method) 基本概念 在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。 下面是一个简单的例子： 父类： public class MethodFather { v oid max(int a, int b) { System.out.println("父类：Using Int"); System.out.println(a < b ? a : b); } } 子类： public class MethodSon extends MethodFather{ @Override v oid max(int a, int b) { System.out.println("子类：Using Int"); System.out.println(a < b ? a : b); } } Main: public class Test_Override { p ublic static void main(String[] args) { //声明一个父类的引用指向子类的对象 MethodFather a = new MethodSon(); a.max(2, 8); //声明一个子类的引用指向子类的对象 MethodSon b = new MethodSon(); b.max(3, 9); // //声明一个子类的引用，指向一个被强制转换成子类类型的父类的对象 // MethodSon c = (MethodSon) new MethodFather();//编译时不报错，运行时错误 // c.max(4, 16); } }
类的继承与方法重写
基于.NET 4面向对象编程高级主题(一) 类的继承与方法重写 继承（Inheritance） Visual https://www.wendangku.net/doc/fa15535330.html, 支持“继承”，这是一种定义作为派生类（Derivation Class）基础的类的能力。派生类继承并可扩展基类的属性（Property）、方法（Method）和事件（Event）。派生类还可以用新的实现重写继承的方法。默认情况下，用Visual Basic .NET创建的所有类都是可继承的。 继承使您得以只编写和调试类一次，然后将该代码作为新类的基础不断重复使用。继承还使您得以使用基于继承的多态性（Polymorphism），这是一种定义如下类的能力：这些类可由客户端代码在运行时交换使用，但具有功能不同而名称相同的方法或属性。 通俗的说，继承就是子承父业，假设定义一个Father类作为基类（父类），然后定义一个子类（派生类）Son，在Son这个类中添加以下突出显示的代码：（Code 1） Public Class Son Inherits Father End Class 这时候，就会发现Son是从父类Father里面继承下来的，假设Father有Sport，EditProgram这两个方法，以及Tall这个属性，那么子类同样包含了父类所具备的Sport，EditProgram这两个方法，以及Tall 这个属性，但是这些方法和属性可以在子类中进行重写（Overridable） 我们在设计Windows应用程序（Application）窗体的时候，Visual Studio会自动创建一个空白的窗体，而这个窗体则是从Form类中继承下来的，如果打开名字为Form1的空白Windows窗体设计视图的Design
php方法重写：Declaration of should be compatible with that
如果你碰到php 方法重写，参数不同，报错：Declaration of should be compatible with that 这种问题不防进入参考一下解决办法吧。 上网搜索了一下，发现许多帖子基本都抄的一样，说什么这是由于php5.3版本后，要求继承类必须在父类之后定义，如果父类定义在前，继承类在后，就不会出现这个错误。尤其是上面还煞有介事的给出了正反例： 代码如下: <?php // this code does trigger a strict message error_reporting( E_ALL | E_STRICT ); class cc extends c { function test() { return null; } } class c { function test( $a ) { return 1; } } $cc = new cc(); ?> < ?php // this code does NOT trigger a strict message error_reporting( E_ALL | E_STRICT ); class c { function test( $a ) { return 1; } } class cc extends c { function test() { return null; } } $cc = new cc(); ?> 并且讨论了出错的情况多半是由于用_autoload()对类进行自动的include，导致基类的定义在后面，子类定义在前面。 我看了下自己的代码，虽然确实也用到了autoload，但是都是显式的先导入了几个基类，并不存在这样的情况，而且将上面的正反例子试了一下，都会出现E_STRICT的警告。 再看例子 代码如下: <?php abstract class A { // 方法无参数 public static function foo(){ echo 'bar'; } } abstract class B extends A { // 方法有参数 public static function foo($str){ echo $str; } } ?> 闪电似的 如上面的代码：类A中的foo方法无参数，类B在继承A后重写foo方法时加入了参数，因此会产生一个类似下面E_STRICT级别的警告： Strict standards: Declaration of ... should be compatible with that of 代码如下: <?php
覆盖与重写的区别
有时候，类的同一种功能有多种实现方式，到底采用那种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。public void train (Dog dog){ //训练小狗站立，排队，做算数 } public void train(Monkey monkey){ //训练猴子骑自行车等 } 再如某个类的一个功能是比较两个城市是否相同，一种方式是比较两个城市的名字，一种是除了比较两个城市的名字外，还要比较所在国家的名字。 publi boolean isSameCity (String city1,String city2){ return city1.equals(city2); } public boolean isSameCity(String city1,String city2,Stirng Country1,String Country2){ return isSameCity(city1,city2)&&Country1.equals(Country2); } 在例如 https://www.wendangku.net/doc/fa15535330.html,ng.Math 类的 max （）方法能够从两个数字中取出最大值，它有多种实现方式。 public static int max(int a,int b) public static int max(long a, long b) public static int max(float a,float b) 以下程序多次调用Math 类的max() 方法，运行时，Java 虚拟机先判断给定参数的类型，然后决定到底执行哪个 max()方法。 // 参数为 int 类型，因此执行max（int a, int b）方法 Math.max(1,2); //参数为 flloat 类型，因此执行 max(float a, float b) 方法 Math.max(1.0F,2.9F); 对于类的方法（包括从父类中继承的方法）如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。 重载方法满足以下条件 方法名相同 方法的参数类型，个数，顺序至少有一项不相同 方法的返回类型可以不相同 方法的修饰符可以不相同 在一个类中不允许定义另个方法名相同，并且参数签名也完全相同的方法。假如存在这样的两个方法，Java 虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型，个数和顺序。 例如：public class Sample { public void amethod(int i,String s){} } 下面哪个方法可以加入到 Sample 类中去？ public void amethod(String s,int i) //OK public int amethod(int i,String s){return 0} //NO
伪静态URL重写的方法
伪静态URL重写 伪静态URL重写实际就是以静态地址（如：http://127.0.0.1:8080/pro/index.html）访问地态网页的方法（如：http://127.0.0.1:8080/pro/index.jsp）。 伪静态URL重写是通过微软公司封装好了的一个URL重写组件（UrlReswriter.jar）来实现的，导入JAR包，在WEB服务中加载伪静态地址拦截器，客户端以静态地址向服务器发起请求，服务器端的拦截器拦截客户端请求，查找XML配置文件，把静态的URL地址转换成动态地址，发起请求。 下面是具体的实现步骤（这里以struts2框架为例）： 1、新建工程，导入struts2框架所需的JAR，导入UrlReswriter.jar 2、新建URL地址转换文件，文件名不定，只需在项目中的web.xml文件加载就行。如下： urlrewrite.xml
白盒测试中的六种覆盖方法
白盒测试中的六种覆盖方法 摘要：白盒测试作为测试人员常用的一种测试方法，越来越受到测试工程师的重视。白盒测试并不是简单的按照代码设计用例，而是需要根据不同的测试需求，结合不同的测试对象，使用适合的方法进行测试。因为对于不同复杂度的代码逻辑，可以衍生出许多种执行路径，只有适当的测试方法，才能帮助我们从代码的迷雾森林中找到正确的方向。本文介绍六种白盒子测试方法：语句覆盖、判定覆盖、条件覆盖、判定条件覆盖、条件组合覆盖、路径覆盖。 白盒测试的概述 由于逻辑错误和不正确假设与一条程序路径被运行的可能性成反比。由于我们经常相信某逻辑路径不可能被执行, 而事实上,它可能在正常的情况下被执行。由于代码中的笔误是随机且无法杜绝的，因此我们要进行白盒测试。 白盒测试又称结构测试,透明盒测试、逻辑驱动测试或基于代码的测试。白盒测试是一种测试用例设计方法，盒子指的是被测试的软件，白盒指的是盒子是可视的,你清楚盒子内部的东西以及里面是如何运作的。 白盒的测试用例需要做到： ·保证一个模块中的所有独立路径至少被使用一次 ·对所有逻辑值均需测试 true 和 false ·在上下边界及可操作范围内运行所有循环 ·检查内部数据结构以确保其有效性 白盒测试的目的：通过检查软件内部的逻辑结构，对软件中的逻辑路径进行覆盖测试；在程序不同地方设立检查点，检查程序的状态，以确定实际运行状态与预期状态是否一致。 白盒测试的特点：依据软件设计说明书进行测试、对程序内部细节的严密检验、针对特定条件设计测试用例、对软件的逻辑路径进行覆盖测试。 白盒测试的实施步骤： 1.测试计划阶段：根据需求说明书，制定测试进度。 2.测试设计阶段：依据程序设计说明书，按照一定规范化的方法进行软件结构划分和设计测试用例。 3.测试执行阶段：输入测试用例，得到测试结果。 4.测试总结阶段：对比测试的结果和代码的预期结果，分析错误原因，找到并解决错误。 白盒测试的方法：总体上分为静态方法和动态方法两大类。
小学生作文修改的方法
小学生作文修改的几种常用方法 我国自古以来就有“文不厌改”之说。何其芳同志曾说：“修改是写作的一个重要部分。”传统的批改模式是“学生作，教师改”。教师为改好一篇作文可谓是花尽心思，而学生却收益甚少，教师也被拖得精疲力竭，且效率低下。很显然，这种传统的“精批细改”方式已经不能适应全面提高学生素质的要求，那么，如何进行作文修改呢？下面作者将结合自己多年的教学经验浅谈几点小学生作文修改 的方法： 一、传授方法，让学生自改 叶老先生提醒我们：“文章要自己改，学生学会了自改的本领，才能把文章写好。”《语文新课程标准》中强调学生要“养成修改自己作文的习惯”。在学生完成作文训练后，无论是大作或是小作，都要训练学生对自己的作文进行修改。那么如何指导学生进行自改呢？ 教师先做示范，学生学会自改方法。学习自改文章，千万不要操之过急，要循序渐进，才能收到一定的效果。学生要在教师的耐心引导下，按一定的步骤，学会掌握常见的批改方法，只有这样学生才不会掉进一个“不知道改些什么，应怎样改”的摸不着头脑的迷阵中。 二、同学间互改，取长补短
学会互改作文，取长补短，促进相互了解和合作，这也是提高写作水平的方法之一。学习互改作文前，必须构建相应的学生批改作文小组。可以按座位划分小组或同桌结对等，4人左右为一组，并选出作文水平较高的同学担任组长。 实施互改时，要求学生努力在批改的文章中找“金子”，找出写得好的地方在哪里，为什么好，怎样评点这些好地方，同时也要找出存在问题的地方，共同讨论怎样修改才算最好。最后还可以在小组内予以相应的评价。互改结束后，由每组的组长汇报组里批改的情况（重点汇报其中一篇文章的批改情况），汇报后可让全班同学展开讨论，教师作点评，通过安排多次的训练，让学生逐步掌握互改作文的方法。同时在互改中互学共勉，共同提高。 三、边改边记，切磋收获 批改或复阅本组其他学生的作文时，要求学生要边批边记，即把几本作文的优缺点找出来，以便与自己的作文比较。通过看、记，把妙语佳句、新颖的开头结尾、好的写作方法记下，为以后写此类作文取人之长，补己之短。 四、常写后记，畅谈体会 学生轮流批阅后，再发给作者，作者仔细看批改后的作文，要既看原文，又要看批语，改正错字，病句，甚至重写。然后对照笔录，写出别人作文的优点，写出此次作文的感受或受到的启示，以及对自己作文的修改意见。这样，使自己的作文每次都有一个升华过 程。
java 子类重写父类的方法
java 子类重写父类的方法 若想实现一个合格重写方法，而不是重载，那么必须同时满足下面的要求！ A、重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。（但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。） 比如：Object类有个toString()方法，开始重写这个方法的时候我们总容易忘记public修饰符，编译器当然不会放过任何教训我们的机会。出错的原因就是：没有加任何访问修饰符的方法具有包访问权限，包访问权限比public当然要严格了，所以编译器会报错的。 B、重写规则之二：参数列表必须与被重写方法的相同。 重写有个孪生的弟弟叫重载，也就是后面要出场的。如果子类方法的参数与父类对应的方法不同，那么就是你认错人了，那是重载，不是重写。 C、重写规则之三：返回类型必须与被重写方法的返回类型相同。 父类方法A：void eat(){} 子类方法B：int eat(){} 两者虽然参数相同，可是返回类型不同，所以不是重写。 父类方法A：int eat(){} 子类方法B：long eat(){} 返回类型虽然兼容父类，但是不同就是不同，所以不是重写。 D、重写规则之四：重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。 import java.io.*; public class Test { public static void main (String[] args) { Animal h = new Horse();
try { h.eat(); } catch (Exception e) { } } } class Animal { public void eat() throws Exception{ System.out.println ("Animal is eating."); throw new Exception(); } } class Horse extends Animal{ public void eat() throws IOException{ System.out.println ("Horse is eating."); throw new IOException(); } } 这个例子中，父类抛出了检查异常Exception，子类抛出的IOException是Exception 的子类，也即是比被重写的方法抛出了更有限的异常，这是可以的。如果反过来，父类抛出IOException，子类抛出更为宽泛的Exception，那么不会通过编译的。 注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类不再这个限制之中。 E、重写规则之五：不能重写被标识为final的方法。
java中方法的覆盖
java中方法的覆盖 (2011-01-16 23:01:54)转载▼ 标签：杂 谈 java中子类继承父类，子类可以重写父类中的方法，这是java多态的表现。java中的方法分静态方法和实例方法，非静态方法可以被覆盖，而静态方法则不可以。看下面的代码：public class Parent { static void Test(){ System.out.println("parent methord"); } } public class Child extends Parent{ static void Test(){ System.out.println("child metho"); } } class Text { public static void main(String[] args) { Child child = new Child(); child.Test(); Parent parent = new Child(); parent.Test(); } } 首先来说这段代码是有问题的，如果你在eclips里编写这段代码，会有警告提示说The static method Test() from the type Parent should be accessed in a static way。大概意思是说应该用静态的方式调用Test（）方法，即Parent.Test(); 输出为child metho parent methord 如果将父类中的static去掉会有什么结果呢，在子类中elcips会提示错误This static method cannot hide the instance method from Parent。 如果只将子类中的static去掉呢，在子类中elcips会提示错误This instance method cannot override the static method from Parent。 我们再来看看java中覆盖的定义。覆盖是指派生类中存在重新定义的函数，其函数名，参数列，返回值类型必须与父类中的相对应的被覆盖函数保持严格的一致，覆盖函数和被覆盖函数只有函数体不同。当派生类对象调用子类中该同名函数时，会自动调用子类中的覆盖版本，而不是父类中被覆盖的版本，这种机制称为覆盖。也就是说，覆盖的意义是调用子类中的覆盖函数，而不是父类中的被覆盖函数。
- 多次覆盖方法
- Java中方法的重载和重写
- URL重写的三种方法
- C#中继承实现父类方法、重写、重载
- php方法重写：Declaration of should be compatible with that
- C#中子类重写父类方法的几种情况(virtual,abstract,override,new)
- 白盒测试中的六种覆盖方法
- 如果重写了对象的equals()方法,需要考虑什么
- 方法重写(覆盖)
- 重载和重写的区别
- 方法覆盖和方法重载(已阅)
- Java中子类重写父类方法
- 方法覆盖
- C#虚方法和重写
- 白盒测试中的六种覆盖方法
- 第四章 多次覆盖方法讲解
- 第四章 多次覆盖方法
- 覆盖方法
- 覆盖与重写的区别
- 方法重载和方法重写