Java程序设计第6章继承与多态

合集下载

Java-第06章-继承和多态8.30

public class Magnician { private String name;//角色名称 private int level;//角色等级 private int blood;//角色血量 public void fight() { System.out.println("魔法攻击"); }
public void fight() { System.out.println("挥剑攻击"); } public int getBlood(){ return blood; } public void setBlood(int blood){ this.blood=blood; } public int getLevel(){ return level; } public void setLevel(int level){ this.level=level; } public String getName(){ return name; } public void setName(String name){ =name; } }
public class SwordMan extends Role{
public String toString(){ return String.format("剑士(%s,%d,%d)", , this.level,this.blood);
public static void main(String[] args) {
注意：父类的private成员会被继承，只是子类无法直接存取，必须通过父类提供的方法来存取。
6.1.2 多态与is-a Java继承的特点：子类只能继承一个父类。子类和父类是is-a关系。Swordman is a Role,Magicial is a Role。这是理解多态的基础

Java语言06(继承和多态)

方法的覆盖
1.
子类方法对父类同名方法的覆盖将清除父类方法占用的内存空间，从而使父类方法在子类对象中不复存在。方法覆盖中需要注意：子类在重新定义父类已有的方法时，应保持与父类完全相同的方法头声明，即应与父类有完全相同的方法名、返回值和参数列表。
2.
public class MethodOverride{ MethodOverride{ public static void main(String [] args) { args) SubClass s=new SubClass(); SubClass(); s.fun(); }} class SuperClass{ SuperClass{ int i=1; public void fun() { System.out.println("Super"); System.out.println("Super"); System.out.println("父类的i "+i System.out.println("父类的i＝"+i); }} class SubClass extends SuperClass{ SuperClass{ int i=2; public void fun() { System.out.println("Sub"); System.out.println("Sub"); System.out.println("子类的i="+i System.out.println("子类的i="+i); System.out.println("父类的i="+super.i); System.out.println("父类的i="+super.i); }}

Java编程基础及应用(第2版)教学课件第6章类的继承与多态性

6.1.1 引言
下图为一个继承的实例：
6.1.2 继承的概念
• 继承是从巳有的类中派生出新的类，新的类拥有已有类的数据属性和行为，并能扩展新的数据属性和行为。换句话说，继承就是在已经存在的类的基础上再扩展新的类。
• 已经存在的类称为父类、超类或者基类。新产生的类称为子类或派生类。子类拥有父类的所有特性。当然，也可以在子类中添加新的方法和成员变量，这些新添加的方法和成员支量仅仅属于子类。
• 继承分为单继承和多继承。单继承是指一个子类最多只能有一个父类。多继承是指一个子类可以有两人以上的父类。由于多继承会带来二义性，在实际应用中应尽量使用单继承。
6.1.3 继承的实现
■关键字(extends)
继承通过关键字extends实现。如果使用默认的extends子句，则该
类为ng.Object的子类。子类可以继承父类中访问权限为public、
■继承的特点： (1) 提供多继承机制。从理论上说，一个类可以是多个一般类的子类，它
可以从密个一般类中继承属性与方法，这便是多继承。Java出于安全性和可靠性的考虑，仅支持单继承，而使用接口机制来实现多继承。
(2) 继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。
6.1.5 继承的特点与优点
Child c = new Child(); System.out.println(c.add(4，"3")); }
6.2.2 方法覆盖和重载
■方法重载：是指在同一个类中，定义多个名称相同，但参数个数或类型不同的方法，程序中的对象根据参数的个数或者类型，调用相对应的方法。
■例:StudentOverload类定义构造函数和get()方法，并重载了这两个方法，sol、so2对象根据这两个方法的参数个数或类型调用相应的方法。

Java基础课程06-第六章继承和多态

• 生活中，继承的例子随处可见
动物谁是父类？谁是子类？能说出继承的特点吗？
食草动物
食肉动物
继承需要符合的关系：is-a，父类更通用、子类更具体
5
生活中的继承
• 子类具有父类的一般特性（包括属性和行为），以及自身特殊的特性
巴士是汽车吗？卡车是汽车吗？出租车是汽车吗？
汽车引擎数量外观颜色刹车加速属性行为
第21页
多态
Java语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进
行类型转换 Animal animal = new Dog(); Dog dog = (Dog)animal; //向下转型，把Animal类型转化为Dog类型 Creature creature = animal; //向上转型，把Animal类型转化为Creature类型如果把引用变量转换为子类类型，称为向下转型，如果把引用变量转换为父类类型，称为向上转型。在进行引用变量的类型转换时，会受到各种限制。而且在通过引用变量访问它所引用的实例的静态属性、静态方法 Animal
访问用static 修饰的成员方法表示静态方法，可以直接通过类名来访问用static修饰的程序代码块表示静态代码块，当java虚拟机加载类时，就会执行该代码块
final关键字
• 修饰类 – 不能被继承 • 修饰方法 – 不能被子类重写
• 修饰变量
– 只能在赋值或构造函数中赋值，后期不能进行修改 • 修饰方法参数 – 如果方法参数是基本类型，那方法中不能修改该值 – 如果方法参数是引用类型，那方法中不能修改该对象的地址
由于giveLesson()方法与父类的实现有所不同，因此重写了该方法
12

JAVA课程第六章继承和多态

单位地址:广州市工业大道1001号
任务6-4：子类与父类方法同名
public class Student{ String name;//姓名 int No;//学号 String Info(){ return "姓名："+name+"\t学号："+No; } }
public class onJobStudent extends Student{ String title ;//职称 String company;//所在单位 String Info(){ return "姓名："+name+" \t学号："+No + "\n职称:"+title+"\t单位:"+company; } }
姓名：张三职称:工程师学号：20081002 单位:广州宝杰公司
任务6-3
Student类 name no address
任务6-4
Student类 name no Info()
继承
onJobStudent类 name no address //重新定义
继承
onJobStudent类 name no
继承
circle类 x 继承 y radius double area（）在test类的Main函数中 double perimeter（）生成两个点
一个圆一个圆柱
public class Student{ 任务6-3:子类与父类变量同名 String name;//姓名 int No;//学号 String address="广州精英学院";//学校地址 String Info(){ return "姓名："+name+" 学号："+No; } } //子类对父类同名变量的覆盖 public class onJobStudent extends Student { String company;//工作单位 String title; //职称 String address="广州工业大道1001号";// 单位地址 void printAddress() { System.out.println("单位地址:" + address); } }

java继承与多态

java继承与多态继承继承：可以让⼦类继承⽗类，这样⼦类会继承⽗类所有的属性和⽅法。

然⽽在Java中是不允许有多继承的，即⼀个⼦类只能继承⼀个⽗类，不能同时继承多个⽗类。

如果⼀个类还需要另外⼀个类的⽅法，可以让⽗类去继承需要的类。

但Java中⽀持多重继承，即⼀个⼦类也可以做为其他类的⽗类。

Object类：是Java中的祖宗类，当⼀个类在代码层⾯没有去继承任何的⽗类，那这个类默认会继承object类。

继承的重写（覆盖）：⼦类继承⽗类以后，可以获取到⽗类的所有⽅法（包含被private修饰的⽅法，只是访问不到），如果⽗类的⽅法功能不能满⾜⼦类的需求，那么⼦类可以根据需求对这个⽅法进⾏重写。

Super关键字：⼦类继承⽗类后，⼦类可以通过super关键字去指向⽗类的元素（属性，构造⽅法，普通⽅法）。

如果是指向⽗类的构造⽅法：super()如果是指向⼦类的构造⽅法：this()注：像super(),this()这样的表达式只能存在于构造⽅法中，且只能出现⼀次。

如果是指向⽗类的普通⽅法：super.⽅法名称()如果是指向⽗类的属性：super.属性名称()构造⽅法的继承：在继承时，当⼦类⽤到默认的⽆参构造⽅法时，⽗类必须要有⽆参构造⽅法，不然⼦类的构造⽅法就会报错。

因为⼦类继承⽗类之后，获取到了⽗类的内容（属性/字段），⽽这些内容在使⽤之前必须先初始化，⼦类如果在没有⾃定义构造⽅法的情况下默认会有⼀个⽆参构造⽅法，其中第⼀⾏默认会有⼀个super()，所以必须先调⽤⽗类的构造函数进⾏内容的初始化。

所以⽗类必须要有⼀个⽆参构造⽅法。

⼦类直接继承得到的属性⽆法直接获取，可以通过⽗类的get和set⽅法来获取和修改属性。

public class Animal {private String name;private int age;private String hobby;public Animal(){}public Animal(String name, int age, String hobby) { = name;this.age = age;this.hobby = hobby;}}public class Dog extends Animal {public Dog(String name, int age, String hobby) {super(name, age, hobby);}}⽅法重写与⽅法重载的区别：⽅法重写override：⽅法重写是指⼦类在继承了⽗类之后需要对⽗类的⼀些⽅法进⾏修改，以适应程序需求，因此在⼦类中重写⽗类中原有的⽅法。

java 第六章继承与多态

6.2.4方法参数和异类集合
1 方法的参数为了处理的一般性，实例和变量并不总是属于同一类
public TaxRate findTaxRate(Employee e) { // 进行计算并返回e的税率 findTaxRate() 的自变量必须是 Employee 类型 } 的，而调用时的参数是 // 而在应用程序类中可以写下面的语句 Manager 类型的，但因为 Manager 是一个 Manager m = new Manager(); Employee，所以可以使用更“一般”的变量类型 TaxRate t = findTaxRate(m); 来调用这个方法。
Object Employee
Manager
Contractor
instanceof运算符类的变量既可以指向本类实例，又可以指向其子类的实例。可以通过instanceof运算符判明一个引用到底指向哪个实例
public void method(Employee e) { if (e instanceof Manager) { // 经理级人士 } else if (e instanceof Contractor){ // 掌握公司机密的高层人士 } else { // 普通雇员 } }
extends关键字
public class A extends B
public class Employee { public class Manager extends Employee{ private String name; private String department; private Employee [] subordinates; private Date hireDate; ... private Date dateOfBirth; } private String jobTitle; private int grade; } Words.java

Java第6讲继承与多态

}
}
类的继承和派生
定义一个Fish类
鱼本身也是动物,它也有吃、睡觉、呼吸行为，希望它从动物类继承状态和行为。
class { } Fish extends Animal
替换（向上转型）
二、替换
考察父类的类型与子类的类型之间关系，发现：子类实例必须拥有父类的所有数据成员。子类实例必须至少通过继承，实现父类所定义的所有功能。这样，在某种条件下，如果用子类实例替换父类实例将会发现子类实例可以完全模拟父类的行为。
继承图
被继承数据（private）被继承数据 (public和protected)
基类A
从基类继承数据 (除private在B中不可见,其它都可见) 自己新增加部分
派生类B
类的继承访问特性
基类中的private成员在派生类中都是不可见的，即该派生类的方法成员不能直接访问基类中的私有成员。
public class A { private int m_a; public int m_b; protected int m_c; public A() { m_a=3; m_b=4; m_c=5; } public int getA() { return m_a; } } public class B extends A { public void showData() { //error System.out.println(m_a); //ok System.out.println(m_b); System.out.println(m_c); //ok System.out.println(GetA()); } }
class { Fish extends Animal public void breathe() { System.out.println(“fish bubble”); } }

java的封装,继承和多态(思维导图)

java的封装，继承和多态类和对象类类声明 { 成员变量的声明；成员方法的声明及实现； }声明类：[修饰符] class 类<泛型> [extends 父类] [implements 接口列表]声明成员变量：[修饰符]数据类型变量[=表达式]{,变量[=表达式]}成员方法声明：[修饰符]返回值类型方法（[形式参数列表]）[throws 异常类列表]{语句序列；[return[返回值]]； }重载：一个类中可以有多个同名的成员方法，前提是参数列表不同，称为类的成员方法重载，重载的多个方法为一种功能提供多种实现。

重载方法之间必须以不同的参数列表（数据类型、参数个数、参数次序）来区别。

例如，MyDate 类可声明多个重载的set()方法如下: void set(int y,int m, int d)void set(int m, int d) //重载方法，参数个数不同void set(int d) void set(MyDate date)//重载方法，参数的数据类型不同对象对象声明：类对象构造实例：对象 = new 类的构造方法（[实际参数列表]）引用对象的成员变量和调用成员方法：对象.成员变量对象.成员方法([实际参数列表])类的封装性构造与析构类的构造方法用于创建类的一个实例并对实例的成员变量进行初始化一个类可声明多个构造方法对成员变量进行不同需求的初始化，构造方法不需要写返回值类型，因为它返回的就是该类的一个实例。

例：MyDate类声明以下构造方法:public MyDate(int year, int month, int day)// 声明构造方法，方法名同类名，初始化成员变量 {set(year, month day);// 调用 set()方法，为成员变量赋值}使用new运算符调用指定类的构造方法，实际参数列表必须符合构造方法声明。

例如:MyDate d1 = new MyDate(2017,10,1);//创建实例并初始化成员变量当一个类没有声明构造方法时，Java 自动为该类提供一个无参数的默认构造方法对象的引用与运算this引用访问本类的成员变量和成员方法：this.成员变量，this.成员方法([实际参数列表])调用本类重载的构造方法：this([实际参数列表])访问控制类的访问控制权限公有和(public)和缺省类中成员4级访问控制权限及范围声明set()和get()方法存取对象的属性例：public void set(int year, int month, int day) //设置日期值 public void set(MyDate date)//设置日期值，重载 public int getYear()//获得年份 public int getMonth()// 获得月份 public int getDay()//获得当月日期静态成员定义及访问格式使用关键字static声明的成员称为静态成员在类内部，可直接访问静态成员，省略类名。

第6章继承和多态

6.4 类之间的关系
类之间最常见的关系主要有以下3种：（1）依赖（或“uses-a”）；（2）聚合（或“has-a”）；（3）继承（或“is-a”）。

6.4.1 依赖依赖关系是类中最常见也是最一般的关系。例如我们的订单类（Order）需要访问用户的账户类（Account）对象，并查看用户的信用度。所以在Order类中需要引用 Account类，但图书类（Book）并不需要 Account类，因为Book类并不需要去关心 Accout类。像这样，我们就可以说Order类依赖Account类，如果我们修改了Accout类，则会影响到Order类。所以依赖的实质是：一个类中的方法操作了另外一个类的实例。
} class B extends A { public B() { System.out.println("this is B"); } } class C extends B { public C(String str) { System.out.println("this is C"); } }

6.4.4 类记号与类图
如果读者查阅有关UML（Unified Modeling Language）的资料，经常可以看到用一些不同形状的箭头来表示类之间的关系，这些图被称为类图（class diagram）。
6.5 继承层次图
在类的继承中，还可以实现多层继承。例如，在 Student类中派生出一个学生会类，在学生会类中再派生出一个学生会主席（Chair）类。一个父类及所有派生出来的类的集合就组成了一个继承层次图。
6.7 防止类的继承
尽管类的继承对于我们设计类提供了很大的方便，但在某些特殊的场合，我们并不希望自己的类再被扩展，也就是说不希望再产生子类，那么有什么办法可以防止类的继承呢？在第10章学习字符串（String）类时，我们将提到过final关键字，如果一个类的声明中有final关键字，那么这个类就不可能再被扩展，继承也就不存在了。例如不再希望学生会主席类再被扩展，我们可以如下声明该类： final class Chair extends ClassManage { …… }

JAVA继承与多态

9
2024年4月3日星期三
Java程序设计
10
2024年4月3日星期三
Java程序设计
// file name：ShapeClass.java
import java.util.*;
public class ShapeClass {
// 几何图元类
private ColorClass color;
4
2024年4月3日星期三
Java程序设计 EmployeeClass类与ManagerClass类的关系图
5
2024年4月3日星期三
Java程序设计
// file name：EmployeeClass.java
public class EmployeeClass {
// 雇员类
private String name;
}
}
11
2024年4月3日星期三
Java程序设计
// file name：RectangleClass.java
public class RectangleClass extends ShapeClass { // 矩形类
private int length;
// 长
private int width;
// 颜色属性
private Point place; // 位置属性
public ShapeClass() {
color = new ColorClass();
place = new Point();
}
public ShapeClass(ColorClass color, Point place){
}
12
2024年4月3日星期三

第06讲继承、多态

6
继承、多态
2012-12-11
方法重写（Porsche2.java ）
• 子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为。 Porsche2重写了Car中的accelerate 、 decelerate 方法，其将会覆盖Car中相同签名方法
•
继承、多态
• 但可以访问超类中声明被子类覆盖(重写)的方法！
myCar. accelerate () ;
//提问？ myCar. accelerate()执行的哪个方法？为什么
继承、多态
13
2012-12-11
动态绑定
•
•
java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。其中有这样的两个原则： 1、访问一个引用类型的变量的非静态方法，运行时与实际引用的对象的方法绑定； 2、访问一个引用类型的变量的成员变量，运行时与声明的类的成员变量绑定； (?) 其原因，对于成员变量，只有隐藏一说，并不能重载/改写，而对于方法，才有改写一说。
11
2012-12-11
面向对象的特性—多态
• • 子类的对象可以替代父类的对象使用一个超类变量可以实际引用不同子类的对象 Car myCar; myCar=new Porsche2();
继承、多态
12
2012-12-11
多态
• 引用子类对象的超类变量不能再访问子类中添加的属性和方法
Car myCar=new Porsche2(); myCar. engageTurbos() ;//Error

JAVA程序设计第6章 JAVA的继承和多态.jsp

package mylsf; class Point { int x,y; void print() {System.out.println("x="+x+" y="+y);} } class P_1 { public static void main(String args[]) { Point p1=new Point(); p1.x=2;p1.y=3; p1.print(); } }
// 创建私有方法,在构造方法中引用方法,私有变量的引用权限创建私有方法,在构造方法中引用方法, class Scope7_4{ private int x=10; Scope7_4( ) { x=1000;} private void a( ) { int x=200; x*=4; System.out.println("A of a method is "+x); } private void b( ) { x*=2; System.out.println("B of a method is "+x); } } public class Samp7_4 { public static void main(String args[] ) { int x=100; System.out.println("x of main method is "+x); Scope7_4 b1=new Scope7_4( ); b1.a( );//调用私有方法出错调用私有方法出错 b1.b( );//调用私有方法出错调用私有方法出错 System.out.println("x of main method is "+x); } }

第6章 Java的继承与多态

其他方法
hashCode()：计算一个对象的哈希码， hashCode()：计算一个对象的哈希码，并将其返回。返回。 notify()：唤醒一个与当前对象关联的线程。 notify()：唤醒一个与当前对象关联的线程。 notifyAll()： notifyAll()：唤醒与当前对象关联的所有线程 wait()： wait()：使线程等待一个指定的时间间隔或等待另一个线程调用当前对象的notify()或另一个线程调用当前对象的notify()或 notifyAll()方法 notifyAll()方法。方法。
class A {} public class Ex6_7{ public static void main(String args[]) { A a=new A(1); Class ca=a.getClass(); System.out.println(“ System.out.println(“class of obj=”+ca); obj=” }
面向对象程序设计三大特性
继承，以既有类为基础，派生出新类，达继承，以既有类为基础，派生出新类，到代码重用的目的。到代码重用的目的。封装，对类对象的数据成员进行访问控制，封装，对类对象的数据成员进行访问控制，起到数据保护作用。起到数据保护作用。多态，程序能够动态的匹配同名方法，多态，程序能够动态的匹配同名方法，使程序更加灵活。程序更加灵活。
习题1——4 习题1——4讲解习题5 习题5
class A { String str1="Hello!\t"; str1="Hello!\ String str2="How are you"; public String toString() { return str1+str2; } } class B extends A { String str1="\b\b,Bill."; str1="\ public String toString() { return super.str1+str1; } } public class Ex6_5 { public static void main(String args[]) { A a=new A(); System.out.println(a.toString()); B b=new B(); System.out.println(b.toString()); } }

JAVA继承与多态

JAVA继承与多态第⼀节、继承⼀、继承的概念、格式、特点（⼀）继承的概念：1、继承是多态的前提，如果没有继承，就没有多态。

2、继承解决的主要问题是：共性抽取。

3、⾯向对象的三⼤特征：封装性、继承性、多态性。

（⼆）继承的格式⽗类的格式：（即普通类）public class ⽗类名称 {// ...}⼦类的格式：public class ⼦类名称 extends ⽗类名称 {// ...}（三）继承的三个特点(单继承、多层继承、相对继承)1、Java只⽀持单继承，不⽀持多继承。

2、Java⽀持多层继承(继承体系)。

3、⼦类和⽗类是⼀种相对的概念。

⼆、继承中的变量（⼀）成员变量的访问(直接、间接)在⽗⼦类的继承关系当中，如果成员变量重名，则创建⼦类对象时，访问有两种⽅式：1、直接通过⼦类对象访问成员变量：等号【左边】是谁，就优先⽤谁，没有则向上找。

2、间接通过成员⽅法访问成员变量：该⽅法【属于】谁，就优先⽤谁，没有则向上找。

（⼆）⼦类⽅法中重名的三种变量区分(局部、本成、⽗成)1、局部变量：直接写局员变量名2、本类的成员变量： this.成员变量名3、⽗类的成员变量： super.成员变量名三、继承中的⽅法（⼀）成员⽅法-覆盖重写1、访问：在⽗⼦类的继承关系当中，创建⼦类对象，访问成员⽅法的规则：创建的对象是谁，就优先⽤谁，如果没有则向上找。

注意事项：⽆论是成员⽅法还是成员变量，如果没有都是向上找⽗类，绝对不会向下找⼦类的。

重写（Override）：⽅法的名称⼀样，参数列表【也⼀样】。

覆盖、覆写。

重载（Overload）：⽅法的名称⼀样，参数列表【不⼀样】。

2、重写（Override）概念：重写要求两同两⼩⼀⼤原则：⽅法名相同，参数类型相同，⼦类返回类型⼩于等于⽗类⽅法返回类型，⼦类抛出异常⼩于等于⽗类⽅法抛出异常，⼦类访问权限⼤于等于⽗类⽅法访问权限。

（1）必须保证⽗⼦类之间⽅法的名称相同，参数列表也相同。

《Java程序设计基础》第6章：继承与多态

注意：

父类中的某个属性值发生了改变，子类中的属性值仍保持自己的状态，因为它们是两块不同的存储空间。如果父类中该属性的定义发生了变化，子类中该属性的类型定义也就跟着发生了变化。
属性的覆盖

指子类可以重新定义父类的非私有属性。在使用时通过调用该属性的变量或者方法来决定使用哪一个。用关键字super来实现父类属性的直接应用。
例6.1 方法的重载

程序代码
例子中用到两个构造函数：Tree()和Tree(int i),输出方法info()和info(String s)都是重载的方法。

重载的方法有同样的名字，Java怎样知道我们指的是哪一个方法呢？
简单的规则：每个重载的方法都必须采取独一无二的形参列表，即形参的个数、类型以及它们的顺序。

方法的重载与覆盖的区别：

方法的覆盖是子类和父类间的关系，而方法的重载是同一类内部多个方法间的关系。方法的覆盖一般是两个方法间的，而重载时可能有多个重载方法。覆盖的方法有相同的方法名和形参表，而重载的方法只能有相同的方法名，不能有相同的形参表。覆盖时区分方法的是根据调用它的对象，而重载是根据形参表来决定调用的是哪个方法。
6.1.2 多态的概念
多态是指在一棵继承树中的类中可以有多个同名但不同方法体以及不同形参的方法。
多态有两种情况：覆盖和重载

覆盖是在子类中直接定义和父类同样的属性和方法，但重新编写了方法体，即子类与父类方法的形参与返回值都相同，而内部处理不同，这种方法在使用过程中，Java虚拟机会根据调用这个方法的类来确定哪个方法被调用。重载是指同一个类定义中有多个同名的方法，但有不同形参，而且每个方法有不同的方法体，调用时根据形参的个数和类型来决定调用的是哪个方法。

Java程序设计案例教程第2版第6章继承和多态

❖ 提高程序扩展性，复用基类的代码，从而提高编程效率 ❖ Java语言只支持单继承，即每个子类只有一个基类
Java程序设计案例教程
幻灯片 4，共38页
4
6.1.2 继承的实现
❖ 声明子类使用extends关键字
▪ 它的含义是扩展基类，即继承基类。
[类修饰符] class 类名 [extends 基类] { [成员变量声明] [getters和setters方法] [构造方法定义] [成员方法定义]
}
}
Java程序设计案例教程
幻灯片 9，共32页
9
成员变量的隐藏
❖ 属性隐藏时
▪ 当子类执行继承自父类的方法时，处理的是继承自父类的变量 ▪ 当子类执行自己定义的方法时，处理的是子类自己定义的变量 ▪ 若在第二种情况，仍希望调用父类的属性，需要使用super关键字
Java程序设计案例教程
幻灯片 10，共38页
}
} public class Student extends Person {
String address = "高浪西路1600";
public class Test { public static void main(String[] args) { Student s = new Student();
▪ 在子类中基类的成员变量被隐藏。 ▪ 子类仍然继承了基类的成员变量，只是将其名字隐藏
public class Person {
String name = "程艳";
String address = "中南路8号";
public void showDetail() {
System.out.println("name=" + name + ",address=" + address);

Java程序设计第6章 继承与多态

Java-第06章-继承和多态8.30

Java语言06(继承和多态)

Java编程基础及应用(第2版)教学课件第6章 类的继承与多态性

Java基础课程06-第六章 继承和多态

JAVA课程第六章 继承和多态

java继承与多态

java 第六章 继承与多态

Java第6讲 继承与多态

java的封装,继承和多态(思维导图)

第6章 继承和多态

JAVA继承与多态

第06讲 继承、多态

JAVA程序设计 第6章 JAVA的继承和多态.jsp

第6章 Java的继承与多态

JAVA继承与多态

《Java程序设计基础》第6章：继承与多态

Java程序设计案例教程 第2版 第6章 继承和多态

Java程序设计第6章继承与多态

Java编程基础及应用(第2版)教学课件第6章类的继承与多态性

Java基础课程06-第六章继承和多态

JAVA课程第六章继承和多态

java 第六章继承与多态

Java第6讲继承与多态

第6章继承和多态

第06讲继承、多态

JAVA程序设计第6章 JAVA的继承和多态.jsp

Java程序设计案例教程第2版第6章继承和多态