继承进一步使用,以及super关键字
目标:
1)掌握子类对象实例化过程
2)掌握方法覆盖概念和实现。
3)掌握super关键字的作用。
一,子类对象实例化过程
子类对象在实例化之前,必须先调用父类中的构造方法,再调用子类中的构造方法。
class Person{ // 定义Person类
private String name ; // 定义name属性
private int age ; // 定义age属性
public Person(){
System.out.println("父类Person中的构造。") ;
}
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
};
class Student extends Person{ // 定义Student类
private String school ; // 定义school属性
public Student(){
super() ; // 默认隐藏
System.out.println("子类Student中的构造。") ;
}
public void setSchool(String school){
this.school = school ;
}
public String getSchool(){
return this.school ;
} };
public class InstanceDemo{
public static void main(String arsg[]){
Student stu = new Student() ;// 实例化子类对象
stu.setName("张三") ; // 此方法在Student类中没有明确定义
stu.setAge(30) ;
stu.setSchool("清华大学") ;
System.out.println("姓名:" + stu.getName() + ",年龄:" + stu.getAge() + ",学校:" + stu.getSchool() ) ;
}
};
运行结果:
父类Person中的构造。
子类Student中的构造。
姓名:张三,年龄:30,学校:清华大学
在生活中也很好理解,没有父亲就没有孩子。
实际上,对于子类的构造方法中,隐含了一个“super()”的语句。有时候,也将父类称为超类,所以调用父类构造方法,用super()。
super关键字必须写在构造方法的首行。
二,方法的复写
方法覆写就是指:子类中定义了与父类中同名的方法。
1)但是在方法覆写时必须考虑访问权限,即:被子类覆写的方法,不能拥有比父类更严格的访问权限。
2)所以,如果在父类中使用public定义的方法,子类的访问权限必须是public,否则无法编译。
3)private<default<public。
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
public void print(){
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo01{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
运行结果:
Student-->void print()。
访问权限:
private:最小的访问权限。
default:什么都不写,例如:string name;
public:最大的访问权限。
以下是访问权限出问题的错误操作。
package methoud;
class Person{ // 定义父类
public void print(){ // public的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
void print(){ // 错误的,降低了访问权限
System.out.println("Student --> void print()。") ;
}
};
public class ThisDemo06{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
由于子类的访问权限default小于public,所以编译通过不了。
从之前正确操作可以看出,如果子类将父类的方法覆写了,调用的时候,肯定是调用被覆写过的方法,那么如果非要调用父类的方法。
通过“super”关键字可以完成功能,super关键字可以从子类访问父类的内容。
如果要访问被覆写过的方法的方法:super.方法();
例如:
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
public void print(){
super.print() ; // 访问父类中被子类覆写过的方法
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo03{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
运行结果:
Person --> void print()。 Student --> void print()。
如果要使用“super”不一定非要在方法覆写之后使用,也可以明确表示某个方法是从父类中继承而来的。
使用super只是更加明确的说直接从父类中寻找,就不从子类找了。因为没有super调用方法,首先从子类寻找,如果子类没有才到父类寻找。
例如:如果上面那个例子中super.print()把super去掉,就会造成无限期循环递归,自己调用自己。
三,问题:
如果父类中使用private关键字声明一个方法,那么在子类中使用default权限算是扩大权限,覆写吗?
答案是:NO,不算覆写。
正常覆写:
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
public void fun(){ // 定义一个fun方法
this.print() ; // 调用print()方法
}
};
class Student extends Person{ // 定义继承关系
void print(){ // 覆写父类中的方法
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo04{
public static void main(String args[]){
Student s = new Student() ;
s.fun() ;
}
};
运行结果:
Student --> void print()。
这里因为正常覆写,所以直接调用了子类中的覆写方法。
错误的覆写:
package methoud;
class Person{ // 定义父类
private void print(){ // private的访问权限
System.out.println("Person --> void print()。") ;
}
public void fun(){ // 定义一个fun方法
this.print() ; // 调用print()方法
}
};
class Student extends Person{ // 定义继承关系
void print(){ // 覆写父类中的方法
System.out.println("Student --> void print()。") ;
}
};
public class ThisDemo06{
public static void main(String args[]){
Student s = new Student() ;
s.fun() ;
}
};
运行结果:
Person-->void print();
可见,这里并没有调用子类中的“覆写”方法,而是调用父类中默认的方法。说明这里并没有达到覆写的作用,子类中的方法其实是另外定义了一个方法。
这点需要注意!。
四,属性的覆盖。
覆盖,就是指子类中声明了父类中同名的属性。
class Person{ // 定义父类
public String info = "MLDN" ; // 定义一个公共属性
};
class Student extends Person{ // 定义继承关系
public String info = "LXH" ; // 定义了一个与父类中属性名称一致的属性
void print(){ // 覆写父类中的方法
System.out.println("父类中的属性:" + super.info) ;
System.out.println("子类中的属性:" + this.info) ;
}
};
public class OverrideDemo05{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
可见,要使用被覆盖的父类中的属性,需要使用super关键字。
五,方法覆盖与重载的区别
六,super关键字
super表示的是从子类调用父类中的指定操作。例如调用属性,方法,构造等等。
因为在子类实例化的时候,会默认调用父类中的无参数构造方法(“super()”)。如果想调用有参构造方法,则必须在子类中明确声明。
class Person{ // 定义Person类
private String name ; // 定义name属性
private int age ; // 定义age属性
public Person(String name,int age){
this.setName(name) ;
this.setAge(age) ;
}
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public String getInfo(){
return "姓名:" + this.getName() + ";年龄:" + this.getAge() ;
}
};
class Student extends Person{ // 定义Student类
private String school ; // 定义school属性
public Student(String name,int age,String school){
super(name,age) ; // 明确调用父类中有两个参数的构造
this.school = school ;
}
public void setSchool(String school){
this.school = school ;
}
public String getSchool(){
return this.school ;
}
public String getInfo(){
return super.getInfo() + ";学校:" + this.getSchool() ;
} };
public class SuperDemo01{
public static void main(String arsg[]){
Student stu = new Student("张三",30,"清华大学") ;// 实例化子类对象
System.out.println(stu.getInfo()) ;
}
};
不管任何时候,子类实例化的时候,永远要先去调用父类中的构造方法,默认调用的是无参构造方法。
1)对于this和super本身都可以调用构造方法,而且调用的时候都必须放在构造方法的首行。所以这两个方法肯定不能同时出现。
继承进一步使用,以及super关键字的更多相关文章
- JAVA继承时this和super关键字
JAVA继承时this和super关键字 本文主要讨论在方法前使用this或super关键字时,编译器在什么地方查找对应的函数. 在子类中指定this关键字.首先在本类中查找,如果本类中找不到,再在父 ...
- java中关于类的封装与继承,this、super关键字的使用
原创作品,可以转载,但是请标注出处地址http://www.cnblogs.com/V1haoge/p/5454849.html. this关键字: this代表当前对象,它有以下几种用途: 1.本类 ...
- 面向对象编程(四)继承,概念及super关键字,final关键字,Object类常见方法
继承 概念: ① 继承背后的思想就是基于已存在的类来构建新类; ② 当从已存在类继承时,就重用了它的方法和属性,还可以添加新的方法和属性来定制新类以应对需求; ③ 当从其它类导出的类叫作子 ...
- 详解 继承(下)—— super关键字 与 多态
接上篇博文--<详解 继承(上)-- 工具的抽象与分层> 废话不多说,进入正题: 本人在上篇"故弄玄虚",用super();解决了问题,这是为什么呢? 答曰:子类中所有 ...
- 面向对象编程(十)——继承之Super关键字及内存分析
Super关键字
- JavaSE复习日记 : 继承关系和super关键字以及继承关系中方法的覆写
/* * 类的继承和super关键字 * * 软件开发的三大目的: * 可拓展性; * 可维护性; * 可重用性; * * 这里单说下可重用性这一项: * 为了代码复用,复用方式有: * 函数的调用复 ...
- java学习笔记-继承中super关键字
背景: 在java继承的概念中我们得知,被声明为私有的类成员对所属的类来说仍然是私有的.类之外的任何代码都不能访问,包括子类. super关键字的两种用法: 1.用于调用超类的构造函数: 2.用于访问 ...
- 24 类:组合 继承 super关键字 面向对象的三大性
组合 组合:自定义类的对象作为另外一个类的属性 class Teacher: def __init__(self, name, age): self.name = name self.age = ag ...
- java学习笔记(八):继承、extends、super、this、final关键字
继承解决代码重用的问题,方便管理和维护代码. 继承 子类拥有父类非private的属性,方法. 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展. 子类可以用自己的方式实现父类的方法. Java ...
随机推荐
- Bootstrap 我的学习记录4 轮播图的使用和理解
<!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="utf-8& ...
- 关于js中两种定时器的设置及清除
1.JS中的定时器有两种: window.setTimeout([function],[interval]) 设置一个定时器,并且设定了一个等待的时间[interval],当到达时间后,执行对应的方法 ...
- 数位类统计问题--数位DP
有一类与数位有关的区间统计问题.这类问题往往具有比较浓厚的数学味道,无法暴力求解,需要在数位上进行递推等操作.这类问题往往需要一些预处理,这就用到了数位DP. 本文地址:http://www.cnbl ...
- 【原】结构体包含CString类型成员变量出错的原理
问题如下:我定义了如下的一个结构体: typedef struct{ CString csText;}MyStruct; 并有如下的程序段1:MyStruct * p=NULL;p=(MyStru ...
- iOS label根据显示内容自适应大小
- (void)setupLabel { //准备工作 UILabel *textLabel = [[UILabel alloc] init]; textLabel.font = [UIFont sy ...
- Java 之 内部类
(static修饰的成员属于整个类,而不属于单个对象) 定义:将一个类放到另一个类的内部定义,这个在内部定义的类就叫做内部类(也有的成嵌套类),包含内部类的类被称为外部类(也有的称宿主类). 1.非静 ...
- INFORMATICA 的调优之 INFORMATICA SERVER TUNING
INFORMATICA SERVER的调优我认为主要从两个级别来做,一个是MAPPING级别,一个是SESSION级别. 对于MAPPING级别的调优: 一 对MAPPING数据流向的优化: 1 控 ...
- 标准sql语句,学习
标准SQL语句总结标准SQL语句总结,标准SQL语言基本上适用于下面所列出的数据库软件 -------------------------------------------------------- ...
- 读书笔记——Windows环境下32位汇编语言程序设计(9)ANSII字符大小写转大写
在罗云彬的<Windows环境下32位汇编语言程序设计>中第321页 ... .const szAllowedChar db '0123456789ABCDEFabcdef',08h .. ...
- 仅IE6中链接A的href为javascript协议时不能在当前页面跳转
切页面时有时用链接A来替代按钮,这样做有几个好处 鼠标放上时默认有手状效果(不用添加cursor:pointer) 可以添加低版本IE都支持的伪类 如果点击时页面要整体刷新,即跳转,这时IE6则不尽人 ...