JAVA学习笔记Ⅳ——面向对象三特性之多态
文章目录
- 多态
- 多态应用示例
- 练习题
- 引用类型转换
- 抽象类
- 接口
- UML简介
- 练习
多态
对象的多种形态
| 引用多态 | 对象多态 |
|---|---|
| 父类的引用可以指向本类的对象 | 创建本类对象时，调用的方法为本类方法 |
| 父类的引用可以指向子类的对象 | 创建子类对象时，调用的方法为子类重写的方法或继承的方法 |
多态应用示例
使用多态时，两个类一定要有一个继承关系
Animal.java
package com.template16;
public class Animal {
public void eat(){
System.out.println("动物具有吃的能力");
}
}
Dog.java
package com.template16;
public class Dog extends Animal {
public void eat(){
System.out.println("狗可以啃骨头");
}
public void watchDoor(){
System.out.println("狗具有看门的能力");
}
}
Cat.java
package com.template16;
public class Cat extends Animal {
}
Initial.java
package com.template16;
public class Initial {
public static void main(String[] args){
Animal obj_1 = new Animal();
Animal obj_2 = new Dog();
Animal obj_3 = new Cat();
//不允许子类对象指向父类引用，如下
//Dog obj_3 = new Animal();
//利用本类对象调用父类方法
obj_1.eat();
//利用本类对象调用子类方法
obj_2.eat();
//利用本类调用子类继承父类的方法
//这种情况用于子类没有重写父类的方法
obj_3.eat();
//不能通过父类的引用调用子类独有的方法
//obj_2.watchDoor();
}
}
动物具有吃的能力
狗可以啃骨头
动物具有吃的能力
练习题
描述交通工具，其中汽车行驶在陆地，可装载 n n n人。轮船行驶在海洋，可装 m m m人。飞机行驶在空中，可装 x x x人。
Transport.java
package com.template17;
public class Transport {
//父类func方法
public void func() {
System.out.println("交通工具可以运载客人");
}
public Transport(){
func();
}
}
bus.java
package com.template17;
public class Bus extends Transport {
private int num;
public Bus(int num) {
setNum(num);
System.out.println("汽车可以在陆地上载客"+getNum()+"人");
}
public void func() {
System.out.println("这是汽车的方法");
}
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
AirPlane.java
package com.template17;
public class AirPlane extends Transport {
private int num;
public AirPlane(int num) {
setNum(num);
System.out.println("飞机可以在天上载客"+num+"人");
}
public void func() {
System.out.println("这是飞机的方法");
}
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
Boat.java
package com.template17;
public class Boat extends Transport {
private int num;
public Boat(int num) {
setNum(num);
System.out.println("船可以在水上载客"+getNum()+"人");
}
public void func() {
System.out.println("这是船的方法");
}
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
Initial.java
package com.template17;
public class Initial {
public static void main(String[] args){
Transport trans = new Transport();
Transport boat = new Boat(100);
Transport bus = new Bus(200);
Transport airPlane = new AirPlane(300);
//不使用参数将使用继承父类的func方法
boat.func();
trans.func();
bus.func();
airPlane.func();
}
}
引用类型转换
| 引用类型转换 |
|---|
| 向上类型转换（隐式/自动类型转换），是小类型到大类型的转换 |
| 向下类型转换（强制类型转换），是大类型到小类型的转换 |
| instanceof 运算符，来解决引用对象的类型，避免类型转换的安全性问题 |
向上类型转换不存在风险
Animal.java
package com.template18;
public class Animal {
}
Cat.java
package com.template18;
public class Cat extends Animal {
}
Dog.java
package com.template18;
public class Dog extends Animal {
}
Initial.java
package com.template18;
public class Initial {
public static void main(String[] args){
//利用子类的引用指向这个对象
Dog dog = new Dog();
//利用父类引用指向之类对象
//如此则做了自动类型提升(向上类型转换)
Animal animal = dog;
//再次将父类引用转换为子类引用
//显然实际上这句代码是不存在任何风险的，因为最开始
//就是使用父类引用创建的，但是计算机不允许我们这么做
//Dog dog2 = animal;(×)这时需要强制类型转化
Dog dog2 = (Dog)animal;
//不能将animal强制转换为cat，因为初始为Dog对象，Dog
//与Cat是两个不同的类型，因此两个不同类型对象不能互相转换
//Cat cat = (Cat)animal;
//通过instanceof运算符可以避免类型转换的安全性问题
//可以通过它判断一个应用是否是某个类型或某个类型的子类型（返回bool值）
if(animal instanceof Cat){
Cat cat = (Cat)animal;
}else{
System.out.println("无法进行类型转换");
}
}
}
无法进行类型转换
抽象类
| 名词 | 说明 |
|---|---|
| 语法定义 | 抽象类前使用abstract关键字修饰，则该类为抽象类 |
| 应用场景 | 1.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法 2.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性 |
| 作用 | 限制规定子类必须实现某些方法，但不关注实现细节 |
| 使用规则 | 1.abstract定义抽象类 2.abstract定义抽象方法，只有声明，不需要实现 3.包含抽象方法的类是抽象类 4.抽象类中可以包含普通的方法，也可以没有抽象方法 5.抽象类不能直接创建，可以定义引用变量 |
抽象类是约束子类必须具有哪些方法，并不关注子类如何去实现的。抽象类的目的不关注子类的实现，但必须要约束子类必须有哪些特征。
Telphone.java
package com.template19;
public abstract class Telphone {
public abstract void call();
public abstract void message();
}
SmartPhone.java
package com.template19;
public class SmartPhone extends Telphone {
@Override
public void call() {
System.out.println("通过语音来打电话");
}
@Override
public void message() {
System.out.println("通过语音发短信");
}
}
CellPhone.java
package com.template19;
public class CellPhone extends Telphone {
@Override
public void call() {
System.out.println("通过键盘来打电话");
}
@Override
public void message() {
System.out.println("通过键盘发短信");
}
}
Initial.java
package com.template19;
public class Initial {
public static void main(String[] args){
//抽象类不能被实例化
//Telphone telPhone = new Telphone();
Telphone tel1 = new CellPhone();
tel1.call();
tel1.message();
Telphone tel2 = new SmartPhone();
tel2.call();
tel2.message();
}
}
通过键盘来打电话
通过键盘发短信
通过语音来打电话
通过语音发短信
抽象类不能实例化
接口
| 名词 | 说明 |
|---|---|
| 接口概念 | 1.接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成 2.类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法 |
| 接口定义 | 和类定义不同，定义接口不需要使用class关键字，而是使用interface关键字 常量：接口中的属性是常量，即使定义时不添加 public、static、final修饰符，系统也会自动加上方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加 public、abstract修饰符，系统也会自动加上 |
| 接口定义的基本语法 | [修饰符] interface 接口名 [extends 父接口1, 父接口2…] { 零到多个常量定义… 零到多个抽象方法的定义… } 接口就是用来被继承、被实现，修饰符一般建议用public 注意：不能使用private和protect修饰接口 |
| 使用接口 | 一个类可以实现一个或多个接口，实现接口使用implements关键字。JAVA中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以补充。接口命名通常在首字母位置加上I以示区别 接口在使用过程当中，还经常与匿名内部类配合使用【匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称，匿名内部类是指在使用类时并不关注类的名字，仅仅在使用时定义的。】  |
| 继承父类实现接口的语法 | [修饰符] class 类名 extends 父类 implements 接口1，接口2… { 类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。 } 如果要继承父类，继承父类必须在实现接口之前 |
没有显示的写出abstract系统会自动加上，类是单继承，但接口可以多继承，继承多个父接口，接口中的变量都是常量，即使我们在定义时未加上public static final，系统也会自动加上。通常来讲，我们一般不写。
如果继承了抽象类，就必须实现抽象类里面的抽象方法。如果遵守了一个接口，就必须实现接口中的抽象方法
接口中方法不能有方法体，同时方法的访问修饰符不能是 private 和 protected
Telphone.java
package com.template20;
public abstract class Telphone {
public abstract void call();
public abstract void message();
}
SmartPhone.java
package com.template20;
public class SmartPhone extends Telphone implements IPlayGame{
@Override
public void call() {
System.out.println("通过语音来打电话");
}
@Override
public void message() {
System.out.println("通过语音发短信");
}
@Override
public void playGame() {
System.out.println("具有玩游戏的功能");
}
}
Psp.java
package com.template20;
public class Psp implements IPlayGame{
@Override
public void playGame() {
System.out.println("通过键盘发短信");
}
}
IPlayGame.java
package com.template20;
public interface IPlayGame {
public void playGame();
}
Initial.java
package com.template20;
public class Initial {
public static void main(String[] args){
Telphone tel2 = new SmartPhone();
tel2.call();
tel2.message();
IPlayGame ip1 = new SmartPhone();
ip1.playGame();
IPlayGame ip2 = new Psp();
ip2.playGame();
//匿名内部类
IPlayGame ip3 = new IPlayGame() {
@Override
public void playGame() {
System.out.println("使用匿名内部类的方式实现接口");
}
};
ip3.playGame();
//直接new接口
new IPlayGame(){
public void playGame() {
System.out.println("使用匿名内部类的方式实现接口2");
}
}.playGame();
}
}
通过语音来打电话
通过语音发短信
具有玩游戏的功能
通过键盘发短信
使用匿名内部类的方式实现接口
使用匿名内部类的方式实现接口2
UML简介
UML 概念：Unified Modeling Language（UML），又称统一建模语言或标准建模语言，是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持
UML 2.2中一共定义了14中图示（diagrams)。
| 用例图（The Use Case Diagram） | 序列图（The Sequence Diagram） | 类图（The Class Diagram） |
|---|---|---|
用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求等信息 |
序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互 |
UML 类图、业务逻辑和所有支持结构一同被用于定义全部的代码结构 |
练习
Persion.java
package com.exercise1;
public class Person {
public void say(){
System.out.println("人类具有说话的能力");
}
}
American.java
package com.exercise1;
public class American extends Person {
@Override
public void say() {
System.out.println("美国人说英语");
}
}
Chinese.java
package com.exercise1;
public class Chinese extends Person {
@Override
public void say(){
System.out.println("中国人说中国话");
}
}
AAmerican.java
package com.exercise1;
public class AAmerican extends APerson{
public void say(){
System.out.println("美国人说英语");
}
}
AChinese
package com.exercise1;
public class AChinese extends APerson{
public void say(){
System.out.println("中国人说中国话");
}
}
APersion.java
package com.exercise1;
public abstract class APerson {
public abstract void say();
}
Test.java
package com.exercise1;
public class Test {
public static void main(String[] args){
Chinese p = new Chinese();
American p2 = new American();
p.say();
p2.say();
//利用多态的方法
Person pp = new Chinese();
Person pp2 = new American();
pp.say();
pp2.say();
//利用抽象类方法
APerson ppp = new AChinese();
APerson ppp2 = new AAmerican();
ppp.say();
ppp2.say();
}
}
中国人说中国话
美国人说英语
中国人说中国话
美国人说英语
中国人说中国话
美国人说英语