Java面向对象   继承(下)

知识概要:

              (1)抽象类

1.1 抽象类概述 

                          1.2 抽象类的特点 

                          1.3 抽象类举例代码讲解 

                          1.4 抽象类相关问题

              (2)模板方法模式

2.1 模板设计模式的概念

2.2 模板设计模式的演示

              (3)接口

                         3.1 接口的格式

3.2 接口的特点

              (4)多态



(1)抽象类

抽象类概述

 抽象定义:

      •  抽象就是从多个事物中将共性的,本质的内容抽取出来。

      •  例如:狼和狗共性都是犬科,犬科就是抽象出来的概念。

 抽象类:

      •  Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类

就是抽象类。

 抽象方法的由来:

      •  多个对象都具备相同的功能,但是功能具体内容有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取

功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。

      •  例如:狼和狗都有吼叫的方法,可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能,但是并不明

确吼叫的细节。

抽象:看不懂的功能内容。

抽象类的特点:

        1,抽象方法一定在抽象类中。

        2,抽象方法和抽象类都必须被abstract关键字修饰。

        3,抽象类不可以用new创建对象。因为调用抽象方法没意义。

        4,抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用。

        如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。

抽象类和一般类没有太大的不同。

       该如何描述事物,就如何描述事物,只不过,该事物出现了一些看不懂的东西。

       这些不确定的部分,也是该事物的功能,需要明确出现。但是无法定义主体。通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法,抽象类不可以实例化。

特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。

  1. abstract class Student
  2. {
  3. abstract final void study();
  4.  
  5. void sleep()
  6. {
  7. System.out.println("躺着");
  8. }
  9. }
  10.  
  11. class ChongCiStudent extends Student
  12. {
  13. void study()
  14. {
  15. System.out.println("chongci study");
  16. }
  17. }
  18.  
  19. class BaseStudent extends Student
  20. {
  21. void study()
  22. {
  23. System.out.println("base study");
  24. }
  25. }
  26.  
  27. class AdvStudent extends Student
  28. {
  29. void study()
  30. {
  31. System.out.println("adv study");
  32. }
  33. }
  34.  
  35. class AbstractDemo
  36. {
  37. public static void main(String[] args)
  38. {
  39.  
  40. new BaseStudent().study();
  41. }
  42. }

抽象练习:

  1. <span style="font-size:18px;">/*
  2. 假如我们在开发一个系统时需要对员工进行建模,员工包含 3 个属性:
  3. 姓名、工号以及工资。经理也是员工,除了含有员工的属性外,另为还有一个
  4. 奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
  5. 法进行属性访问。
  6.  
  7. 员工类:name id pay
  8.  
  9. 经理类:继承了员工,并有自己特有的bonus。
  10.  
  11. */
  12.  
  13. abstract class Employee
  14. {
  15. private String name;
  16. private String id;
  17. private double pay;
  18.  
  19. Employee(String name,String id,double pay)
  20. {
  21. this.name = name;
  22. this.id = id;
  23. this.pay = pay;
  24. }
  25.  
  26. public abstract void work();
  27.  
  28. }
  29.  
  30. class Manager extends Employee
  31. {
  32. private int bonus;
  33. Manager(String name,String id,double pay,int bonus)
  34. {
  35. super(name,id,pay);
  36. this.bonus = bonus;
  37. }
  38. public void work()
  39. {
  40. System.out.println("manager work");
  41. }
  42. }
  43.  
  44. class Pro extends Employee
  45. {
  46. Pro(String name,String id,double pay)
  47. {
  48. super(name,id,pay);
  49. }
  50. public void work()
  51. {
  52. System.out.println("pro work");
  53. }
  54. }
  55.  
  56. </span>

abstract 关键字,和哪些关键字不能共存?

          final:被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法,不被子类所知,就无法被复写,而抽象方法出现的就是需要被复写

static:如果static可以修饰抽象方法,那么连对象都省了,直接类名调用就可以了,可是抽象方法运行没意义。

抽象类中是否有构造函数?

        有,抽象类是一个父类,要给子类提供实例的初始化。

(2)模板方法模式

需求:获取一段程序运行的时间。

原理:获取程序开始和结束的时间并相减即可。

获取时间:System.currentTimeMillis();

当代码完成优化后,就可以解决这类问题。

这种方式,模版方法设计模式。

什么是模版方法呢?

        在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,

        那么这时就将不确定的部分暴露出去。由该类的子类去完成。

  1. abstract class GetTime
  2. {
  3. public final void getTime()
  4. {
  5. long start = System.currentTimeMillis();
  6.  
  7. runcode();
  8.  
  9. long end = System.currentTimeMillis();
  10.  
  11. System.out.println("毫秒:"+(end-start));
  12. }
  13. public abstract void runcode();
  14.  
  15. }
  16.  
  17. class SubTime extends GetTime
  18. {
  19.  
  20. public void runcode()
  21. {
  22.  
  23. for(int x=0; x<4000; x++)
  24. {
  25. System.out.print(x);
  26. }
  27. }
  28. }
  29.  
  30. class TemplateDemo
  31. {
  32. public static void main(String[] args)
  33. {
  34. //GetTime gt = new GetTime();
  35. SubTime gt = new SubTime();
  36. gt.getTime();
  37. }
  38. }

(3)接口讲解

       格式:

          interface { }

     接口中的成员修饰符是固定的。

         •成员常量:public static final

         •成员函数:public abstract

记住:接口中的成员都是public的。

接口:是不可以创建对象的,因为有抽象方法。

                需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。

                否则子类是一个抽象类。

接口可以被类多实现,也是对多继承不支持的转换形式。java支持多实现。

                接口的出现将“多继承”通过另一种形式体现出来,即“多实现”。

  1. interface Inter
  2. {
  3. public static final int NUM = 3;
  4. public abstract void show();
  5. }
  6.  
  7. interface InterA
  8. {
  9. public abstract void show();
  10. }
  11.  
  12. class Demo
  13. {
  14. public void function(){}
  15. }
  16.  
  17. class Test extends Demo implements Inter,InterA
  18. {
  19. public void show(){}
  20. }
  21.  
  22. interface A
  23. {
  24. void methodA();
  25. }
  26. interface B //extends A
  27. {
  28. void methodB();
  29. }
  30.  
  31. interface C extends B,A
  32. {
  33. void methodC();
  34. }
  35.  
  36. class D implements C
  37. {
  38. public void methodA(){}
  39. public void methodC(){}
  40. public void methodB(){}
  41. }
  42.  
  43. class InterfaceDemo
  44. {
  45. public static void main(String[] args)
  46. {
  47. Test t = new Test();
  48. System.out.println(t.NUM);
  49. System.out.println(Test.NUM);
  50. System.out.println(Inter.NUM);
  51.  
  52. }
  53. }

     抽象类和接口异同:

     相同:

    1,都可以在内部定义抽象方法。

    2,通常都在顶层。

3,都不可以实例化,都需要子类来实现。

不同点:

1,抽象类中可以定义抽象方法和非抽象方法,而接口中只能定义抽象方法。

   2,接口的出现可以多实现。 抽象类只能单继承。 也就是说:接口的出现避免了单继承的局限性。

   3,继承和实现的关系不一致。继承:is a,实现:like a

(4)多态

多态:可以理解为事物存在的多种体现形态。

人:男人,女人

动物:猫,狗。

猫 x = new 猫();

动物 x = new 猫();

1,多态的体现

父类的引用指向了自己的子类对象。

          父类的引用也可以接收自己的子类对象。

     2,多态的前提

          必须是类与类之间有关系。要么继承,要么实现。

          通常还有一个前提:存在覆盖。

3,多态的好处

          多态的出现大大的提高程序的扩展性。

4,多态的弊端:

          提高了扩展性,但是只能使用父类的引用访问父类中的成员。

5,多态的应用

在多态中成员函数的特点:



        1.在编译时期:   参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。

2.在运行时期:   参阅对象所属的类中是否有调用的方法。

简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。

在多态中,成员变量的特点:

        无论编译和运行,都参考左边(引用型变量所属的类)

        在多态中,静态成员函数的特点:

无论编译和运行,都参考做左边。

  1. /*
  2. 需求:
  3. 电脑运行实例,
  4. 电脑运行基于主板。
  5. */
  6.  
  7. interface PCI
  8. {
  9. public void open();
  10. public void close();
  11. }
  12.  
  13. class MainBoard
  14. {
  15. public void run()
  16. {
  17. System.out.println("mainboard run ");
  18. }
  19. public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
  20. {
  21. if(p!=null)
  22. {
  23. p.open();
  24. p.close();
  25.  
  26. }
  27. }
  28. }
  29.  
  30. class NetCard implements PCI
  31. {
  32. public void open()
  33. {
  34. System.out.println("netcard open");
  35. }
  36. public void close()
  37. {
  38. System.out.println("netcard close");
  39. method();
  40. }
  41.  
  42. }
  43. class SoundCard implements PCI
  44. {
  45. public void open()
  46. {
  47. System.out.println("SoundCard open");
  48. }
  49. public void close()
  50. {
  51. System.out.println("SoundCard close");
  52. }
  53. }
  54. /*
  55. class MainBoard
  56. {
  57. public void run()
  58. {
  59. System.out.println("mainboard run");
  60. }
  61. public void useNetCard(NetCard c)
  62. {
  63. c.open();
  64. c.close();
  65. }
  66. }
  67.  
  68. class NetCard
  69. {
  70. public void open()
  71. {
  72. System.out.println("netcard open");
  73. }
  74. public void close()
  75. {
  76. System.out.println("netcard close");
  77. }
  78. }
  79. */
  80.  
  81. class DuoTaiDemo5
  82. {
  83. public static void main(String[] args)
  84. {
  85. MainBoard mb = new MainBoard();
  86. mb.run();
  87. mb.usePCI(null);
  88. mb.usePCI(new NetCard());
  89. mb.usePCI(new SoundCard());
  90.  
  91. }
  92. }

       





Java面向对象 继承(下)的更多相关文章

  1. Java面向对象 继承(上)

       Java面向对象 继承 知识概要:         (1)继承的概述 (2)继承的特点 (3)super关键字 (4)函数覆盖 (5) 子类的实例化过程 (6) final关键字 (1)继承 ...

  2. Java面向对象㈡ -- 继承与多态

    Java的继承是通过extends和implement来实现的,Java不支持多继承,但是Java支持多层继承以及多实现(接口).Java继承有一个关键字super是用来指向父类.Java继承衍生出覆 ...

  3. java面向对象--继承与多态

    可以为一个变异单元中的每个类创建一个main方法,只有命令行所调用的那个类的main方法才会被调用,这样方便进行单元测试.继承时,一般将所有的数据成员都指定为private,将所有的方法指定为publ ...

  4. java面向对象程序设计(下)-接口的定义

    抽象类是从多个类中抽象出来的模板,如果将这种抽象进行得更加彻底,则可以提炼出一种更加特殊的"抽象类"-接口(interface),Java9对接口进行了改进,允许在接口中定义默认方 ...

  5. java面向对象程序设计(下)-枚举类

    在某些情况下,一个类的对象是有限而且固定的,比如季节类,它只有4个对象;再比如行星类,目前只有8个对象,这些实例有限而且固定的类,在Java中被称为枚举类 JDK1.5新增了一个enum关键字,(它与 ...

  6. JAVA面向对象-----继承

    类和类之间的常见关系. 既然继承是描述类和类之间的关系,就需要先来了解类和类之间的常见关系 现实生活的整体与部分 举例说明 现实生活 学生 是人 狗 是动物 球队 包含 球员 整体与部分的关系,部分可 ...

  7. Java面向对象—继承

    概述: 1.多个类相同的属性和功能抽取成另一个类, 让具有特有功能的类继承这个类. 2.通过 extends 关键字可以实现类与类的继承 格式: class 子类名 extends 父类名 {} 特点 ...

  8. java 面向对象 — 继承

    继承中的构造方法,先执行父类中的构造方法,然后执行子类中的构造方法 继承中的属性,最后执行的属性 覆盖前面的属性 因为是开辟了 两个内存空间,所以相比较是不同的. 如果想比较两个对象的值是否相同的话, ...

  9. Java面向对象----继承概念,super关键字

    继承概念: 继承需要符合的关系  is-a  , 父类通用更抽象,子类更特殊更具体 类之间的关系 继承体现 组合体现 实现接口体现 继承的意义 代码重用 体现不同抽象层次 extends关键字 Sup ...

随机推荐

  1. 通信原理课程设计Javaswing技术计算出PCM编码——猎八哥FLY

    package keshe; import java.awt.BorderLayout; import java.awt.EventQueue; import javax.swing.JFrame; ...

  2. Bootstrap框架菜鸟入门教程

    Bootstrap菜鸟入门教程 Bootstrap简介 Bootstrap,来自 Twitter,是目前最受欢迎的前端框架.Bootstrap 是基于 HTML.CSS.JAVASCRIPT 的,它简 ...

  3. §--------算法分界线--------§

    如题 As said in the title~ 计算机的cpu计算从根源上由最基本的逻辑电路(晶体管)组成,由此衍生出最基本的数值运算:四则运算.而此后所有的高级算法都是建立在这个基本计算原理(逻辑 ...

  4. 201521123084 《Java程序设计》第2周学习总结

    第2周作业-Java基本语法与类库 1. 本周学习总结 1.学会使用码云管理代码: 2.学会使用Eclipse关联jdk源代码,并查看对象的源代码: 3.学会String类和StringBuilder ...

  5. html5 javascript 小型计算器

    <!doctype html> <html> <head> <meta charset="utf-8"> <title> ...

  6. 团队作业7---Alpha冲刺之事后诸葛亮

    一.设想与目标 1.我们的软件要解决什么问题? 我们的软件主要是帮助老师解决通过博客地址收集博客的相关信息来对学生对课程的认真与努力程度进行评定的问题,主要就是根据采集到的各项博客数据作为评分项,构建 ...

  7. 24点游戏详细截图介绍以及原型、Alpha、Beta对比

    原型设计 图片展示 功能与界面设计 1.登录注册 2.手机号验证 3.24点游戏 4.粉色系女生界面 Alpha 图片展示 功能与界面设计 1.24点游戏 2.背景音乐 3.可查看多种可能的答案 4. ...

  8. 201521123061 《Java程序设计》第七周学习总结

    201521123061 <Java程序设计>第七周学习总结 1. 本周学习总结 2. 书面作业 ArrayList代码分析 1.1 解释ArrayList的contains源代码 贴上源 ...

  9. 201521123111 《Java程序设计》第1周学习总结

    Java 第一周学习 1.刚开始学习对java还是陌生的,完全不清楚.通过刚开始的上课,有一点点的了解.刚开始可能相对比较基础,进程有点快,而且多媒体屏幕有点反光,所以还是蛮多不懂的.接下来应该好好努 ...

  10. 201521123002《Java程序设计》第14周学习总结

    本次作业参考文件 1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多数据库相关内容. MySql数据库简单操作: 库操作: 显示所有数据库: show databases; 创建数 ...