高级程序设计语言(Java版)5 Java高级特性.pptx

1、第5章 高级特性,目录,5.1 类的封装 5.2 类的继承 5.3 类的多态 5.4 综合实例 5.5 习题,5.1 类的封装,5.1.1 封装的基本概念 隐藏的过程就是封装。封装性把对象的属性和行为结合成一个独立单位类，并且要尽可能多尽可能好的隐藏对象的内部细节，需要的只是提供外部接口（接口的概念在后续章节中会详细讲解）。封装性是类能够建立起严格的内部结构，对内部信息起到了保护作用，减少了外部的干扰和影响，有效保证了类自身的独立性。,Java语言中所提到的封装性包含两个方面的含义： 对象的全部属性和方法都结合在一起，形成一个不可分割的独立单位； 尽可能隐藏对象的内部结构；,【实例5-1】Em

2、ployee.java Public class Employee /private权限 private String name; private double salary; private static int count; /public权限 public String getName() return name; /public权限 Public void setName(String name) = name; ,5.1.2 封装的4种访问控制级别 public： 公共的，最高的访问级别，类的public成员所有类的成员都可以访问。 protected： 受保护的

3、，类的protected成员只能被该类的成员以及其子类成员访问。还可以被同一个包中其他类的成员访问。 private： 私有的，不对外公开，类的private成员只能被该类的成员访问，访问级别最低。 default： 类的成员什么修饰符都没有，又叫包修饰符，只有类本身成员和当前包下类的成员可以访问。,下面给出对比的表格以便更清晰的对比四种修饰符的使用环境,表5-1修饰符对比：,5.2 类的继承,在开始继承的学习之前，先看两个生活中的例子，如图5-1 动物的继承，图5-2汽车的继承：,图5-1 动物的继承,图5-2汽车的继承,5.2.1 继承的基本概念 继承，是对有着共同特性的多类事物，进行再抽

4、象成一个类。这个类就是多类事物的父类。父类的意义在于抽取多类事物的共性。Java中的继承要使用extends关键字，并且java中只允许单继承，也就是一个类只能有一个父类，是继承关系呈树状，体现了java的简单性。 Java语言继承的一般格式： class 子类名 extends 父类名 方法体； ,【实例5-2】 Extends.java /创建父类 class SUPER int i, j; void showij() System.out.println(i 和 j: + i + + j); class SUB extends SUPER int k; void showk() Syst

5、em.out.println(k: + k); void sum() System.out.println(i+j+k: + (i + j + k); ,class Extends public static void main(String args) SUPER superTest = new SUPER (); SUB subTest = new SUB (); System.out.println(superTest内容: ); superTest.showij(); System.out.println(); subTest.i = 1; subTest.j = 2; subTest

6、.k = 3; System.out.println(subTest内容: ); subTest.showij(); subTest.showk(); System.out.println(); System.out.println(i, j, k之和 :); subTest.sum(); ,运行结果： superTest内容: i 和 j: 0 0 subTest内容: i 和 j: 1 2 k: 3 i, j, k之和 : i+j+k: 6,5.2.2 父类和子类 父类代表的是共性，从一个父类继承的所有类都继承了这个父类的功能。在Java程序设计中，我们力图发现并且提取共性来构造父类。子类

7、继承了父类的功能，并根据具体需求来添加功能。当创建一个新类的时候，不用全部写出所有的属性和方法，只需要声明该类继承已定义过的父类的属性和方法，这个新类便叫做子类，每个子类也可以成为将来某个子类的父类。子类可以从父类中继承属性，也可以继承方法。,子类对父类的继承是Java语言中很常用，在这里总结子类继承父类的准则： 1)子类能够继承父类中public和protected的成员； 2)如果子类和父类在同一个包内，子类能够继承父类中没有访问控制的成员； 3)子类不能继承父类中private成员； 4)子类不能继承父类中的构造方法（但可以使用super关键字来调用，我们在后面5.2.5中会讲到）。 5

8、)子类不能继承父类隐藏的成员变量和覆盖的父类方法；,5.2.3 抽象类和抽象方法 抽象类就是用abstract关键字来修饰的一个类。抽象类必须被继承，但是不能被实例化。下面是创建抽象类的一般格式： abstract class 抽象类 方法体； 抽象方法是用abstract关键字来修饰的一个方法，抽象方法只能声明，不能实现。下面是创建抽象方法的一般格式： abstract 返回类型 抽象方法（参数）；,抽象类和抽象方法的使用准则： 1）抽象类不能被直接实例化，只有它的非抽象子类可以创建对象； 2）抽象类中不一定包含抽象方法，但包含抽象方法的类必定是抽象类； 3）抽象类中的抽象方法只是声明，不包

9、含方法体； 4）构造方法和类方法不能声明为抽象方法； 5）抽象类的子类必须给出抽象类中的抽象方法的具体实现，如果该子类也是抽象类，则不需要。,5.2.4 super的使用 【实例5-4】调用父类的构造方法： public class Employee private String name; private int age; private String salary; public Employee(String name, int age, String salary) = name; this.age = age; this.salary = salary; publ

10、ic Employee(String name, int age) this(name, age, null); public Employee(String name, String salary) this(name, 24, salary); public Employee(String name) this(name, 24); ,class Manager extends Employee private String Mname; public Manager(String name, String salary, String Mname) super(name, salary)

11、; this.Mname = Mname; public Manager(String name, String Mname) super(name); this.Mname = Mname; public Manager(String Mname) /报错 this.Mname = Mname; ,【实例5-5】调用父类中被隐藏的成员变量和覆盖的父类方法：Super.java class Animal int feather; Animal() System.out.println(第一个constructor); Animal(int feather) this. feather = fe

12、ather; System.out.println(第二个constructor); void eat() System.out.println(eat方法); void rest() System.out.println(rest方法); ,class Crab extends Animal String feather = 没有feather！; Crab() super(8); System.out.println(constructor); void rest () super.rest (); System.out.println(子类 rest方法); void getfeathe

13、r () System.out.println(super. feather); System.out.println(feather); ,public class Super public static void main(String args) Crab crab = new Crab(); crab.rest (); crab.getfeather (); 运行结果： 第二个constructor constructor rest方法 子类 rest方法 8 没有feather！,5.2.5 this的使用 this关键字代表的是本类中的对象。this关键字有一下三种用法： this

14、的第一种用法是给成员变量赋值。 this的第二种用法是调用本类中的其他构造方法，调用是要放在构造方法的第一行 this的第三种用法是在实例方法中使用（不能在类方法中使用）。,5.3 类的多态,图5-3员工实现多态,5.3.1 多态的基本概念 多态，就是一个对象变量可以指向多种实际类型的现象。在Java语言中有两种方式实现多态，即方法重载和方法覆盖。 多态的应用广泛，它可以使代码变得更通用，以适应需求的变化。也就是定义在父类中的方法，可以在子类中有不同的实现将其覆盖，在为父类型的对象变量赋值相应需要功能的子类的对象实例。,5.3.2 方法重载 在Java语言中，成员方法和构造方法都可以重载。方法

15、重载有如下特点： 子类与父类方法名称相同； 子类与父类方法的形参的个数或类型不同； 重载的方法可以返回值不同； 子类与父类方法的修饰符可以不相同。,【实例5-6】成员方法重载Polymorphic1.java： class Arithmetic public int Add(int x, int y) return x + y; /重载Add方法 public long Add(long x, long y) return x + y; /重载Add方法 public double Add(double x, double y) return x + y; ,public class Poly

16、morphic1 public static void main(String args) int a = 2; int b = 5; long c = 123451234; long d = 543215432; double e = 10e-6; double f = 10e-12; Arithmetic arithmetic = new Arithmetic(); int g = arithmetic.Add(a, b); long h = arithmetic.Add(c, d); double i = arithmetic.Add(e, f); System.out.println(

17、g); System.out.println(h); System.out.println(i); 运行结果： 7 666666666 1.0000010000000002E-5,5.3.3 方法覆盖 方法覆盖与方法重载最大的区别在于，方法覆盖子类中的一个方法与父类方法的声明部分完全相同。它具有如下特点： 子类方法的名称、参数必须和父类方法的名称、参数一致； 子类方法不能缩小父类方法的访问权限； 方法覆盖只存在于子类和父类之间（在同一个类中方法是重载）； 子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法； 父类的私有方法不能被子类覆盖； 父类的抽象方法能够被子类通过以

18、下两种方式覆盖：一是子类实现父类的抽象方法，二是子类重新声明父类的抽象方法； 父类的非抽象方法可以被覆盖为抽象方法；,【实例5-7】Polymorphic3.java： class Cover public void Display() System.out.println(Cover父类); class Cover1 extends Cover public void Display() System.out.println(Cover1子类覆盖Cover父类Display()方法); class Cover2 extends Cover public void Display() Syst

19、em.out.println(Cover2子类覆盖Cover父类Display()方法); ,public class Polymorphic3 public static void main(String args) Cover temp; Cover1 a = new Cover1(); Cover2 b = new Cover2(); temp = a; temp.Display(); temp = b; temp.Display(); 运行结果： Cover1子类覆盖Cover父类Display()方法 Cover2子类覆盖Cover父类Display()方法,5.4 综合实例,cla

20、ss Tree / 声明变量，树的属性 String object; int age; int state; / Tree类的构造方法 Tree() Tree(String object) / 注意this关键字的使用 this.object = object; / 成员方法 void position() System.out.println(object + position); void treestate(int state) if (state 0) System.out.println(健康); else System.out.println(需要保养); void treeage

21、(int age) System.out.println(树龄 + age); ,class Wutong extends Tree int state = 1; int age = 12; / 创建类的构造方法，使之能进行类方法的重载 Wutong() / 重载了类的方法，用来处理类对象的属性变量 Wutong(String object) super(object); void position() System.out.println(object + 法国引进); / state(state); ,class Baiyang extends Tree int state = 0; int age = 8; Baiyang() Baiyang(String object) super(object); void position() System.out.println(object + 意大利引进