付费节点推荐

免费节点

节点使用教程

[t]第5章 子类与继承[/t]

[t]5.1 子类与父类[/t]

1)继承是一种由已有的类创建新类的机制。

2)Java不支持多重继承，即子类只能有一个父类。

[t]5.1.1 声明子类[/t]

例如：

class Student extends People{
.....
}
把Student类定义为People的子类。

[t]5.1.2 类的树形结构[/t]

如果c是b的子类，b又是a的子类，习惯上称c是a的子孙类。Java的类

按照继承关系形成树形结构，在这个树形结构中根节点是Object类（Object
类是java.lang包中的类），即Object类是所有类的祖先类。如果一个类的声
明中没有使用extends关键字，这个类被系统默认认为是Object的子类。

[t]5.2 子类的继承性[/t]
[t]5.2.1 子类和父类在同一包中的继承性[/t]
如果子类和父类在同一包中，那么子类自然地继承了父类中不是
private的成员变量和方法。

[t]5.2.2 子类和父类不在同一包中的继承性[/t]
子类和父类不在同一包中时，父类中的private和友好访问权限的成员变量
不会被子类继承。子类只继承父类中的protected和public访问权限的成员变量

[t]5.2.3 继承关系的UML图[/t]
。。。
[t]5.2.4 protected的进一步说明[/t]
[t]5.3 子类与对象[/t]
[t]5.3.1 子类对象的特点[/t]
1）.当子类的构造方法创建一个子类的对象时，不仅子类中声明的成员变量被分配了
内存，而且父类的成员变量也都被分配了内存空间。但只将子类继承的那部分成员变
量作为分配给子类对象的变量。即子类不继承父类的私有成员变量。
2）.如果子类和父类不在同一包中，尽管父类的友好成员变量分配了内存空间，但也
不作为子类对象的变量，即如果子类和父类不在同一包中，子类不继承父类的友好成员变
量。
[t]5.3.2 关于instanceof运算符[/t]
[t]5.4 成员变量的隐藏和方法重写[/t]
[t]5.4.1 成员变量的隐藏[/t]
子类声明的成员变量和从父类继承来的成员变量名字相同，子类就会隐藏
所继承的成员变量。
子类继承的方法只能操作子类继承和隐藏的成员变量，子类新定义的方法
可以操作子类继承和子类新声明的成员变量，但无法操作子类隐藏的成员变量（需
使用super关键字操作隐藏的成员变量。）

[t]5.4.2 方法重写(Overwride)[/t]

1）子类通过重写可以隐藏已继承的方法。

2）重写规则：子类继承了父类的某个方法，子类就有权重写这个方法，是指子类中定义了一个方法，这个歌方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型。

3）重写目的： 子类通过方法重写可以隐藏继承的方法，子类通过方法重写可以把父类的状态和行为改变为自身的状态和行为。

4）重写方法既可以操作继承的成员变量、调用继承的方法，也可以操作子类新声明的成员变量，和子类新定义的其他方法，但无法操作被子类隐藏的成员变量和方法。必须使用super关键字。

[t]5.5 super关键字[/t]

[t]5.5.1 用super操作被隐藏的成员变量和方法[/t]

1）子类一旦隐藏了继承的成员变量和方法，那么子类创建的对象就无法拥有该变量和方法，需使用super关键字。

例子：

class Sum{ int n;

for(int i=1;i<=n;i++) sum=sum+i; return sum; } } class Average extends Sum { int n; flaot f(){ flaot c; super.n=n; c=super.f(); return c/n; } }
[t]5.5.2 使用super调用父类的构造方法[/t]

1)当用子类的构造方法创建一个子类的对象时，子类的构造方法总是先调用父类的某个构造方法，也就是说，如果子类的构造方法没有明显指明使用父类的那个构造方法，子类就调用父类的不带参数的构造方法。

2）由于子类不继承父类的构造方法，因此，子类在其构造方法中需使用super关键字来调用父类的构造方法，而且super必须是子类构造方法中头一条语句，即如果在子类的构造方法中，没有明显的写出super关键字来调用父类的某个构造方法，那么默认有：super();

package com.Super;
class Student {
int number;
String name;
Student(){
}
Student(int number,String name)
{
this.number=number;
this.name=name;
System.out.println("我的名字是:"+name+ "学号是:"+number);
}

public class example_super {
public static void main(String args[]){
UniverStudent zhang=new UniverStudent(9901, "猪八戒",false);
}
}
 

[t]5.6 final类[/t]
[t]5.6.1 final类[/t]
可以使用final关键字将类声明为final类。final类不能被继承
final class A{
....
}

[t]5.6.2 final方法[/t]
使用final声明的方法不能被子类重写。
[t]5.6.3 final常量[/t]
使用final声明的变量为常量。
[t]5.7 对象的上转型对象[/t]

假如Animal类是Tiger的父类，当用子类创建了一个对象，并把这个对象的引用放到父类的对象中时，比如：
Animal a;
a=new Tiger();
或
Animal a;
Tiger b=new Tiger();
a=b;

这时，称对象a是对象b的上转型对象。

对象的上转型对象的实体是子类负责创建的，但上转型对象会失去一些属性和功能(上转型对象相当于子类对象的一个"简化"对象)。

1）上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。

2）上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法。上转型对

操作子类继承的方法和子类重写的实例方法，其作用等价于子类对象去调用这些方法。因此，如果子类重写了父类的

个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用了子类重写的实例方法。

3）如果子类重写了父类的静态方法，那么子类对象的上转型对象不能调用子类重写的静态方法，只能调用父类的静态方法。
[t]5.8 继承与多态[/t]

多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能和行为。

[t]5.9 abstract类和abstract方法[/t]

1）用关键字修饰的类或者方法被称为abstract类或abstract方法。

2）abstract方法：

* 对于abstract方法，只允许声明，不允许实现，而且不能使用final，和abstract同时修饰一个方法或类，也不能使用static修饰abstract方法。即abstract方法必须是实例方法。

3）abstract类中可以有abstract方法

* abstract类中可以有abstract方法，也可以有非abstract方法，但非abstract类不可以有abstract方法。

例如：

abstract class A{
abstract int min(int x,int y);

{
return x>y?x:y;
}
}

4)abstract 类不能有new运算符创建对象

* 如果一个非抽象类是某个抽象类的子类，那么它必须“重写”父类的抽象方法，给出方法体，所以不允许同时使用final和abstract同时修饰一个方法或者类的原因。

5）abstract类的对象作上转型对象

abstract类不能使用new运算符创建对象，但是该对象可以成为子类对象的上转型对象，这样就可以调用子类重写的方法。
[t]5.10 面向抽象编程[/t]

1）使用多态进行程序设计的核心技术之一是使用上转型对象，即将abstract类声明的对象作为其子类对象的上转型对象，那么这个上转型对象就可以调用子类重写方法。

2）所谓面向抽象编程，是指当设计某种重要的的类时，不让该类面向具体的类，而是面向抽象类，即所设计类中的充要数据是抽象类声明的对象，而不是具体类声明的对象。

未经允许不得转载：Bcoder资源网 » 【jAVA基础知识】第5章 子类与继承

相关推荐