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. }

• 运行结果
  

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/lutianfei/p/5233377.html