老九Java基础课关于子类重写的总结

Java重写和重载的知识点

Java重写和重载的知识点在学习广州中软卓越Java培训课程中，我们会遇到一些关于java重载与重写的问题：Java 中重载与重写有何重要性？什么是重载与重写？今天，我们简要讲解一下关于java重载与重写的知识点。

首先，先来了解一下java的重载与重写是什么？只有了解了定义，知道是做什么的，才能清楚怎么运用。

1、重载（Overloading）方法重载：是让类以统一的方式去处理不同类型数据的一种手段。

多个同名函数同时存在，具有不同的参数个数（类型）。

重载是一个类中多态性的一种表现。

Java的方法重载就是，在类中可以创建多个方法，这些方法拥有相同的名字，但参数和意义不同。

调用方法时，通过传递给这些方法的不同参数个数和参数类型来决定具体使用哪种方法，这就是我们所说的多态性。

重载的时候，方法名需一致，但是参数类型和个数不一样，返回值类型可同可不同。

无法以返回型别作为重载函数的区分标准。

重载方法的规则有哪些？①一定且必须具有不同的参数列表；②允许有不同的返回类型，前提是参数列表必须不同；③允许有不同的访问修饰符；④允许抛出不同的异常。

2、重写（Overrrid）父类方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包，则不能重写。

而父类的方法被protoected时，不仅是在同一包中，被其子类被重写，还可以不同包的子类重写。

重写方法的规则有哪些？①参数列表一定且必须完全与被重写的方法一致，否则不能称其为重写，只能称为重载；②返回的类型也是一定且必须与被重写的方法的返回类型相同，否则不能称其为重写，只能称为重载；③访问修饰符的限制必须大于被重写方法的访问修饰符（pulic > protoected > default >private）；④重写方法一定不可以抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。

比如：父类的一个方法申明了一个检查异常IOException，在重写这个方法时，不能抛出Exception，只能抛出IOException的子类异常，抛出非检查异常。

Java中子类重写父类方法

}
有一个子类Programmer（程序员）,其中继承Meeting（开会），重写Working（工作）
public class Programmer extends Employee {
public void Working() {
System.out.println("我在努力敲代码........"); } }
此时我们可以看到，父类虽然提供了两个方法，但是子类只继承了一个，另外一个被重写。在main方法中实例化Programmer和SaleMan,调用Working方法，将执行子类重写之后的代码。
Programmer p = new Programmer(); p.Meeting(); //打印"我在努力开会........" p.Working(); //打印"我在努力敲代码........"
方法重写
方法重写：父类提供了方法给子类继承，子类不愿意继承，子类选择在自己这里把父类方法重新写一遍。子类重写父类方法，要求方法的定义完全一致（返回值，方法名，参数），具体实现不一样。
案例:重写的基本应用：有一个父类Employee（员工类）,其中两个方法：Meeting（开会），Working（工作）
案例：ﬁnal定义的方法不能被重写：
public class Employee { public void Meeting() { System.out.println("我在努力开会........"); } public final void Working() //此处使用final关键字，表示此方法不能被重写。 { System.out.println("我在努力工作........"); }

java的继承类,重写方法

java的继承类,重写方法Java中的继承是一种重要的面向对象编程概念，它允许我们创建一个新的类，这个类继承了另一个已经存在的类的属性和方法。

在继承类中，我们可以对父类的方法进行重写，即在子类中重新定义父类的方法实现。

这种重写方法的操作是面向对象编程中的一种常见操作，下面我们将详细介绍继承类中重写方法的相关知识。

一、继承的基本概念继承是一种面向对象编程中的重要概念，它允许我们创建一个新的类，并且可以继承一个已经存在的类的属性和方法。

在Java中，使用关键字extends来实现继承。

一个子类可以继承一个父类的属性和方法，从而可以重用父类的代码，并且可以在子类中添加新的属性和方法。

二、重写方法的概念在继承类中，我们可以对父类的方法进行重写，即在子类中重新定义父类的方法实现。

重写方法是面向对象编程中的一种常见操作，它允许子类根据自己的需要重新定义父类的方法，从而实现特定的功能或行为。

三、重写方法的语法重写方法的语法如下所示：```java@Override修饰符返回类型方法名(参数列表) {// 实现代码}```其中，@Override是一个注解，用于标识下面的方法是对父类方法的重写。

修饰符可以是public、protected或者默认修饰符，返回类型和参数列表必须与父类方法一致。

四、重写方法的注意事项在进行方法重写时，需要注意以下几点：1. 重写的方法必须与父类方法具有相同的名称、返回类型和参数列表；2. 重写的方法的访问修饰符不能比父类方法的访问修饰符更严格，即如果父类方法是public，则子类方法可以是public或者protected，但不能是private；3. 重写的方法不能抛出比父类方法更宽泛的异常，即子类方法抛出的异常类型不能是父类方法抛出异常类型的父类。

五、重写方法的示例下面我们通过一个示例来演示继承类中重写方法的过程。

假设我们有一个父类Animal，它有一个名为eat的方法，用于表示动物进食的行为。

Java基础之方法重写详解

Java基础之⽅法重写详解⼀、java⽅法重写⽅法的重写是⼦类根据需求对⽗类继承的⽅法进⾏重新的编写，在重写时，可以使⽤super⽅法的⽅式来保留⽗类中的⽅法，注意:构造⽅法不可以被重写。

创建⼀个⼈类，属性包括姓名性别年龄⾏为⽅法是输出信息⼆、super关键字⽅法重写时要在⼦类中定义⼀个和⽗类相同名称的⽅法，并采⽤super关键字super.⽅法名();,这样就实现了⽅法的重写package cn.zhz.Kind.dh;public class Person1 {public String sex;public String name;public int age;public void showInfo() {System.out.println("姓名:" + name + "年龄:" + age + "性别:" + sex);}}创建⼀个学⽣类，属性包括学号学科，⾏为⽅法是输出信息package cn.zhz.Kind.dh;public class Student1 extends Person1{public int stuId;public String stuSubject;public void showInfo(){super.showInfo();System.out.println("学号:"+ stuId+ "学科:"+ stuSubject);}}创建学⽣类的⼀个实例，进⾏赋值操作，赋值后输出package cn.zhz.Case.dh;import cn.zhz.Kind.dh.Student1;public class Student1Test {public static void main(String[] args) {Student1 student1 = new Student1();student1.stuId = 1; = "张三";student1.age = 18;student1.sex = "男";student1.stuSubject = "物理";student1.showInfo();}}2.1 super关键字的介绍super可以应⽤在⼦类访问⽗类成员中，⽐如说:访问⽗类的属性super.print();注意是⾮private的⽅法访问⽗类的⽅法;访问⽗类的构造⽅法super();package cn.zhz.Inherit.dh;public class Pet {private String name = "⽆名⽒";private int health = 100;private int love = 0;public int age = 1;public Pet() {System.out.println("⽗类⽆参构造⽅法");}public Pet(String name) { = name;}public Pet(String name, int health, int love) {//this可以调⽤本类的构造⽅法，且在第⼀⾏//this(name); = name;this.health = health;this.love = love;System.out.println("⽗类带参构造⽅法");}public void setAge(int age) {this.age = age;}public int getAge() {return age;}public void setHealth(int health) {if (health < 0 || health > 100) {System.out.println("宠物的健康值在0-100之间");this.health = 60;return;}this.health = health;}public int getHealth() {return this.health;}public void setName(String name) { = name;}public String getName() {return ;}public void setLove(int love) {if (love < 0 || love > 100) {System.out.println("宠物的亲密度只能在0-100之间");this.love = 60;return;}this.love = love;}public int getLove() {return this.love;}//输出宠物的信息public void print() {System.out.println("宠物的⾃⽩:\n我的名字叫" + + "健康值是" + this.health + "和主⼈的亲密度是:" + this.love); }}package cn.zhz.Inherit.dh;public class Dog extends Pet {private String strain = "聪明的拉布拉多⽝";public Dog() {System.out.println("⼦类狗狗的⽆参构造⽅法");}public Dog(String name, int health, int love, String strain) {//通过super调⽤⽗类的构造⽅法，必须是第⼀句//super();super(name, health, love);this.strain = strain;System.out.println("狗狗的带参构造⽅法");}public void setStrain(String strain) {this.strain = strain;}public String getStrain() {return this.strain;}public void print() {//调⽤⽗类的⾮private的print()⽅法super.print();System.out.println("我是⼀只" + this.strain);}public void m1() {//super不可以调⽤⽗类的private属性// System.out.println();System.out.println(super.age);}}在使⽤super关键字来访问⽗类的成员时，使⽤super关键字，super代表的是⽗类的对象，super只可以出现在⼦类的⽅法和构造⽅法中，使⽤super调⽤构造⽅法时，只可以是第⼀句，super不可以访问⽗类的private成员。

Java重写时应当遵守的11条规则

Java重写时应当遵守的11条规则CSDN 的⼩伙伴们，⼤家好，我是沉默王⼆。

重写（Overriding）算是 Java 中⼀个⾮常重要的概念，理解重写到底是什么对每个 Java 程序员来说都⾄关重要，这篇⽂章就来给⼤家说说重写过程中应当遵守的 12 条规则。

01、什么是重写？重写带来了⼀种⾮常重要的能⼒，可以让⼦类重新实现从超类那继承过来的⽅法。

在下⾯这幅图中，Animal 是⽗类，Dog 是⼦类，Dog 重新实现了move()⽅法⽤来和⽗类进⾏区分，毕竟狗狗跑起来还是⽐较有特⾊的。

重写的⽅法和被重写的⽅法，不仅⽅法名相同，参数也相同，只不过，⽅法体有所不同。

02、哪些⽅法可以被重写？规则⼀：只能重写继承过来的⽅法。

因为重写是在⼦类重新实现从⽗类继承过来的⽅法时发⽣的，所以只能重写继承过来的⽅法，这很好理解。

这就意味着，只能重写那些被 public、protected 或者 default 修饰的⽅法，private 修饰的⽅法⽆法被重写。

Animal 类有move()、eat()和sleep()三个⽅法：public class Animal {public void move() { }protected void eat() { }void sleep(){ }}Dog 类来重写这三个⽅法：public class Dog extends Animal {public void move() { }protected void eat() { }void sleep(){ }}OK，完全没有问题。

但如果⽗类中的⽅法是 private 的，就⾏不通了。

public class Animal {private void move() { }}此时，Dog 类中的move()⽅法就不再是⼀个重写⽅法了，因为⽗类的move()⽅法是 private 的，对⼦类并不可见。

public class Dog extends Animal {public void move() { }}03、哪些⽅法不能被重写？规则⼆：final、static 的⽅法不能被重写。

java中子类重写父类的方法

Java中子类重写父类的方法在Java中，子类可以重写（override）父类的方法。

方法重写是面向对象编程的一个重要概念，它允许子类根据自己的需要重新实现继承自父类的方法。

本文将详细介绍Java中子类重写父类方法的概念、语法和使用场景。

1. 方法重写的概念方法重写是指子类定义一个与父类具有相同名称、参数列表和返回类型的方法，并且在子类中提供新的实现逻辑。

通过方法重写，子类可以覆盖掉从父类继承而来的方法实现，以满足自己特有的需求。

方法重写是实现多态性（polymorphism）的一种方式。

多态性指同一个方法可以在不同的对象上产生不同的行为。

通过方法重写，我们可以在父类引用指向子类对象时，根据实际对象类型调用相应的方法。

2. 方法重写的语法在Java中，要实现方法重写，需要遵循以下语法规则：访问修饰符返回类型方法名(参数列表) throws异常 {// 子类自定义的逻辑}•访问修饰符：与父类中被重写方法的访问修饰符相同或更宽松。

常用的访问修饰符有public、protected和默认（package-private）。

•返回类型：与父类中被重写方法的返回类型相同或是其子类。

•方法名：与父类中被重写方法的方法名相同。

•参数列表：与父类中被重写方法的参数列表相同。

•throws 异常：与父类中被重写方法声明的异常列表相同或是其子集，如果子类抛出了比父类更大范围的异常，编译时会报错。

3. 方法重写的注意事项在进行方法重写时，需要注意以下几点：3.1 方法签名必须一致方法签名由方法名称、参数列表和返回类型组成。

子类重写父类方法时，必须保证方法签名一致，否则编译器将无法识别该方法为重写而是新定义的方法。

3.2 访问修饰符不能更严格在进行方法重写时，子类不能使用比父类更严格的访问修饰符。

如果父类中的方法使用了protected访问修饰符，则子类中重写该方法时只能使用protected或public访问修饰符。

Java基础-重写-子类重写父类中的方法后执行情况

Java基础-重写-⼦类重写⽗类中的⽅法后执⾏情况代码public class Test {public static void main(String[] args) {Shape shape = new Circle();System.out.println();shape.printType();shape.printName();}}class Shape {public String name = "shape";public Shape(){System.out.println("shape constructor");}public void printType() {System.out.println("this is shape");}public static void printName() {System.out.println("shape");}}class Circle extends Shape {public String name = "circle";public Circle() {System.out.println("circle constructor");}public void printType() {System.out.println("this is circle");}public static void printName() {System.out.println("circle");}}结果shape constructorcircle constructorshapethis is circleshape这道题主要考察了隐藏和覆盖的区别（当然也和多态相关)覆盖只针对⾮静态⽅法（终态⽅法不能被继承，所以就存在覆盖⼀说了），⽽隐藏是针对成员变量和静态⽅法的。

Java编程关于子类重写父类方法问题的理解

Java编程关于⼦类重写⽗类⽅法问题的理解⼦类重新实现⽗类的⽅法称重写；重写时可以修改访问权限修饰符和返回值，⽅法名和参数类型及个数都不可以修改；仅当返回值为类类型时，重写的⽅法才可以修改返回值类型，且必须是⽗类⽅法返回值的⼦类；要么就不修改，与⽗类返回值类型相同。

那么，该如何理解呢？为什么要是⽗类返回值类型的⼦类？提出问题：⼦类必须重写⽗类所有⽅法吗？Java，⼦类不是必须重写⽗类所有⽅法的，分为以下两种情况：⽗类⽅法为抽象⽅法时，⼦类必须重写（实现）所有⽗类的抽象⽅法；⽗类⽅法为普通⽅法时，⼦类可以重写⽗类⽅法，也可以不重写。

举例如下：abstract class A{public void a(){}public abstract void b();}public class B extends A{//必须重写b⽅法，a⽅法可以不重写public void b(){}}还是先看⽰例，详见下⽂。

包human中定义了三个类，Person类、Student类和TestMain类，其中Student类是Person类的⼦类。

代码分别如下：Person类的代码如下：package human;public class Person {String name;int age;//test:重写public Person overRide() {Person per = new Person(); = "liu";return per;}}Student类重写了⽗类的overRide()⽅法，代码如下：package human;public class Student extends Person {String stuNumber;int score;//test:重写public Student overRide() {Student stu = new Student(); = "li";return stu;}}TestMain类的代码如下：package human;public class TestMain {public static void main(String[] args) {Student stu = new Student();Person per = new Person();per = stu.overRide();System.out.println();per = per.overRide();System.out.println();}输出结果为：lili有没有⼈跟我⼀样，第⼀反应输出应该为“li liu”呢，怎么两个都是“li”？仔细分析⼀下，看下⾯的⼏张内存图就明⽩了。

java中子类重写父类的方法(一)

java中子类重写父类的方法(一)Java中子类重写父类介绍在Java中，子类可以通过继承父类并重写父类的方法来实现自定义行为。

子类重写父类的方法是面向对象编程中的重要概念之一。

本文将详细说明Java中子类重写父类的各种方法。

方法一：方法重写方法重写是指在子类中定义一个与父类相同签名的方法，用于覆盖父类中的同名方法，从而改变子类的行为。

示例代码：public class Parent {public void sayHello() {("Hello from Parent");}}public class Child extends Parent {@Overridepublic void sayHello() {("Hello from Child");}}public class Main {public static void main(String[] args) {Parent parent = new Parent();(); // 输出：Hello from ParentChild child = new Child();(); // 输出：Hello from ChildParent parent2 = new Child();(); // 输出：Hello from Child}}解释：•Parent类定义了一个名为sayHello的方法，输出”Hello from Parent”。

•Child类继承自Parent类，并重写了父类的sayHello方法，输出”Hello from Child”。

•在主方法中，首先创建一个Parent对象，调用其sayHello方法，输出”Hello from Parent”。

•然后创建一个Child对象，调用其sayHello方法，输出”Hello from Child”。

•最后创建一个Parent引用指向Child对象，调用其sayHello方法，输出”Hello from Child”。

java方法重写的规则

java方法重写的规则摘要：1.重写的概念与意义2.Java方法重写的规则3.重写时的注意事项4.总结正文：Java方法重写的规则在Java编程中，继承和多态是两个重要的概念。

子类可以通过重写父类的方法来实现多态，提高代码的可扩展性和可维护性。

下面我们将详细介绍Java 方法重写的规则以及重写时需要注意的事项。

1.重写的概念与意义方法重写是指子类继承父类方法时，根据需要对方法进行重写，以实现子类特有的功能。

重写的方法需要遵循一定的规则，以确保代码的规范性和稳定性。

2.Java方法重写的规则（1）方法签名：子类重写的方法必须与父类的方法具有相同的参数列表和返回类型。

（2）访问权限：子类重写的方法的访问权限不能比父类的方法更严格。

例如，如果父类方法是public，那么子类方法也必须是public。

（3）返回类型：子类重写的方法返回类型必须与父类方法返回类型相同。

（4）方法声明：子类重写的方法必须在声明中使用“ override”关键字。

3.重写时的注意事项（1）遵循访问控制：子类重写的方法访问权限不能比父类方法更严格，否则会导致编译错误。

（2）方法名相同：子类重写的方法名必须与父类方法名相同，但可以有不同的参数列表。

（3）返回值类型相同：子类重写的方法返回值类型必须与父类方法返回值类型相同。

（4）抛出异常：子类重写的方法不能抛出比父类方法抛出异常更严重的异常，否则会导致编译错误。

4.总结Java方法重写是实现多态的重要手段，遵循一定的规则可以提高代码的可扩展性和可维护性。

在重写方法时，需要注意访问控制、方法名、返回类型和异常处理等方面的要求。

java重写方法

java重写方法Java中的重写方法。

在Java中，重写方法是指子类重新定义父类中已有的方法。

通过重写方法，子类可以根据自身的需求来重新实现父类中的方法，从而实现定制化的功能。

在本文中，我们将介绍Java中重写方法的相关知识和技巧。

首先，我们需要了解重写方法的基本规则。

在Java中，要重写一个方法，子类的方法必须与父类的方法具有相同的名称、参数列表和返回类型。

此外，子类中重写的方法不能比父类中被重写的方法拥有更严格的访问权限。

换句话说，如果父类中的方法是public的，那么子类中重写的方法也必须是public的。

接下来，我们来看一个简单的例子来说明重写方法的使用。

假设我们有一个父类Animal，其中有一个eat()方法：```java。

public class Animal {。

public void eat() {。

System.out.println("Animal is eating");}。

}。

```。

现在，我们创建一个子类Dog，我们想要重写父类Animal中的eat()方法：```java。

public class Dog extends Animal {。

@Override。

public void eat() {。

System.out.println("Dog is eating");}。

}。

```。

在这个例子中，子类Dog重写了父类Animal中的eat()方法，并且实现了自己的eat()方法。

当我们调用Dog的eat()方法时，将会输出"Dog is eating"，而不是"Animal is eating"。

除了重写父类中的实例方法外，Java中还可以重写父类中的静态方法。

但需要注意的是，静态方法不能被子类重写，因为静态方法是与类相关联的，而不是与对象相关联的。

因此，子类中的同名静态方法只是隐藏了父类中的静态方法，而不是重写。

java重写方法规则

java重写方法规则
重写方法是Java中一项重要特性，它允许在子类中重写父类中的方法，以在不改变父类结构的情况下提供特定于子类的实现。

本文中，将介绍重写方法的一般规则。

重写方法的规则一般包括：
（一）方法名和形式参数必须具有完全相同的签名，返回类型也必须一致。

方法可以改变返回类型，但子类的返回类型必须是父类返回类型的子类型。

例如，如果父类的方法返回一个Object，子类的重写方法可以返回一个String，但重写方法不能返回Integer，因为String不是Integer的子类型。

（二）子类重写的方法可以改变其访问权限，比如将父类中的protected方法重写为public方法。

（三）子类重写的方法不能抛出比父类中被重写的方法更广泛的异常。

（四）父类的final方法可能不会被重写。

（六）如果一个类声明了一个方法带有final关键字，表明此方法为不可变的，不能被重写。

（七）正确重写父类方法的执行和结果必须与父类中被重写的方法一致。

（八）子类可以重写父类中被声明为static的方法，但必须保持方法的签名完全一致。

（九）父类中的非静态属性可以在子类中被重写，但子类的静态属性不能被重写。

（十）子类重写的方法可以调用父类中被重写的方法，而且可以使用super关键字在子类中直接调用父类中被重写的方法。

此外，Java 8还增加了一些规则，比如重写方法可以抛出受检异常，即声明在方法中的异常，这些异常必须在子类重写的方法中抛出，或者在父类中抛出的异常的子类。

java 方法重写

java 方法重写Java 方法重写。

在Java编程中，方法重写（Method Overriding）是一个非常重要的概念，它允许子类重新定义父类中的方法。

方法重写是面向对象编程中的多态性的体现，通过方法重写，我们可以实现不同对象对同一方法的不同行为。

本文将详细介绍Java 方法重写的概念、规则和示例，帮助读者更好地理解和运用这一重要的编程特性。

概念。

方法重写是指子类重新定义父类中已有的方法，使得子类对象可以根据自身的特性来执行这一方法。

在方法重写中，子类需要保持方法名、参数列表和返回类型与父类中的方法一致，但可以重新定义方法体。

通过方法重写，我们可以实现多态性，即不同对象对同一方法的不同行为。

规则。

在Java中，方法重写需要遵循一定的规则，以确保程序的正确性和可读性。

下面是方法重写的规则：1. 子类方法的访问修饰符不能严格地限制父类方法的访问权限。

例如，父类方法使用public修饰，那么子类方法只能使用public修饰或者不使用任何修饰符；父类方法使用protected修饰，那么子类方法可以使用protected或public修饰；父类方法使用default修饰，那么子类方法可以使用default、protected或public修饰。

2. 子类方法不能使用比父类方法更严格的异常。

如果父类方法抛出了异常，那么子类方法可以不抛出异常，也可以抛出父类方法抛出的异常或者其子类异常，但不能抛出父类方法没有抛出的异常。

3. 子类方法的返回类型必须与父类方法的返回类型一致，或者是其子类。

下面通过一个示例来演示方法重写的具体应用。

假设我们有一个父类Animal 和一个子类Dog，它们都有一个eat方法，我们希望在子类中重新定义eat方法来实现不同的行为。

```java。

class Animal {。

public void eat() {。

System.out.println("Animal is eating");}。

父类调用子类重写方法

父类调用子类重写方法在面向对象的编程中，子类可以继承父类的方法和属性，并且还可以通过重写父类的方法来改变或扩展其功能。

假设有一个父类Animal和一个子类Dog，我们来探讨父类调用子类重写方法的情况。

首先，需要明确的一点是，父类是无法直接调用子类的方法的。

因为在父类中并没有定义子类所特有的方法，所以无法直接通过父类实例调用子类的方法。

但是，应该注意到的是，在面向对象的设计中，我们常常会使用多态来实现动态绑定，即通过父类的引用指向子类的对象。

这时，虽然我们无法直接调用子类的方法，但是可以通过父类的引用调用子类重写的方法。

具体来说，我们可以使用父类的引用指向子类的对象，然后调用重写的方法。

例如，假设我们有以下的代码：javaclass Animal {void sound() {System.out.println("动物发出声音");}}class Dog extends Animal {@Overridevoid sound() {System.out.println("狗发出汪汪的声音");}}public class Main {public static void main(String[] args) {Animal animal = new Dog();animal.sound(); 调用重写的方法}}在上面的代码中，Animal类有一个sound()方法，而Dog类继承自Animal类，并重写了sound()方法。

在main()方法中，我们使用父类Animal的引用指向子类Dog的对象，并调用了sound()方法。

在运行上述代码时，输出的结果是"狗发出汪汪的声音"。

这是因为Java中的方法调用是动态绑定的，即在运行时根据对象的实际类型来决定调用哪个方法。

animal.sound()语句中，animal引用的实际类型是Dog，所以会调用Dog类中重写的sound()方法。

深入理解java重写的概念

深⼊理解java重写的概念1、重写：在⼦类中可以根据需要对从基类中继承来的⽅法进⾏重写，重写是对类中⽅法的扩充，因为继承⽤的是⽗类的东西，重写则不仅得到⽗类的东西，同时也加⼊了⾃⼰的东西2、在Java和其他⼀些⾼级⾯向对象的编程语⾔中，⼦类可继承⽗类中的⽅法，⽽不需要重新编写相同的⽅法。

但有时⼦类并不想原封不动地继承⽗类的⽅法，⽽是想作⼀定的修改，这就需要采⽤⽅法的重写。

⽅法重写⼜称⽅法覆盖。

若⼦类中的⽅法与⽗类中的某⼀⽅法具有相同的⽅法名、返回类型和参数表，则新⽅法将覆盖原有的⽅法。

如需⽗类中原有的⽅法，可使⽤super关键字，该关键字引⽤了当前类的⽗类。

3、⽅法重写的特性 1>发⽣⽅法重写的两个⽅法返回值、⽅法名、参数列表必须完全⼀致(⼦类重写⽗类的⽅法) 2>⼦类抛出的异常下不能超过⽗类相应⽅法抛出的异常(⼦类异常不能⼤于⽗类异常) 3>⼦类⽅法的访问级别不能低于⽗类相应⽅法的访问级别(⼦类访问级别不能低于⽗类访问级别) 根据2，3条可以确定第⼀条，⼦类重写⽗类⽅法的返回值类型不能⼤于⽗类⽅法的返回值类型，即是说⼦类⽅法的返回值必须和⽗类⽅法的返回值相同或是其⼦类。

（1）⽗类与⼦类之间的多态性，对⽗类的函数进⾏重新定义。

即在⼦类中定义某⽅法与其⽗类有相同的名称和参数。

（2）若⼦类中的⽅法与⽗类中的某⼀⽅法具有相同的⽅法名、返回类型和参数表，则新⽅法将覆盖原有的⽅法。

如需⽗类中原有的⽅法，可使⽤super关键字，该关键字引⽤了当前类的⽗类。

4>重写是为了增强类的重⽤性和复⽤性，扩展性；重写是对类中⽅法的扩充，因为继承⽤的是⽗类的东西，重写则不仅得到⽗类的东西，同时也加⼊了⾃⼰的东西。

Java 重写与重载总结

Java 重写与重载目录1、重写(Override) (2)2、方法的重写规则 (3)3、Super 关键字的使用 (4)4、重载(Overload) (5)5、重载规则 (5)6、重写与重载之间的区别 (6)1、重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。

也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出Exception 异常，因为Exception 是 IOException 的父类，抛出 IOException 异常或者IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。

实例如下：2、方法的重写规则2.1参数列表与被重写方法的参数列表必须完全相同。

2.2返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

2.3访问权限不能比父类中被重写的方法的访问权限更低。

例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

2.4父类的成员方法只能被它的子类重写。

2.5声明为 final 的方法不能被重写。

2.6声明为 static 的方法不能被重写，但是能够被再次声明。

2.7子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

2.8子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

2.9重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。

Java基础篇之继承与方法重写

Java基础篇之继承与⽅法重写1.继承的解释：Java语⾔中继承体现的是⼀种“is a”的关系，Java仅⽀持单继承，但可以多层继承，即⼦类继承⽗类，⽗类继承祖⽗类2.继承的注意事项： 1.⼦类只能继承⽗类中⾮私有的成员变量和成员⽅法 2.⼦类不能继承⽗类的构造⽅法，但可以通过super关键字去访问⽗类的构造⽅法注意：super的⽤法和this很像，this代表本类对象的引⽤，super代表⽗类存储空间的标识，可以理解为⽗类引⽤，可以操作⽗类的成员⼦类中所有的构造⽅法默认都会先访问⽗类中⽆参的构造⽅法，这是因为⼦类继承⾃⽗类，所以要先初始化⽗类，这样⼦类才能⽤⽗类中的成员变量，综上，⼦类的每⼀个构造⽅法第⼀句肯定是super();调⽤⽗类的⽆参构造⽅法。

如果⽗类没有⽆参的构造⽅法，那么⼦类的构造⽅法就会报错，解决办法： 1.加⼊⼀个⽗类的⽆参构造⽅法 2.通过使⽤super关键字去显⽰的调⽤⽗类的带参构造⽅法，例如⽗类中没有⽆参构造⽅法，但有⼀个带String name的构造⽅法：public Person(String name){}，此时⼦类的构造⽅法第⼀⾏可以调⽤这个⽗类带参的构造⽅法：super("张三")。

this(...)和super(...)必须在第⼀⾏，避免多次初始化⽗类。

3.⽅法重写：⼦类中出现了和⽗类中⼀模⼀样的⽅法，包括⽅法名，参数，返回值类型等都⼀模⼀样，如果⼦类中的⽅法和⽗类中的⽅法⼀模⼀样，就近原则会先使⽤⼦类的⽅法。

4.⽅法重写的注意事项：⽗类中的私有⽅法不能被重写，因为⼦类⽆法继承⽗类的私有⽅法⼦类重写⽗类中的⽅法时，访问权限不能更低，，即⼦类⽅法的访问修饰符权限必须要⼤于等于⽗类的访问修饰符，所以如果⽗类中的该⽅法被public修饰，那么⼦类重写该⽅法，访问修饰符也必须是public ⽗类静态⽅法，⼦类也必须通过静态⽅法重写，这与多态相关5.代码展⽰：class Person2{private int age=10;String name="张三";int score=90;public Person2(){System.out.println("这是Person2的⽆参构造⽅法");}public void eat(){System.out.println("⼈都要吃饭");}public void show(){System.out.println("⼈都会思考");}static{System.out.println("静态代码块");}private void method(){System.out.println(age);System.out.println(name);}public void method2(){System.out.println(age);System.out.println(name);}public void play(){System.out.println("我是⼈，我可以玩");}private void example(){System.out.println("我是⼀个样例");}}class Student extends Person2 {int score=80;{System.out.println("构造代码块");}static{System.out.println("student的静态代码块");}public Student(){System.out.println("我是Student的构造⽅法");}public void method3(){int score=70;System.out.println(score);System.out.println(this.score);System.out.println(super.score);}public void play(){super.play();System.out.println("我同时也是⼀名学⽣，还需要学习");}}public class ExtendsDemo {public static void main(String[] args) {Student s=new Student();//静态代码块 student的静态代码块这是Person2的⽆参构造⽅法构造代码块我是Student的构造⽅法 s.eat();//⼈都要吃饭s.show();//⼈都会思考//s.method(); ⽆法访问⽗类私有的成员⽅法//int a=s.age;⽆法访问⽗类私有的成员变量s.method2();//通过⽗类中的成员⽅法访问私有成员变量 10 张三s.method3();//70 80 90s.play();//我是⼈，我可以玩我同时也是⼀名学⽣，还需要学习}}。

java 子类重载构造方法

java 子类重载构造方法Java是一种面向对象的编程语言，它支持继承和多态等特性。

在Java中，子类可以继承父类的属性和方法，同时也可以重载父类的构造方法。

本文将介绍Java子类重载构造方法的相关知识。

什么是构造方法？在Java中，构造方法是一种特殊的方法，它用于创建对象并初始化对象的属性。

每个类都有一个构造方法，如果没有显式地定义构造方法，则会默认生成一个无参构造方法。

构造方法的名称必须与类名相同，它没有返回值，也不能被继承。

子类继承父类的构造方法当子类继承父类时，它会自动继承父类的构造方法。

子类可以通过super关键字调用父类的构造方法，以初始化父类的属性。

例如：```public class Animal {private String name;public Animal(String name) { = name;}}public class Dog extends Animal {public Dog(String name) {super(name);}}```在上面的例子中，Dog类继承了Animal类的构造方法，并通过super关键字调用了Animal类的构造方法，以初始化Animal类的属性。

子类重载父类的构造方法除了继承父类的构造方法外，子类还可以重载父类的构造方法。

重载是指在同一个类中定义多个方法，它们具有相同的名称但参数列表不同。

子类重载父类的构造方法可以为子类提供更多的构造方法，以满足不同的需求。

例如，我们可以在Animal类中定义一个无参构造方法和一个有参构造方法，然后在Dog类中重载有参构造方法，以提供更多的构造方法：```public class Animal {private String name;public Animal() { = "unknown";}public Animal(String name) { = name;}}public class Dog extends Animal {public Dog() {super();}public Dog(String name) {super(name);}}```在上面的例子中，Animal类定义了一个无参构造方法和一个有参构造方法，而Dog类重载了有参构造方法，并提供了一个无参构造方法。

深入理解Java重载与重写

深⼊理解Java重载与重写我们都知道Java有三⼤宝，分别是：多态、封装、继承。

其中多态主要体现就是重写与重载（有些⼈认为重载根本不属于多态）两种⽅式，那么今天就结合研读过JVM之后⾃⼰的理解来聊聊重载与重写的VM内部是怎么实现的，是怎么找到最后执⾏的⽅法的。

在分析重载与重写这两个之前，我们必须要知道⼀些概念：分派、静态分派、动态分派、实际类型、静态类型....（之后涉及到的会边介绍别举例才能更好地理解）⼀、相关的概念1、静态类型与实际类型先看以下⼀个重载例⼦的输出，再进⼀步介绍：1public class StaticDispatch {23static abstract class Human{ }4static class Man extends Human{ }5static class Women extends Human{ }6//三个⽅法重载7public void sayHello(Human guy) {8 System.out.println("hello guy!");9 }10public void sayHello(Man guy) {11 System.out.println("hello gentleman!");12 }13public void sayHello(Women guy) {14 System.out.println("hello laday!");15 }16public static void main(String[] args) {17 Human man = new Man();//upcast18 Human woman = new Women();//upcast19 StaticDispatch sd = new StaticDispatch();20//输出结果为：hello guy!21 sd.sayHello(man);22 sd.sayHello(woman);23 }24 }⼤多数都应该能知道最后的输出结果为：hello, guyhello, guy这是为什么呢？根据输出来看man与woman就是Human类，这肯定是成⽴的，通过向上转型成基类（⽗类）可以使⽤getClass()或者instanceof确定，我们先不研究为什么吧。

java重写方法的特点

java重写方法的特点Java中的方法重写是面向对象编程中的一个重要概念，它允许子类重新定义父类中已经定义的方法。

方法重写是实现多态性的一种方式，通过重写方法，可以在不改变方法名称和参数列表的情况下，改变方法的实现逻辑，使得方法在不同的对象中具有不同的行为。

方法重写的特点如下：1. 继承关系：方法重写只能发生在父类和子类之间，即子类可以重写父类的方法。

在Java中，通过extends关键字来建立类之间的继承关系。

2. 方法名称和参数列表相同：重写的方法必须与父类中的被重写方法具有相同的名称和参数列表。

这是Java中识别重写关系的基本条件。

3. 返回值类型相同或是其子类：重写的方法的返回值类型可以与父类中被重写方法的返回值类型相同，也可以是其子类。

这是为了保证子类重写的方法可以替代父类的方法。

4. 访问修饰符相同或更宽松：重写的方法的访问修饰符可以与父类中被重写方法的访问修饰符相同，或者比父类的访问修饰符更宽松。

例如，父类中的方法是public修饰的，那么子类中重写的方法可以是public或protected修饰的，但不能是private修饰的。

5. 抛出的异常相同或更窄：重写的方法可以抛出与父类中被重写方法相同的异常，也可以抛出其子类的异常，或者不抛出异常。

但是，重写的方法不能抛出比父类中被重写方法更宽泛的异常。

方法重写的目的是为了实现多态性。

在Java中，通过方法重写可以实现动态绑定，即在运行时根据对象的实际类型来确定调用哪个方法。

这样可以提高代码的灵活性和可扩展性，使得程序更加易于维护和扩展。

方法重写的示例代码如下：```javaclass Animal {public void move() {System.out.println("动物可以移动");}}class Dog extends Animal {@Overridepublic void move() {System.out.println("狗可以跑和走");}public void bark() {System.out.println("狗可以吠叫");}}public class Test {public static void main(String[] args) {Animal animal = new Animal(); // 创建Animal对象animal.move(); // 调用Animal类的move方法Animal dog = new Dog(); // 创建Dog对象，使用Animal 类型的引用dog.move(); // 调用Dog类重写的move方法// dog.bark(); // 编译错误，Animal类型的引用不能调用子类特有的方法}}```运行结果：```动物可以移动狗可以跑和走```在上述示例中，Animal类是父类，定义了一个名为move的方法，用于表示动物的移动行为。

老九Java基础课关于子类重写的总结

Java重写和重载的知识点

Java中子类重写父类方法

java的继承类,重写方法

Java基础之方法重写详解

Java重写时应当遵守的11条规则

java中子类重写父类的方法

Java基础-重写-子类重写父类中的方法后执行情况

Java编程关于子类重写父类方法问题的理解

java中子类重写父类的方法(一)

java方法重写的规则

java重写方法

java重写方法规则

java 方法重写

父类调用子类重写方法

深入理解java重写的概念

Java 重写与重载总结

Java基础篇之继承与方法重写

java 子类 重载构造方法

深入理解Java重载与重写

java重写方法的特点

java 子类重载构造方法