首页 > > 程序设计 > Java技术 >

JAVA面向对象的三大特性多态

2018-06-18 03:48:31来源：未知阅读 ()

多态指的是对象的多种形态

继承是多态的实现基础，别忘了子父类要有继承关系.

多态特性：

一、引用多态

1.父类引用可以指向本类对象 Animal obj1 = new Animal();

2.父类引用可以指向子类对象 Animal obj2 = new Dog();

但是我们不能用子类的引用指向父类对象

Dog obj3 = new Animal();//错

二、方法多态

创建本类对象时，调用的方法为本类方法。

创建子类对象时，调用的方法为子类重写的方法或者继承的方法。

1.在父类Animal中定义一个eat()方法，输出一个语句(动物有吃的能力); 在子类Dog中重写eat()方法，输出一个语句（狗是吃肉的）; 那么我们在测试类main函数里面，如果obj1.eat() ，那么调用的是父类的方法. 若用obj2调用eat()方法，那么调用的是子类的方法.

2.还有一种情况，比如创建一个继承父类Animal的子类Cat ，但是Cat里并不重写继承的eat()方法. 然后，我们在测试类main函数里创建一个子类对象, Animal obj3 = new Cat(); 然后调用 obj3.eat(); 那么，结果调用的则是子类继承父类的方法. (输出结果：动物有吃的能力)

3.最后一种特殊情况，多态的特性是不能使用的. 若在子类添加一个独有的方法 public void watchDoor() ，含有一句输出语句(狗具有看门的能力); 那么我们在测试类的main函数当中(得先定义好对象Animal obj2 = new Dog() )，就不能用obj2.watchDoor()，即不能通过父类的引用调用子类的方法

 1 public class Animal    {
 2     public void eat(){
 3         System.out.println("动物有吃的能力");
 4     }
 5 }
 6 
 7 public class Dog extends Animal {
 8     public void eat(){
 9         System.out.println("狗是吃肉的");
10     }
11     public static void main(String[] args) {
12         Animal obj1 = new Animal();
13         Animal obj2 = new Dog();
14         obj1.eat();
15         obj2.eat();
16     }
17 }

引用类型转换：

1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换。如：Dog dog=new Dog();Animal animal=dog;//正确，自动类型提升，向上类型转换

2.向下类型转换（强制类型转换），是大类型到小类型的转换（存在风险，溢出）如：Dog dog1=(Dog)animal;//向下类型转换

3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。

如： Dog dog=new Dog();

　　 Animal animal=dog;

　　 Cat cat=(Cat)animal;//编译时不会出错（按Cat类型进行编译），但运行时会报错，因为它开辟的是Dog类型的空间，而（无法将引用类型进行转换）无法将dog对象转换成Cat类型，并且此方法对程序的安全性有影响。

此时应该利用instanceof和if语句结合使用，进行验证，以保证程序的安全性，如：

if(animal instanceof Cat){

//判断animal类中是否包含Cat类型的元素，若包含则进行转换，instanceof返回值为布尔类型

1 if (dog instanceof cat){
2 Dog l1 = (Dog)cat;
3 }else{
4 System.out.println("无法进行类型转换！");
5 }

抽象类

1 语法定义：

类前使用abstract关键字修饰，则该类为抽象类

2 应用场景：

a.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。抽象类约束子类必须有这些方法，而并不关注子类如何实现。

b.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

3 作用：

限制规定了子类必须实现某些方法，但不关注实现细节

4使用规则：

a.abstract定义抽象类

b.abstract定义抽象方法，只有声明，不需要具体实现。

c.包含抽象方法的是抽象类(如果在类前不适用abstract关键字，会出错)

d.抽象类中可以包含普通的方法，也可以没有抽象方法。

e.抽象类不能直接创建对象，可以定义引用变量，指向一个子类的对象

接口：

1.接口可以理解为一种特殊的类，由全局常量和公共抽象方法组成

如果说类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的具体实现细节，它只规定这些类里必须提供某些方法

2.接口的定义：

和类定义不同，定义接口不再使用class关键字，而是使用interface关键字.

基本语法：[修饰符] interface 接口名[extends 父接口1，父接口2.......]{

零个到多个常量定义...

零个到多个抽象方法定义...

}

接口就是用来继承，被实现，修饰符一般建议用public

注意：不能够使用private和protected修饰接口

3 接口定义：常量

接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上

方法：

接口中的方法只能是抽象方法，即使定义时不添加public abstract字符修饰，系统也会自动加上

4实现：

一个类可以实现一个或多个接口，实现接口使用implements关键字。

java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充，java中一个类可以实现一个或者多个接口。

继承父类实现接口的语法：

[修饰符] class 类名 extends 父类 implements接口1 ，接口2......{

类体部分//如果继承了抽象类，需要实现继承的抽象方法

//要实现接口中的抽象方法

}

如果要继承父类，继承父类必须在实现接口之前

5 实现时可以利用接口的引用指向实现了接口的对象，调用其方法，如：

IPlay ip1=new Psp();ip1.playGame();

Telphone抽象类只提供打电话，发短信的方法，没有提供玩游戏的功能，怎么在不改变抽象方法的情况下，让智能手机拥有玩游戏的功能？这就用到了我们的接口

我们想描述Psp呢？Psp只能玩游戏不能发短信和打电话

 1 public interface IplayGame {
 2     public void playGame();
 3 }
 4 
 5 public abstract class Telphone {
 6     public abstract void call();
 7     public abstract void message();
 8 }
 9 
10 public class SmartPhone extends Telphone implements IplayGame {
11 
12     @Override
13     public void call() {
14         // TODO Auto-generated method stub
15         System.out.println("智能手机能打电话！");
16     }
17 
18     @Override
19     public void message() {
20         // TODO Auto-generated method stub
21         System.out.println("智能手机能够发短信！");
22     }
23 
24     @Override
25     public void playGame() {
26         // TODO Auto-generated method stub
27         System.out.println("智能手机能够玩游戏！");
28     }
29 }
30 
31 public class Psp implements IplayGame{
32     @Override
33     public void playGame() {
34         // TODO Auto-generated method stub
35         System.out.println("psp能够玩游戏！");
36     }
37 }
38 
39 public class Cellphone extends Telphone {
40 
41     @Override
42     public void call() {
43         // TODO Auto-generated method stub
44         System.out.println("普通手机能够打电话!");
45     }
46 
47     @Override
48     public void message() {
49         // TODO Auto-generated method stub
50     System.out.println("普通手机能够发短信！");
51     }
52 }
53 
54 public class Ceshi {
55     public static void main(String[] args) {
56         IplayGame smp = new SmartPhone();
57         smp.playGame();
58         Telphone t1 = new SmartPhone();
59         t1.call();
60         t1.message();
61         IplayGame ip = new Psp();
62         ip.playGame();
63     }
64 }

View Code

6接口在使用过程中，还经常与匿名内部类配合使用

匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名字

public class Nmnbl {
    IplayGame ip1 = new IplayGame() {
        public void playGame() {
            System.out.println("我是匿名内部类实现接口！");
        };
    };

    public static void main(String[] args) {
        new IplayGame() {
            @Override
            public void playGame() {
                // TODO Auto-generated method stub
                System.out.println("使用第二中匿名内部类实现接口！");
            }
        }.playGame();
    }
}