Core Java (十一) Java 继承，类，超类和子类

Core Java (十一) Java 继承，类，超类和子类

标签： javaJavaJAVA

2013-01-22 17:08 1274人阅读 评论(0) 收藏 举报

 分类：

java（58） 读书笔记（46） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

继承关系

两个类之间存在三种关系：

  1. 依赖，uses-a，如果一个类的方法操纵另一个对象，我们就说一个类依赖于另一个类。
  2. 聚合（关联），has-a，一个对象包含另外一个对象，聚合关系意味着类A的对象包含类B的对象。
  3. 继承，is-a，如果两个类之间存在明显的is-a（是）关系，例如每个经理都是雇员，那这两个类有继承关系。

例如：

[java] view plaincopy

  1. class Manager extends Employee{
  2. ......
  3. }

Manager继承了Employee类，继承可以重写超类的方法，也可以添加方法，即子类比超类拥有的功能更加丰富。

方法重写

当子类重写超类的方法时，也可以调用超类的同名方法，只需要使用super.method()。要注意，重写的方法不可低于超类方法的访问权限！

例如：

[java] view plaincopy

  1. //重写getSalary方法
  2. public double getSalary(){
  3. double baseSalary = super.getSalary();//调用了超类的getSalary方法
  4. return baseSalary + bonus;
  5. }

子类重写了getSalary()方法，也调用了超类的同名方法。
另外，super()方法也可以在构造器中使用，以便调用超类的构造器方法。要注意的是super()方法必须是子类构造器的第一条语句。否则编译器会给出Constructor call must be the first statement in a constructor的错误提醒。例子见最后大例子。

多态和动态绑定

一个对象（例如下例中的e）能够引用多种实际类型的现象称为多态，在运行时能够自动的选择调用那个方法的想象成为动态绑定。Java不支持多重继承，仅支持单继承。

例如下面的大例子中，Emplyee类型的e可以引用Emplyee类型，Manager类型以及Boss类型的对象，当调用e.getSalary()的时候，编译器知道具体的e的实际类型，从而准确的调用该实际类型类的getSalary方法，如果不存在，那就调用其超类的该方法，这就是动态绑定。

final

阻止继承。

[java] view plaincopy

  1. class Employee{
  2. ......
  3. public final String getName(){
  4. return name;
  5. }
  6. ......
  7. }
  8. final class Manager extends Employee{
  9. ......
  10. }

如上例中，Manager类不可以再被继承了，而getName方法也不可被子类重写。

强制类型转换

进行强制类型转换的原因：在暂时忽视对象的实际类型之后，使用对象的全部功能。

仅可以在继承链上从上向下进行转换，如把实际类型是Manager的Employee类型的staff[1]转换成Manager类型。

[java] view plaincopy

  1. Manager man = (Manager)staff[1];

例子

总结性的大例子：

[java] view plaincopy

  1. package com.xujin;
  2. public class Test {
  3. public static void main(String[] args) {
  4. Employee[] staff = new Employee[3];
  5. staff[0] = new Employee("Bob", 1000);
  6. staff[1] = new Manager("Jim", 5000, 1000);
  7. staff[2] = new Boss("Alice", 7000, 1000, 10000);
  8. for(Employee e : staff)
  9. System.out.println("class name:" + e.getClass().getName() + "\tid:" + e.getId() +
  10. "\tname:" + e.getName() + "\tsalary:" + e.getSalary());
  11. Manager man = (Manager)staff[1];
  12. Boss boss = (Boss)staff[2];
  13. System.out.println(man.getBonus());//类型转换后就可以使用实际类型的全部功能
  14. System.out.println(boss.getAward());
  15. //ClassCastException异常,不允许进行继承链上的从上到下的转换
  16. //Boss myBoss = (Boss)staff[0];
  17. //把instaceof运算符和类型转换组合起来，避免异常
  18. if(staff[0] instanceof Boss){
  19. System.out.println("staff[0] is a instace of Boss");
  20. Boss myBoss = (Boss) staff[0];
  21. }
  22. else System.out.println("staff[0] isn‘t a instace of Boss");
  23. if(staff[2] instanceof Boss){
  24. System.out.println("staff[2] is a instace of Boss");
  25. }
  26. else System.out.println("staff[2] isn‘t a instace of Boss");
  27. }
  28. }
  29. class Employee{
  30. public Employee(String name){
  31. this.name = name;
  32. id = nextId;
  33. nextId++;
  34. }
  35. public Employee(String name, double salary){
  36. this(name);//调用另一构造器
  37. this.salary = salary;
  38. }
  39. //定义访问器方法
  40. public final String getName(){
  41. return name;
  42. }
  43. public double getSalary(){
  44. return salary;
  45. }
  46. public final int getId(){
  47. return id;
  48. }
  49. //定义更改器方法
  50. public final void setName(String name){
  51. this.name = name;
  52. }
  53. public final void setSalary(double salary){
  54. this.salary = salary;
  55. }
  56. public final void raiseSalary(double percent){
  57. this.salary *= (1 + percent);
  58. }
  59. //定义变量
  60. private String name = "";//实例域初始化
  61. private double salary;
  62. private int id;
  63. private static int nextId = 1;
  64. }
  65. class Manager extends Employee{
  66. public Manager(String name, double salary, double bonus){
  67. super(name, salary);//super在构造器中的使用，可以调用超类的构造器
  68. setBonus(bonus);
  69. }
  70. public double getBonus(){
  71. return bonus;
  72. }
  73. //重写getSalary方法
  74. public double getSalary(){
  75. double baseSalary = super.getSalary();//调用了超类的getSalary方法
  76. return baseSalary + bonus;
  77. }
  78. public void setBonus(double bonus){
  79. this.bonus = bonus;
  80. }
  81. private double bonus;
  82. }
  83. final class Boss extends Manager{
  84. public Boss(String name, double salary, double bonus, double award){
  85. super(name, salary, bonus);
  86. this.award = award;
  87. }
  88. //重写getSalary方法
  89. public double getSalary(){
  90. double baseSalary = super.getSalary();//调用了超类的getSalary方法
  91. return baseSalary + award;
  92. }
  93. public double getAward(){
  94. return award;
  95. }
  96. private double award;
  97. }

抽象类

最后，阐述一下抽象类的概念。

抽象类就是一个专门用来扩展的祖先类，抽象类本身不能定义一个该类的对象，即抽象类不能被实例化。

[java] view plaincopy

  1. Person p = new Student("joun", 17, 6000);

这里p是一个person类型的变量，但是它引用了Student类型的实例。

抽象类中的方法有两种，一种是普通的，和一般类中的方法一样，另一种是抽象方法，起一个占位的作用，将来子类继承会实现这种方法。

类即使不含抽象方法，也可以将类声明为抽象方法。

抽象类的抽象方法可以用来实现多态性，例如下例中在抽象类中定义了一个getFee()方法，两个子类Employee和Student分别实现了它，但是用了不同的实现方法，当通过Person类型的p调用getFee()方法时，就会根据p的实际类型来调用确定的方法。

[java] view plaincopy

  1. package com.xujin;
  2. public class Test {
  3. public static void main(String[] args) {
  4. Person[] people = new Person[2];
  5. people[0] = new Employee("Bod", 34, 5000);
  6. people[1] = new Student("Joun", 17, 6000);
  7. for(Person p: people){
  8. System.out.print(
  9. "Name:" + p.getName() +
  10. "\tAge:" + p.getAge() +
  11. "\tDescription:" + p.getDescription() + "\t");
  12. if(p instanceof Employee){
  13. System.out.println(((Employee) p).getFee());
  14. }
  15. else if(p instanceof Student)
  16. System.out.println(((Student) p).getFee());
  17. }
  18. }
  19. }
  20. abstract class Person{
  21. public Person(String name, int age){
  22. this.name = name;
  23. this.age = age;
  24. }
  25. public abstract String getDescription();
  26. public final String getName(){
  27. return this.name;
  28. }
  29. public final void setName(String name){
  30. this.name = name;
  31. }
  32. public final int getAge(){
  33. return this.age;
  34. }
  35. public final void setAge(int age){
  36. this.age = age;
  37. }
  38. private String name;
  39. private int age;
  40. }
  41. class Employee extends Person{
  42. public Employee(String name, int age, double fee){
  43. super(name, age);
  44. id = nextId;
  45. nextId++;
  46. this.fee = fee;
  47. }
  48. //定义Person抽象类的抽象方法
  49. public String getDescription(){
  50. return "This is an employee. class name:" + this.getClass().getName();
  51. }
  52. //定义访问器方法
  53. public double getFee(){
  54. return fee * 2;
  55. }
  56. public final int getId(){
  57. return id;
  58. }
  59. //定义更改器方法
  60. public final void setFee(double salary){
  61. this.fee = fee;
  62. }
  63. //定义变量
  64. private double fee;
  65. private int id;
  66. private static int nextId = 1;
  67. }
  68. class Student extends Person{
  69. public Student(String name, int age, double fee){
  70. super(name, age);
  71. this.fee = fee;
  72. }
  73. public String getDescription(){
  74. return "This is a student. class name:" + this.getClass().getName();
  75. }
  76. public double getFee(){
  77. return this.fee;
  78. }
  79. public void setFee(double fee){
  80. this.fee = fee;
  81. }
  82. private double fee;
  83. }

结果：

时间： 2024-10-12 08:32:18

Core Java (十一) Java 继承，类，超类和子类的相关文章

java中带继承类的加载顺序详解及实战

一.背景: 在面试中,在java基础方面,类的加载顺序经常被问及,很多时候我们是搞不清楚到底类的加载顺序是怎么样的,那么今天我们就来看看带有继承的类的加载顺序到底是怎么一回事?在此记下也方便以后复习巩固! 二.测试步骤: 1.父类代码 1 package com.hafiz.zhang; 2 3 public class Fu 4 { 5 private int i = print("this is father common variable"); 6 private static

java基础，继承类题目：编写一个Java应用程序，该程序包括3个类：Monkey类、People类和主类 E

21．编写一个Java应用程序,该程序包括3个类:Monkey类.People类和主类 E.要求: (1) Monkey类中有个构造方法:Monkey (String s),并且有个public void speak() 方法,在speak方法中输出“咿咿呀呀......”的信息. (2)People类是Monkey类的子类,在People类中重写方法speak(),在speak方法 中输出“小样的,不错嘛!会说话了!”的信息. (3)在People类中新增方法void think(),在thi

java中利用继承类和Runnable接口实现多线程的区别

利用继承Thread类实现的多线程无法资源共享 如下程序 class MyThread extends Thread{ public MyThread(String name){ super(); this.name=name; } public void run(){ while(tickets==0?false:true) { tickets--; System.out.println(name+" just selt one ticket,only "+tickets+"

Java中的继承：父类和子类的关系

一.父类引用指向子类对象时 1.若子类覆盖了某方法,则父类引用调用子类重新定义的新方法 2.若子类未覆盖某方法,则父类引用调用父类本身的旧方法 3.若子类覆盖了某属性,但父类引用仍调用父类本身的旧属性 4.若子类未覆盖某属性,则父类引用调用父类本身的旧属性 5.父类引用不能访问子类新定义的方法 二.子类引用指向自身对象时 1.若子类覆盖了某方法,则子类引用调用子类重新定义的新方法 2.若子类未覆盖某方法,则子类引用调用父类本身的旧方法 3.若子类覆盖了某属性,则子类引用调用子类重新定义的新属性

java 继承类与接口问题

java 先extends 继承类,再implements 继承接口 1 public class DataBase extends ClassBase implements Ijiekou { 2 3 }// end

java中的继承关系

1.定义 java中的继承是单一的,一个子类只能拥有一个父类:java中所有类的父类是java.lang.Object,除了这个类之外,每个类只能有一个父类: 而一个父类可以有多个子类,可以被多个子类继承: Java只支持单继承,也就是说,一个类不能继承多个类. Java只支持单继承(继承基本类和抽象类),但是我们可以用接口来实现(多继承{实现}接口来实现),脚本结构如: public class One extends Parent implements Two,Three,Four{} 2.

Java面向对象之继承

Java 中的继承规则: 1.子类继承父类所有的成员变量和成员方法,但是不能继承父类的构造方法. 2.子类虽然继承了父类的成员变量,但是子类不能直接访问父类的私有变量,可以通过getter/setter()方法进行访问 3.子类对父类构造函数的调用规则: a.子类的构造方法首先必须调用父类的构造方法. b.如果没有显示指定,子类的构造方法会默认的调用父类中的无参构造方法, 1 public class Animal { 2 public Animal() { 3 System.out.print

java进阶--继承类

[1]构造函数 为了在遵守某些约定的情况下对已有的程序进行扩充,java语言和一般的op语言一样拥有继承.继承是为了扩展,继承不是为了修改. 这里我们谈几点java继承机制中容易忽略但是很重要的几点. 1.子类中的构造函数 假如我们的超类中显示声明了一个构造函数,子类的实例化能用默认的构造函数么?答案是不能! 比如下面这个例子,子类中必须显示声明. public class third { public static void main(String atgs[]) { a a1=new a(1

java学习笔记（Core Java）5 继承

第五章 继承 1. 类 超类 子类继承:extends (所有继承嗾使公有继承,没有私有继承和保护继承) c+++: 用: 2.使用super(c#使用Base)调用基类的方法 子类构造器会默认调用基类的无参构造来初始化基类的私有域 如果基类没有无参构造,则会报错 3.this :1.引用隐式传参 2.调用类其他构造器 super:1.调用超类的方法 2.调用超类的构造器 c++使用初始化列表来调用基类的构造函数 4.java中,不需要将方法声明为虚拟方法方法,基类指针指向不同对象时,虚拟指针知