No_16_0229 Java基础学习第九天

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了No_16_0229 Java基础学习第九天相关的知识，希望对你有一定的参考价值。

文档版本 开发工具 测试平台 工程名字 日期 作者 备注
V1.0 2016.02.29 lutianfei none

final 关键字
多态
多态概述
多态的分类：
多态中的成员访问特点：
多态中的转型问题
抽象类
抽象类概述
抽象类特点
抽象类的成员特点
抽象类的几个小问题
接口
接口概述
接口特点
接口成员特点
类与类,类与接口以及接口与接口的关系
抽象类和接口的区别

final 关键字

  • final关键字是最终的意思，可以修饰类，成员变量，成员方法。

  • 特点：

    • 修饰的类，类不能被继承
    • 修饰的变量，变量就变成了常量，只能被赋值一次
    • 修饰的方法，方法不能被重写

  • final关键字面试题

  • Eg1： final修饰局部变量

    • 在方法内部，该变量不可以被改变
    • 在方法声明上，分别演示基本类型和引用类型作为参数的情况
      • 基本类型，是值不能被改变
      • 引用类型，是地址值不能被改变，但是该对象堆内存的值可以改变。

  • Eg2： final修饰变量的初始化时机

    • 在对象构造完毕前即可
  1. class Student {
  2.     int age = 10;
  3. }
  5. class FinalTest {
  6.     public static void main(String[] args) {
  7.         //局部变量是基本数据类型
  8.         int x = 10;
  9.         x = 100;
  10.         System.out.println(x);
  11.         final int y = 10;
  12.         //无法为最终变量y分配值
  13.         //y = 100;
  14.         System.out.println(y);
  15.         System.out.println("--------------");
  17.         //局部变量是引用数据类型
  18.         Student s = new Student();
  19.         System.out.println(s.age);
  20.         s.age = 100;
  21.         System.out.println(s.age);
  22.         System.out.println("--------------");
  24.         final Student ss = new Student();
  25.         System.out.println(ss.age);
  26.         ss.age = 100;
  27.         System.out.println(ss.age);
  29.         //重新分配内存空间
  30.         //无法为最终变量ss分配值
  31.         ss = new Student();
  32.     }
  33. }

多态

多态概述

  • 某一个事物，在不同时刻表现出来的不同状态。
    • 举例：
      • 猫可以是猫的类型。猫 m = new 猫();
      • 同时猫也是动物的一种，也可以把猫称为动物。
        • 动物 d = new 猫();
      • 再举一个例子：水在不同时刻的状态
  • 多态前提和体现
    • 有继承关系
    • 有方法重写
    • 有父类引用指向子类对象
      • Fu f = new Zi();

多态的分类：

  • 具体类多态：
    • class Fu{}
    • class Zi extends Fu{}
    • Fu f = new Zi();
  • 抽象类多态：
    • abstract class Fu{}
    • class Zi extends Fu{}
    • Fu f = new Zi();
  • 接口多态：
    • interface Fu{}
    • class Zi implements Fu{}
    • Fu f = new Zi();

多态中的成员访问特点：

  • A:成员变量
    • 编译看左边，运行看左边。
  • B:构造方法
    • 创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
  • C:成员方法
  • 编译看左边，运行看右边。由于成员方法存在方法重写，所以它运行看右边。
  • D:静态方法
    • 编译看左边，运行看左边。
    • (静态和类相关，算不上重写，所以，访问还是左边的)
  1. /*
  2.     多态：同一个对象(事物)，在不同时刻体现出来的不同状态。
  3.     举例：
  4.         猫是猫，猫是动物。
  5.         水(液体，固体，气态)。
  7.     多态的前提：
  8.         A:要有继承关系。
  9.         B:要有方法重写。
  10.             其实没有也是可以的，但是如果没有这个就没有意义。
  11.                 动物 d = new 猫();
  12.                 d.show();
  13.                 动物 d = new 狗();
  14.                 d.show();
  15.         C:要有父类引用指向子类对象。
  16.             父 f =  new 子();
  18.     用代码体现一下多态。
  20.     多态中的成员访问特点：
  21.         A:成员变量
  22.             编译看左边，运行看左边。
  23.         B:构造方法
  24.             创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
  25.         C:成员方法
  26.             编译看左边，运行看右边。
  27.         D:静态方法
  28.             编译看左边，运行看左边。
  29.             (静态和类相关，算不上重写，所以，访问还是左边的)
  31.         由于成员方法存在方法重写，所以它运行看右边。
  32. */
  33. class Fu {
  34.     public int num = 100;
  36.     public void show() {
  37.         System.out.println("show Fu");
  38.     }
  40.     public static void function() {
  41.         System.out.println("function Fu");
  42.     }
  43. }
  45. class Zi extends Fu {
  46.     public int num = 1000;
  47.     public int num2 = 200;
  49.     public void show() {
  50.         System.out.println("show Zi");
  51.     }
  53.     public void method() {
  54.         System.out.println("method zi");
  55.     }
  57.     public static void function() {
  58.         System.out.println("function Zi");
  59.     }
  60. }
  62. class DuoTaiDemo {
  63.     public static void main(String[] args) {
  64.         //要有父类引用指向子类对象。
  65.         //父 f =  new 子();
  66.         Fu f = new Zi();
  67.         System.out.println(f.num);
  68.         //找不到符号
  69.         //System.out.println(f.num2);
  71.         f.show();
  72.         //找不到符号
  73.         //f.method();
  74.         f.function();
  75.     }
  76. }
  78. /*
  79. * 运行结果：
  80. 100
  81. show Zi
  82. function Fu
  83. */
  • 多态的好处
    • 提高了程序的维护性(由继承保证)
    • 提高了程序的扩展性(由多态保证)

  • 多态的弊端

    • 父类不能访问子类特有功能

  • 如何才能访问子类的特有功能呢?

    • 创建子类对象，调用方法即可。（然而很多时候不合理，且太占内存）
    • 向下转型：把父类的引用强制转换为子类的引用。
      • Zi z = (Zi)f; //要求该f必须是能够转换为Zi的
  • 现象： 子可以当做父使用，父不能当作子使用。

多态中的转型问题

  • 向上转型
    • 从子到父
    • 父类引用指向子类对象

  • 向下转型

    • 从父到子
    • 父类引用转为子类对象

  • 孔子装爹案例

  1. //多态的问题理解：
  2.     class 孔子爹 {
  3.         public int age = 40;
  5.         public void teach() {
  6.             System.out.println("讲解JavaSE");
  7.         }
  8.     }
  10.     class 孔子 extends 孔子爹 {
  11.         public int age = 20;
  13.         public void teach() {
  14.             System.out.println("讲解论语");
  15.         }
  17.         public void playGame() {
  18.             System.out.println("英雄联盟");
  19.         }
  20.     }
  22.     //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
  23.     //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
  24.     //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
  25.     //向上转型
  26.     孔子爹 k爹 = new 孔子();
  27.     //到人家那里去了
  28.     System.out.println(k爹.age); //40
  29.     k爹.teach(); //讲解论语
  30.     //k爹.playGame(); //这是儿子才能做的,一做就报错！
  33.     //讲完了，下班回家了
  34.     //脱下爹的装备，换上自己的装备
  35.     //向下转型
  36.     孔子 k = (孔子) k爹; 
  37.     System.out.println(k.age); //20
  38.     k.teach(); //讲解论语
  39.     k.playGame(); //英雄联盟

技术分享

  • 多态中的对象变化内存图
    技术分享


  • 多态练习：猫狗案例
  1. class Animal {
  2.     public void eat(){
  3.         System.out.println("吃饭");
  4.     }
  5. }
  7. class Dog extends Animal {
  8.     public void eat() {
  9.         System.out.println("狗吃肉");
  10.     }
  12.     public void lookDoor() {
  13.         System.out.println("狗看门");
  14.     }
  15. }
  17. class Cat extends Animal {
  18.     public void eat() {
  19.         System.out.println("猫吃鱼");
  20.     }
  22.     public void playGame() {
  23.         System.out.println("猫捉迷藏");
  24.     }
  25. }
  27. class DuoTaiTest {
  28.     public static void main(String[] args) {
  29.         //定义为狗
  30.         Animal a = new Dog();
  31.         a.eat();
  32.         System.out.println("--------------");
  33.         //还原成狗
  34.         Dog d = (Dog)a;
  35.         d.eat();
  36.         d.lookDoor();
  37.         System.out.println("--------------");
  38.         //变成猫
  39.         a = new Cat();
  40.         a.eat();
  41.         System.out.println("--------------");
  42.         //还原成猫
  43.         Cat c = (Cat)a;
  44.         c.eat();
  45.         c.playGame();
  46.         System.out.println("--------------");
  48.         //演示错误的内容
  49.         //Dog dd = new Animal();
  50.         //Dog ddd = new Cat();
  51.         //ClassCastException
  52.         //Dog dd = (Dog)a;
  53.     }
  54. }


  • 不同地方饮食文化不同的案例
  2. class Person {
  3.     public void eat() {
  4.         System.out.println("吃饭");
  5.     }
  6. }
  8. class SouthPerson extends Person {
  9.     public void eat() {
  10.         System.out.println("炒菜,吃米饭");
  11.     }
  13.     public void jingShang() {
  14.         System.out.println("经商");
  15.     }
  16. }
  18. class NorthPerson extends Person {
  19.     public void eat() {
  20.         System.out.println("炖菜,吃馒头");
  21.     }
  23.     public void yanJiu() {
  24.         System.out.println("研究");
  25.     }
  26. }
  28. class DuoTaiTest2 {
  29.     public static void main(String[] args) {
  30.         //测试
  31.         //南方人
  32.         Person p = new SouthPerson();
  33.         p.eat();
  34.         System.out.println("-------------");
  35.         SouthPerson sp = (SouthPerson)p;
  36.         sp.eat();
  37.         sp.jingShang();
  38.         System.out.println("-------------");
  40.         //北方人
  41.         p = new NorthPerson();
  42.         p.eat();
  43.         System.out.println("-------------");
  44.         NorthPerson np = (NorthPerson)p;
  45.         np.eat();
  46.         np.yanJiu();
  47.     }
  48. }


  • 多态中继承练习
  • 继承的时候：
    • 子类中有和父类中一样的方法，叫重写。
    • 子类中没有父亲中出现过的方法，方法就被继承过来了。
  1. /*
  2.     多态的成员访问特点：
  3.         方法：编译看左边，运行看右边。
  5.     继承的时候：
  6.         子类中有和父类中一样的方法，叫重写。
  7.         子类中没有父亲中出现过的方法，方法就被继承过来了。
  8. */
  9. class A {
  10.     public void show() {
  11.         show2();
  12.     }
  13.     public void show2() {
  14.         System.out.println("我");
  15.     }
  16. }
  17. class B extends A {
  18.     /*
  19.     public void show() {
  20.         show2();
  21.     }
  22.     */
  24.     public void show2() {
  25.         System.out.println("爱");
  26.     }
  27. }
  28. class C extends B {
  29.     public void show() {
  30.         super.show();
  31.     }
  32.     public void show2() {
  33.         System.out.println("你");
  34.     }
  35. }
  36. public class DuoTaiTest4 {
  37.     public static void main(String[] args) {
  38.         A a = new B();
  39.         a.show();
  41.         B b = new C();
  42.         b.show();
  43.     }
  44. }


抽象类

抽象类概述

  • 动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体(连大括号也没有)的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

抽象类特点

  • 抽象类和抽象方法必须用abstract关键字修饰
    • 格式
      • abstract class 类名 {}
      • public abstract void eat();
  • 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
  • 抽象类不能实例化(抽象类如何实例化呢?)
    • 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
    • 抽象类有构造方法，其作用是为了用于子类访问父类数据的初始化。
  • 抽象类的子类
    • 要么是抽象类
    • 要么重写抽象类中的所有抽象方法
  1. //abstract class Animal //抽象类的声明格式
  2. abstract class Animal {
  3.     //抽象方法
  4.     //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
  5.     public abstract void eat();
  7.     public Animal(){}
  8. }
  10. //子类是抽象类
  11. abstract class Dog extends Animal {}
  13. //子类是具体类，重写抽象方法
  14. class Cat extends Animal {
  15.     public





















以上是关于No_16_0229 Java基础学习第九天的主要内容，如果未能解决你的问题，请参考以下文章

No_16_0224 Java基础学习第五天

No_16_0324 Java基础学习第二十三天

No_16_0226 Java基础学习第七天

No_16_0221 Java基础学习第一天

No_16_0221 Java基础学习第二天

No_16_0222 Java基础学习第三天