目标:

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关键字的更多相关文章

  1. JAVA继承时this和super关键字

    JAVA继承时this和super关键字 本文主要讨论在方法前使用this或super关键字时,编译器在什么地方查找对应的函数. 在子类中指定this关键字.首先在本类中查找,如果本类中找不到,再在父 ...

  2. java中关于类的封装与继承,this、super关键字的使用

    原创作品,可以转载,但是请标注出处地址http://www.cnblogs.com/V1haoge/p/5454849.html. this关键字: this代表当前对象,它有以下几种用途: 1.本类 ...

  3. 面向对象编程(四)继承,概念及super关键字,final关键字,Object类常见方法

    继承 概念: ①   继承背后的思想就是基于已存在的类来构建新类; ②   当从已存在类继承时,就重用了它的方法和属性,还可以添加新的方法和属性来定制新类以应对需求; ③   当从其它类导出的类叫作子 ...

  4. 详解 继承(下)—— super关键字 与 多态

    接上篇博文--<详解 继承(上)-- 工具的抽象与分层> 废话不多说,进入正题: 本人在上篇"故弄玄虚",用super();解决了问题,这是为什么呢? 答曰:子类中所有 ...

  5. 面向对象编程(十)——继承之Super关键字及内存分析

    Super关键字

  6. JavaSE复习日记 : 继承关系和super关键字以及继承关系中方法的覆写

    /* * 类的继承和super关键字 * * 软件开发的三大目的: * 可拓展性; * 可维护性; * 可重用性; * * 这里单说下可重用性这一项: * 为了代码复用,复用方式有: * 函数的调用复 ...

  7. java学习笔记-继承中super关键字

    背景: 在java继承的概念中我们得知,被声明为私有的类成员对所属的类来说仍然是私有的.类之外的任何代码都不能访问,包括子类. super关键字的两种用法: 1.用于调用超类的构造函数: 2.用于访问 ...

  8. 24 类:组合 继承 super关键字 面向对象的三大性

    组合 组合:自定义类的对象作为另外一个类的属性 class Teacher: def __init__(self, name, age): self.name = name self.age = ag ...

  9. java学习笔记(八):继承、extends、super、this、final关键字

    继承解决代码重用的问题,方便管理和维护代码. 继承 子类拥有父类非private的属性,方法. 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展. 子类可以用自己的方式实现父类的方法. Java ...

随机推荐

  1. Bootstrap 我的学习记录4 轮播图的使用和理解

    <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="utf-8& ...

  2. 关于js中两种定时器的设置及清除

    1.JS中的定时器有两种: window.setTimeout([function],[interval]) 设置一个定时器,并且设定了一个等待的时间[interval],当到达时间后,执行对应的方法 ...

  3. 数位类统计问题--数位DP

    有一类与数位有关的区间统计问题.这类问题往往具有比较浓厚的数学味道,无法暴力求解,需要在数位上进行递推等操作.这类问题往往需要一些预处理,这就用到了数位DP. 本文地址:http://www.cnbl ...

  4. 【原】结构体包含CString类型成员变量出错的原理

    问题如下:我定义了如下的一个结构体: typedef struct{   CString csText;}MyStruct; 并有如下的程序段1:MyStruct * p=NULL;p=(MyStru ...

  5. iOS label根据显示内容自适应大小

    - (void)setupLabel { //准备工作 UILabel *textLabel = [[UILabel alloc] init]; textLabel.font = [UIFont sy ...

  6. Java 之 内部类

    (static修饰的成员属于整个类,而不属于单个对象) 定义:将一个类放到另一个类的内部定义,这个在内部定义的类就叫做内部类(也有的成嵌套类),包含内部类的类被称为外部类(也有的称宿主类). 1.非静 ...

  7. INFORMATICA 的调优之 INFORMATICA SERVER TUNING

    INFORMATICA SERVER的调优我认为主要从两个级别来做,一个是MAPPING级别,一个是SESSION级别. 对于MAPPING级别的调优: 一  对MAPPING数据流向的优化: 1 控 ...

  8. 标准sql语句,学习

    标准SQL语句总结标准SQL语句总结,标准SQL语言基本上适用于下面所列出的数据库软件 -------------------------------------------------------- ...

  9. 读书笔记——Windows环境下32位汇编语言程序设计(9)ANSII字符大小写转大写

    在罗云彬的<Windows环境下32位汇编语言程序设计>中第321页 ... .const szAllowedChar db '0123456789ABCDEFabcdef',08h .. ...

  10. 仅IE6中链接A的href为javascript协议时不能在当前页面跳转

    切页面时有时用链接A来替代按钮,这样做有几个好处 鼠标放上时默认有手状效果(不用添加cursor:pointer) 可以添加低版本IE都支持的伪类 如果点击时页面要整体刷新,即跳转,这时IE6则不尽人 ...