Java中类的继承,重写
java继承子类重写父类方法

java继承子类重写父类方法Java继承和方法重写什么是继承?在Java中,继承是一种重要的面向对象编程概念。
它允许我们创建一个新的类,称为子类(或派生类),从一个现有的类,称为父类(或基类)继承属性和方法。
子类可以继承父类的所有非私有成员,并可以添加自己的新成员。
为什么要继承?继承提供了代码重用的机制,减少了重复编写代码的工作量。
它还可以使代码更具可读性,可维护性和可扩展性。
通过继承,我们可以建立类之间的层次结构,使得代码的组织更加清晰。
方法的重写方法的重写是指子类重新定义或实现从父类继承的方法。
在Java 中,子类可以覆盖父类的方法,以满足其特定的需求。
方法的重写通过使用相同的方法名,返回类型和参数列表来实现。
当子类重写父类的方法时,子类的方法将完全取代父类的方法。
子类可以根据自己的需要实现不同的行为,但方法的签名必须与父类的方法相同。
方法重写的规则在进行方法重写时,需要遵守以下规则:1.子类的方法必须具有与父类方法相同的名称和参数列表。
2.子类的方法必须具有相同或更宽松的访问权限(即不能缩小方法的访问权限)。
3.子类的方法必须具有相同的返回类型或其子类。
4.子类的方法不能抛出比父类方法更广泛的异常。
方法重写示例下面是一个例子,演示了如何在Java中实现方法的重写:public class Animal {public void sound() {("Animal is making a sound");}}public class Dog extends Animal {@Overridepublic void sound() {("Dog is barking");}}public class Cat extends Animal {@Overridepublic void sound() {("Cat is meowing");}}public class Main {public static void main(String[] args) { Animal animal = new Animal();();Dog dog = new Dog();();Cat cat = new Cat();();}}输出结果:Animal is making a soundDog is barkingCat is meowing在上面的例子中,我们定义了一个Animal类,其中包含了一个sound()方法。
java父类方法调用顺序

java父类方法调用顺序
在Java中,当子类继承自父类并且重写了父类的方法时,父类
方法的调用顺序取决于子类的实现方式。
当子类调用父类的方法时,会根据以下几种情况进行调用:
1. 如果子类没有重写父类的方法,那么直接调用父类的方法。
2. 如果子类重写了父类的方法,并且在子类中通过super关键
字调用父类方法,那么首先会执行父类的方法,然后再执行子类的
方法体。
3. 如果子类重写了父类的方法,但在子类中没有通过super关
键字调用父类方法,那么只会执行子类的方法体,而不会执行父类
的方法。
在Java中,方法的调用顺序遵循继承链,即先从子类开始,如
果在子类中找不到对应的方法,则会去父类中寻找。
因此,父类方
法的调用顺序取决于子类对该方法的重写和调用方式。
这种调用方
式保证了程序的灵活性和可维护性,使得子类可以根据需要选择是
否调用父类的方法以及何时调用。
Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思?

Java中的⽅法覆盖(Overriding)和⽅法重载(Overloading)是什么意思? ⽅法覆盖也称为重写,重写即⼦类重新定义了⽗类的⽅法。
重写: 1、重写的⽅法必须与原⽅法有相同的⽅法名、参数列表和返回值类型(Java SE5之后返回值类型可以是其类型的⼦类型) 2、被重写的⽅法不能是final类型,因为final类型⽆法重写 3、被重写的⽅法不能是private,因为private⽆法继承,⽽继承是重写的前提 4、被重写的⽅法不能为static,如果⽗类中的⽅法为静态,⽽⼦类的⽅法不是静态的,但是两个⽅法除了这⼀点其他都满⾜重写条件,那么会发⽣编译错误,反之亦然。
如果⼦类和⽗类中的⽅法都是静态的,并且满⾜重写条件,但仍然不会发⽣重写,因为静态⽅法是在编译时把静态⽅法和类的引⽤进⾏匹配。
5、重写的⽅法的访问权限不能⼩于原⽅法 6、重写抛出的异常的范围不能⼤于原⽅法 7、重写是在运⾏是发⽣的,JVM会在代码运⾏时作出决定。
⽅法重载简称重载,重载即同⼀个类中两个或多个⽅法名相同但参数不同的情况重载: 1、⽅法名必须相同 2、参数列表必须不同(参数的个数,类型,顺序不同) 3、⽅法的返回类型可以相同也可以不同 4、仅仅返回值类型不同不⾜以成为⽅法的重载 5、重载是发⽣在编译时的,因为编译器可以根据参数类型来选择使⽤哪个⽅法重写和重载的区别: 1、重写只能⽤于⼦类重写⽗类的⽅法,⽽重载⽤于同⼀类中的所有⽅法 2、重写的参数列表必须相同,重载的参数列表必须不同 3、重写要求返回值类型必须⼀致或是其⼦类,重载没有要求 4、重写对⽅法的访问权限和抛出异常有特殊的要求,⽽⽅法的重载没有这⽅⾯的限制 5、⽗类的⽅法只能被同⼀⼦类重写⼀次,⽽⼀个⽅法可以在所有类中被重载很多次 6、重写是运⾏时的多态,重载是编译时的多态。
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 的⽅法不能被重写。
继承、多态,重载、重写的区别与总结

继承、多态,重载、重写的区别与总结李氏原则:(1)父类的引用指向子类对象。
-多态(2)接口的引用指向实现类的实例。
-接口Polo咯,什么是多态?它的实现机制是什么呢?重载和重写的区别在那里?这就是这一次我们要回顾的四个十分重要的概念:继承、多态、重载和重写继承(inheritance)简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型。
继承是面向对象的三个基本特征--封装、继承、多态的其中之一,我们在使用JAVA 时编写的每一个类都是在继承,因为在JAVA语言中,ng.Object类是所有类最根本的基类(或者叫父类、超类),如果我们新定义的一个类没有明确地指定继承自哪个基类,那么JAVA就会默认为它是继承自Object类的。
我们可以把JAVA中的类分为以下三种:类:使用class定义且不含有抽象方法的类。
抽象类:使用abstract class定义的类,它可以含有,也可以不含有抽象方法。
接口:使用interface定义的类。
在这三种类型之间存在下面的继承规律:类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
抽象类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
接口只能继承(extends)接口。
请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements,它们是不可以随意替换的。
大家知道,一个普通类继承一个接口后,必须实现这个接口中定义的所有方法,否则就只能被定义为抽象类。
我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系,而且对于抽象类implements接口的情况下,它并不是一定要实现这个接口定义的任何方法,因此使用继承的说法更为合理一些。
java重写的具体应用场景

Java重写(Override)是一种面向对象编程中的重要概念,它允许子类重新定义父类中已经定义的方法,并提供更具体的实现。
Java重写的具体应用场景如下:
1. 实现多态性:Java重写使得父类中的方法可以被子类重新定义,从而实现多态性的概念。
当子类重写父类中的方法时,可以使用不同的实现方式和不同的参数,从而实现更加具体的功能。
2. 实现子类特有的行为:有时候子类需要实现一些特有的行为,这时候可以通过重写父类中的方法来实现。
例如,在父类中定义了一个算法的骨架,而子类需要根据具体的需求来实现某些具体的步骤,可以通过重写父类方法来实现。
3. 提高代码复用性:通过重写父类中的方法,子类可以重复使用父类中的方法实现,同时在其基础上扩展新的功能,从而提高代码复用性。
4. 改善代码设计:通过使用Java重写,可以改善代码的设计,使得程序结构更加清晰,同时也更加符合面向对象的设计原则。
重写方法必须具有与原方法完全相同的名称、返回类型和参数列表。
重写方法的访问修饰符不能比父类的访问修饰符更严格。
如果重写方法抛出了一个新的已检查异常,则父类必须声明该异常的类型或其超类型。
java中子类重写父类的方法

Java中子类重写父类的方法在Java中,子类可以重写(override)父类的方法。
方法重写是面向对象编程的一个重要概念,它允许子类根据自己的需要重新实现继承自父类的方法。
本文将详细介绍Java中子类重写父类方法的概念、语法和使用场景。
1. 方法重写的概念方法重写是指子类定义一个与父类具有相同名称、参数列表和返回类型的方法,并且在子类中提供新的实现逻辑。
通过方法重写,子类可以覆盖掉从父类继承而来的方法实现,以满足自己特有的需求。
方法重写是实现多态性(polymorphism)的一种方式。
多态性指同一个方法可以在不同的对象上产生不同的行为。
通过方法重写,我们可以在父类引用指向子类对象时,根据实际对象类型调用相应的方法。
2. 方法重写的语法在Java中,要实现方法重写,需要遵循以下语法规则:访问修饰符返回类型方法名(参数列表) throws异常 {// 子类自定义的逻辑}•访问修饰符:与父类中被重写方法的访问修饰符相同或更宽松。
常用的访问修饰符有public、protected和默认(package-private)。
•返回类型:与父类中被重写方法的返回类型相同或是其子类。
•方法名:与父类中被重写方法的方法名相同。
•参数列表:与父类中被重写方法的参数列表相同。
•throws 异常:与父类中被重写方法声明的异常列表相同或是其子集,如果子类抛出了比父类更大范围的异常,编译时会报错。
3. 方法重写的注意事项在进行方法重写时,需要注意以下几点:3.1 方法签名必须一致方法签名由方法名称、参数列表和返回类型组成。
子类重写父类方法时,必须保证方法签名一致,否则编译器将无法识别该方法为重写而是新定义的方法。
3.2 访问修饰符不能更严格在进行方法重写时,子类不能使用比父类更严格的访问修饰符。
如果父类中的方法使用了protected访问修饰符,则子类中重写该方法时只能使用protected或public访问修饰符。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
/*
*包的创建
*/
package com.by3g.test;
import java.util.Scanner;
/*
*此类实现通过:调用有参方法和无参方法(function)求出三角形的面积。
*/
class Area
{
public double width,height,area;
="漫步云端";
v.functionVilla();
}
}
运行结果:
3.自编案例总结super的两种用法:super()和super.父类方法()
class Parent
{
double width,height,depth;
Parent()
{
System.out.println("调用Parent构造函数!");
}
}
运行结果:
{
super(width,height,length);
}
void function()
{
area=width*length;
System.out.println("\n此别墅:"+name+"占地:"+area+"平方米高度为:"+height);
}
}
class Host
{
public static void main(String[] args)
{
super(width,height,depth);
super.function();
System.out.println("调用Sub有参数构造函数!");
}
}
class Demo extends Parent
{
public static void main(String[] args)
{
Sub sub;
{
Building b;
b=new Villa(120,100,100.35);
//function重写后不再是调用父类的方法
b.function(;
Villa v=new Villa();
v.width=100;
v.height=50;
v.length=120;
="漫步云端";
v.function();
System.out.println("三角形的面积为:"+(width*height/2)+"平方米");
}
/* Sss
*类的功能方法实现,要求传参数过来(重载)
*/
public double function(double width,double height)
{
area=width*height/2;
}
}
运行结果:
2.自编案例总结类的单继承(包括属性和方法的继承)
/*
*建筑类是父类
*/
class Building
{
double width,height,length,area;
Building()
{
}
Building(double width,double height,double length)
return area;
}
}
//Create类继承Area的所有方法和属性
public class Create extends Area
{
}
/*
*包的导入
*/
import com.by3g.test.Create;
/*
*共类继承Create类
*/
public class Input extends Create
}
Parent(double width,double height,double depth)
{
this.width=width;
this.height=height;
this.depth=depth;
}
void function()
{
System.out.println("三者之积为:"+height*width*depth);
{
this.width=width;
this.height=height;
this.length=length;
}
void function()
{
area=width*length;
System.out.println("此建筑物的占地面积为:"+area+"平方米高度为:"+height);
}
}
class Villa extends Building
Scanner scanf=new Scanner(System.in);
/*
*功能实现,要求输入并求出三角形的面积(也是重载)
*/
public void function()
{
System.out.print("请输入三角行的长度,宽度:");
width=scanf.nextDouble();
height=scanf.nextDouble();
{
public static void main(String[] args)
{
Input a=new Input();
//Area中无参重载调用
a.function();
//Area中有参重载调用
System.out.println("\n自带参数的三角形面积为:"+a.function(100.2,122)+"平方米");
}
}
class Host
{
public static void main(String[] args)
{
Building b;
b=new Villa(120,100,100.35);
b.function();
Villa v=new Villa();
v.width=100;
v.height=50;
v.length=120;
sub=new Sub();
sub=new Sub(12,12,12);
Demo d;
d=new Demo();
}
Demo()
{
super(10,10,10);
super.function();
}
}
运行结果:
4.自编案例总结方法重写(override)
/*
*建筑类是父类
*/
class Building
{
double width,height,length,area;
Building()
{
}
Building(double width,double height,double length)
{
this.width=width;
this.height=height;
this.length=length;
{
String name;
Villa(){}
Villa(double width,double height,double length)
{
super(width,height,length);
}
void functionVilla()
{
area=width*length;
System.out.println("\n此别墅:"+name+"占地:"+area+"平方米高度为:"+height);
}
void function()
{
area=width*length;
System.out.println("此建筑物的占地面积为:"+area+"平方米高度为:"+height);
}
}
class Villa extends Building
{
String name;
Villa(){}
Villa(double width,double height,double length)
}
void function1(double a)
{
System.out.println("zzzzzzzz");
}
}
class Sub extends Parent
{
Sub()
{
System.out.println("调用Sub中的无参构造函数!");
}
Sub(double width,double height,double depth)