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. */
  19. class Fu {
  20.     public int num = 100;
  22.     public void show() {
  23.         System.out.println("show Fu");
  24.     }
  26.     public static void function() {
  27.         System.out.println("function Fu");
  28.     }
  29. }
  31. class Zi extends Fu {
  32.     public int num = 1000;
  33.     public int num2 = 200;
  35.     public void show() {
  36.         System.out.println("show Zi");
  37.     }
  39.     public void method() {
  40.         System.out.println("method zi");
  41.     }
  43.     public static void function() {
  44.         System.out.println("function Zi");
  45.     }
  46. }
  48. class DuoTaiDemo {
  49.     public static void main(String[] args) {
  50.         //要有父类引用指向子类对象。
  51.         //父 f =  new 子();
  52.         Fu f = new Zi();
  53.         System.out.println(f.num);
  54.         //找不到符号
  55.         //System.out.println(f.num2);
  57.         f.show();
  58.         //找不到符号
  59.         //f.method();
  60.         f.function();
  61.     }
  62. }
  64. /*
  65. * 运行结果：
  66. 100
  67. show Zi
  68. function Fu
  69. */


多态的优缺点

  • 多态的好处
    • 提高了程序的维护性(由继承保证)
    • 提高了程序的扩展性(由多态保证)

  • 多态的弊端

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

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

    • 创建子类对象，调用方法即可。（然而很多时候不合理，且太占内存）
    • 向下转型：把父类的引用强制转换为子类的引用。
      • 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("--------------");
  47.     }
  48. }


  • 不同地方饮食文化不同的案例
  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. }
  50. /*
  51. 运行结果：
  53. 炒菜,吃米饭
  54. -------------
  55. 炒菜,吃米饭
  56. 经商
  57. -------------
  58. 炖菜,吃馒头
  59. -------------
  60. 炖菜,吃馒头
  61. 研究
  62. */


多态中继承练习

  • 继承的时候：

    • 子类中有和父类中一样的方法，叫重写。
    • 子类中没有父亲中出现过的方法，方法就被继承过来了。

  • Eg:(不太理解)

  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.     }
  33.     public void show2() {
  34.         System.out.println("你");
  35.     }
  36. }
  37. public class DuoTaiTest4 {
  38.     public static void main(String[] args) {
  39.         A a = new B();
  40.         a.show();
  42.         B b = new C();
  43.         b.show();
  44.     }
  45. }
  47. // 运行结果：
  48. //爱
  49. //你


抽象类

抽象类概述

  • 动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在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 void eat() {
  16.         System.out.println("猫吃鱼");
  17.     }
  18. }
  20. class AbstractDemo {
  21.     public static void main(String[] args) {
  22.         //创建对象
  23.         //Animal是抽象的; 无法实例化
  24.         //Animal a = new Animal();
  25.         //通过多态的方式
  26.         Animal a = new Cat();
  27.         a.eat();
  28.     }
  29. }


抽象类的成员特点

  • 成员变量
    • 可以是变量
    • 也可以是常量
  • 构造方法
    • 有构造方法，但是不能实例化
    • 那么，构造方法的作用是什么呢?
      • 用于子类访问父类数据的初始化

  • 成员方法

    • 可以有抽象方法 作用：限定子类必须完成某些动作
    • 也可以有非抽象方法 提高代码复用性

  • 抽象定义类练习：

  1. //定义抽象的动物类
  2. abstract class Animal {
  3.     //姓名
  4.     private String name;
  5.     //年龄
  6.     private int age;
  8.     public Animal() {}
  10.     public Animal(String name,int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     //定义一个抽象方法
  32.     public abstract void eat();
  33. }
  35. //定义具体的狗类
  36. class Dog extends Animal {
  37.     public Dog() {}
  39.     public Dog(String name,int age) {
  40.         super(name,age); //重要知识点！！！
  41.     }
  43.     public void eat() {
  44.         System.out.println("狗吃肉");
  45.     }
  46. }
  48. //定义具体的猫类
  49. class Cat extends Animal {
  50.     public Cat() {}
  52.     public Cat(String name,int age) {
  53.         super(name,age);
  54.     }
  56.     public void eat() {
  57.         System.out.println("猫吃鱼");
  58.     }
  59. }
  61. //测试类
  62. class AbstractTest {
  63.     public static void main(String[] args) {
  64.         //测试狗类
  65.         //具体类用法
  66.         //方式1：
  67.         Dog d = new Dog();
  68.         d.setName("旺财");
  69.         d.setAge(3);
  70.         System.out.println(d.getName()+"---"+d.getAge());
  71.         d.eat();
  72.         //方式2：
  73.         Dog d2 = new Dog("旺财",3);
  74.         System.out.println(d2.getName()+"---"+d2.getAge());
  75.         d2.eat();
  76.         System.out.println("---------------------------");
  78.         Animal a = new Dog();
  79.         a.setName("旺财");
  80.         a.setAge(3);
  81.         System.out.println(a.getName()+"---"+a.getAge());
  82.         a.eat();
  84.         Animal a2 = new Dog("旺财",3);
  85.         System.out.println(a2.getName()+"---"+a2.getAge());
  86.         a2.eat();
  88.         //练习：测试猫类
  89.     }
  90. }


  • 抽象教师类练习：
  1. //定义抽象的老师类
  2. abstract class Teacher {
  3.     //姓名
  4.     private String name;
  5.     //年龄
  6.     private int age;
  8.     public Teacher() {}
  10.     public Teacher(String name,int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     //抽象方法
  32.     public abstract void teach();
  33. }
  35. //基础班老师类
  36. class BasicTeacher extends Teacher {
  37.     public BasicTeacher(){}
  39.     public BasicTeacher(String name,int age) {
  40.         super(name,age);
  41.     }
  43.     public void teach() {
  44.         System.out.println("基础班老师讲解JavaSE");
  45.     }
  46. }
  48. //就业班老师类
  49. class WorkTeacher extends Teacher {
  50.     public WorkTeacher(){}
  52.     public WorkTeacher(String name,int age) {
  53.         super(name,age);
  54.     }
  56.     public void teach() {
  57.         System.out.println("就业班老师讲解JavaEE");
  58.     }
  59. }
  61. class AbstractTest2 {
  62.     public static void main(String[] args) {
  63.         //具体的类测试，自己玩
  65.         //测试(多态)
  66.         //基础班老师
  67.         Teacher t = new BasicTeacher();
  68.         t.setName("刘意");
  69.         t.setAge(30);
  70.         System.out.println(t.getName()+"---"+t.getAge());
  71.         t.teach();
  72.         System.out.println("--------------");
  74.         t = new BasicTeacher("刘意",30);
  75.         System.out.println(t.getName()+"---"+t.getAge());
  76.         t.teach();
  77.         System.out.println("--------------");
  79.         //就业班老师
  80.         t = new WorkTeacher();
  81.         t.setName("林青霞");
  82.         t.setAge(27);
  83.         System.out.println(t.getName()+"---"+t.getAge());
  84.         t.teach();
  85.         System.out.println("--------------");
  87.         t = new WorkTeacher("林青霞",27);
  88.         System.out.println(t.getName()+"---"+t.getAge());
  89.         t.teach();
  90.     }
  91. }


抽象类的几个小问题

  • 一个类如果没有抽象方法，可以定义为抽象类?如果可以，有什么意义?
    • 可以
    • 禁止创建对象
  • abstract不能和哪些关键字共存
    • private 冲突
    • final 冲突
    • static 无意义(通过类名直接访问没有内容的方法体)

接口

接口概述

  • 狗一般就是看门，猫一般就是作为宠物。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
    所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

接口特点

  • 接口用关键字interface表示
    • 格式：interface 接口名 {}
  • 类实现接口用implements表示
    • 格式：class 类名 implements 接口名 {}
  • 接口不能实例化(接口如何实例化呢?)
    • 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

  • 接口的实现类（子类）：

    • 抽象类:实现接口，但意义不大
    • 具体类:重写接口中的所有抽象方法

  • 补充：多态的三种形式

    • 具体类多态（几乎没有）
    • 抽象类多态（常用）
    • 接口类多态（最常用 ）

接口成员特点

  • 成员变量
    • 只能是常量
    • 默认修饰符 public static final
  • 构造方法
    • 没有，因为接口主要是扩展功能的，而没有具体存在。
    • 所有的类都默认继承自一个类：Object。（类Object 是类层次结构的根类。每个类都使用Object作为超类）
  • 成员方法
    • 只能是抽象方法
    • 默认修饰符 public abstract

类与类,类与接口以及接口与接口的关系

  • 类与类
    • 继承关系，只能单继承，但是可以多层继承
  • 类与接口
    • 实现关系，
      • 可以单实现，也可以多实现。
      • 还可以在继承一个类的同时实现多个接口。
  • 接口与接口
    • 继承关系，可以单继承，也可以多继承

抽象类和接口的区别

  • 成员区别
    • 抽象类
      • 成员变量：变量,常量;
      • 构造方法：可以有
      • 成员方法：可以是抽象方法，也可以是非抽象方法;
    • 接口
      • 成员变量：只可以是常量;
      • 构造方法：没有
      • 成员方法：只能是抽象方法
  • 关系区别
    • 类与类 继承，单继承
    • 类与接口 实现，单实现，多实现
    • 接口与接口 继承，单继承，多继承

  • 设计理念区别

    • 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能
    • 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能

  • 跳高猫练习：

  1. /*
  2.     猫狗案例,加入跳高的额外功能
  4.     分析：从具体到抽象
  5.         猫：
  6.             姓名,年龄
  7.             吃饭，睡觉
  8.         狗：
  9.             姓名,年龄
  10.             吃饭，睡觉
  12.         由于有共性功能，所以，我们抽取出一个父类：
  13.         动物：
  14.             姓名,年龄
  15.             吃饭();
  16.             睡觉(){}
  18.         猫：继承自动物
  19.         狗：继承自动物
  21.         跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
  22.         接口：
  23.             跳高
  25.         部分猫：实现跳高
  26.         部分狗：实现跳高
  27.     实现；
  28.         从抽象到具体
  30.     使用：
  31.         使用具体类
  32. */
  33. //定义跳高接口
  34. interface Jumpping {
  35.     //跳高功能
  36.     public abstract void jump();
  37. }
  39. //定义抽象类
  40. abstract class Animal {
  41.     //姓名
  42.     private String name;
  43.     //年龄
  44.     private int age;
  46.     public Animal() {}
  48.     public Animal(String name,int age) {
  49.         this.name = name;
  50.         this.age = age;
  51.     }
  53.     public String getName() {
  54.         return name;
  55.     }
  57.     public void setName(String name) {
  58.         this.name = name;
  59.     }
  61.     public int getAge() {
  62.         return age;
  63.     }
  65.     public void setAge(int age) {
  66.         this.age = age;
  67.     }
  69.     //吃饭();
  70.     public abstract void eat();
  72.     //睡觉(){}
  73.     public void sleep() {
  74.         System.out.println("睡觉觉了");
  75.     }
  76. }
  78. //具体猫类
  79. class Cat extends Animal {
  80.     public Cat(){}
  82.     public Cat(String name,int age) {
  83.         super(name,age);
  84.     }
  86.     public void eat() {
  87.         System.out.println("猫吃鱼");
  88.     }
  89. }
  91. //具体狗类
  92. class Dog extends Animal {
  93.     public Dog(){}
  95.     public Dog(String name,int age) {
  96.         super(name,age);
  97.     }
  99.     public void eat() {
  100.         System.out.println("狗吃肉");
  101.     }
  102. }
  104. //有跳高功能的猫
  105. class JumpCat extends Cat implements Jumpping {
  106.     public JumpCat() {}
  108.     public JumpCat(String name,int age) {
  109.         super(name,age);
  110.     }
  112.     public void jump() {
  113.         System.out.println("跳高猫");
  114.     }
  115. }
  117. //有跳高功能的狗
  118. class JumpDog extends Dog implements Jumpping {
  119.     public JumpDog() {}
  121.     public JumpDog(String name,int age) {
  122.         super(name,age);
  123.     }
  125.     public void jump() {
  126.         System.out.println("跳高狗");
  127.     }
  128. }
  130. class InterfaceTest {
  131.     public static void main(String[] args) {
  132.         //定义跳高猫并测试
  133.         JumpCat jc = new JumpCat();
  134.         jc.setName("哆啦A梦");
  135.         jc.setAge(3);
  136.         System.out.println(jc.getName()+"---"+jc.getAge());
  137.         jc.eat();
  138.         jc.sleep();
  139.         jc.jump();
  140.         System.out.println("-----------------");
  142.         JumpCat jc2 = new JumpCat("加菲猫",2);
  143.         System.out.println(jc2.getName()+"---"+jc2.getAge());
  144.         jc2.eat();
  145.         jc2.sleep();
  146.         jc2.jump();
  148.         //定义跳高狗并进行测试的事情自己完成。
  149.     }
  150. }
  • 运行结果




posted @ 2016-03-02 00:02  鹿天斐  阅读(174)  评论(0)    收藏  举报