程序员===Java基础===多态和接口



一．多态

什么是多态：事物的多种形态

 

为什么在继承中说道多态，因为他是多态的前提条件，

要有方法重写

父类引用指向子类对象

 

成员变量   花木兰的实例

      编译看左边(父类)，运行看左边(父类)。

成员变量

编译看左边(父类),运行看左边(父类)

成员方法

编译看左边(父类)，运行看右边(子类)。动态绑定

静态方法

编译看左边(父类)，运行看左边(父类)。

(静态和类相关，算不上重写，所以，访问还是左边的)

总结：只有非静态的成员方法,编译看左边,运行看右边 

花木兰替父从军         花爹 爹 = new花木兰();                  成员变量 :编译看左边(父类),运行看左边(父类);                   军队点名:                   报花爹 (他爹的名字) ---- 88 (他爹年龄)                  成员方法:　编译看左边(父类)看他父亲有没有这个方法,有编译成功,没有编译失败,运行看右边(子类)运行花木兰的方法;                   打仗:                   打仗的时候(方法) ----- > 花木兰去打仗(他爹必须有打仗的方法)                             注释:                   父类中必须要有这个方法编译才能通过,运行的时候执行的是子类的这个方法(子类重写父类方法);                    问题:子类特点有方法,父类引用能不能调用?           他两都有打仗的方法fly();           花木兰打仗 ----匕首           花木兰他爹 ----长矛           花木兰特点有方法:跳舞 dance();           FlowerDady  dady = new FlowerTreeGirl();           dady.fly();  ---- 打仗用匕首           dady.dance() ----  这个编译报错.父类引用不能调用子类特有的方法

多态的好处和弊端:

        好处:1)提高代码的维护性 (多态的前提是继承)

                  2)提高代码的扩展性 

弊端:

不能使用子类的特有属性和方法（向下转型才会使用，后面一起写代码）

 

二.抽象类

                  抽象类也是描述一个类事物,但是自己本身不实现,让子类去继承并且重写. (抽象类设定了方法签名---规则)

                  规则强制子类重写父类的抽象方法,防止子类设计的随意化.

                  

                  特点:

                  1)被Abstract修饰的类

                  2)抽象类不一定有抽象方法(抽象类可以有非抽象的方法也可以有抽象方法),有抽象方法的一定是抽象类或者即接口

                  3)抽象类不能实例化(创建该类对象),但是可以按照多态方式,创建子类对象,指向该父类(可以是抽象类)引用.

                  4)抽象类的子类要么就是抽象类,要么就不是抽象类,如果不是抽象类,就必须重写父类中的所有抽象方法.

 

                  格式:

                  abstract 类名 {

                           inta = 10;  //变量不用Abstract修饰

                           //方法可以用Abstract修饰

                           publicabstract void print();  //抽象方法没有方法体

                           

                           也可以不用Abstract修饰

                           public  void method(){}

                           

                  }

                  

                  抽象类成员特点:

                           1) 抽象类中成员变量可以是变量,也可以是常量。变量不能用abstract修饰。

                           2）抽象类有构造方法。用于子类访问父类数据的初始化。

                           3）成员方法：既可以是抽象的，也可以是非抽象的。

                           4）抽象方法强制要求子类做的事情；非抽象方法子类继承的事情，提高代码复用

/* 已知动物类（姓名，年龄，吃饭，睡觉），它有两个子类，分别是猫类和狗类。 不同的是猫吃鱼，狗吃肉。 经过马戏团的培训后，部分猫会跳高，部分狗也会跳高。 请写代码实现。 */ class TestDay09Jump { public static void main(String[] args) { Cat c = new Cat ("花色",4); c.eat(); c.catchHouse(); c. jump(); //使用多态 Anmial c1 = new Cat ("花色",4); c1.eat(); Cat c2 = (Cat) c1;//向下转型 c2.catchHouse(); c2. jump(); System.out.println("Hello World!Hello World!Hello World!Hello World!Hello World!"); Dog d = new Dog ("花色",4); d.eat(); d.lookHome(); d. jump(); //使用多态 Anmial d1 = new Dog ("花色",4); d1.eat(); Dog d2 = (Dog) d1;//向下转型 d2.lookHome(); d2. jump(); } } abstract class Anmial {//父类anmial String name; int age ; public Anmial(){//无参 } public Anmial(String name,int age){//有参 this.name = name ; this.age = age; } /* setting和getter方法 */ public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(){ this.age = age; } public int getAge(){ return age; } public abstract void eat();//抽象的吃的方法 public abstract void sleep();//抽象的睡觉的方法 } //接口 跳高的功能 abstract interface IJump{ public abstract void jump(); } class Cat extends Anmial implements IJump { public void jump(){ System.out.println(this.getName()+"会跳高了"); } public Cat(){//无参 } public Cat(String name,int age){//有参 super(name,age); } public void eat(){ System.out.println("mao吃鱼"); } public void sleep(){ System.out.println("mao睡觉的方法"); } public void catchHouse(){ System.out.println("mao特有的方法"); } } class Dog extends Anmial implements IJump{//狗类 public void jump(){ System.out.println(this.getName()+"会跳高了"); } public Dog(){//无参 } public Dog(String name,int age){//有参 super(name,age); } public void eat(){ System.out.println(" Dog吃骨头"); } public void sleep(){ System.out.println(" Dog睡觉地方法"); } public void lookHome(){ System.out.println(" Dog特有的方法"); } }

小的知识点：1)抽象类中能不能有非抽象方法?有什么意义?

                           可以. 让子类直接继承并使用. 

                           父类中的抽象方法,目的不让其他类创建本类对象,

                           让子类重写这个方法,并且创建子类对象,使用子类对象(父类引用),调用该方法.

                           

                           2)abstract不可以和那些关键字共存？

                            不能和static共存。被static修饰方法是静态方法，可以通过类名调用。但是这个方法是抽象方法，通过类名调用没有意义。

                            不能和final共存。被fianl修饰的方法不能被子类重写，父类的抽象方法强制要求子类重写，冲突。

                            不能和private共存。父类中private修饰的抽象方法，子类不可见，但是又要求这个抽象方法子类必须重写，矛盾。

 

三.接口

1.类A继承另一个类B，B类是A类的父类

类C实现了一个接口D, D接口是C的师傅.多实现

接口:狭义上理解就是把class换成interface

         广义上来理解,第一方面接口给我们制定了规则(方法签名),第二方面,给我们提供了额外的功能.其实就是对功能的一种扩展.

方法签名 public void method();

格式:

interface接口名{}

怎么样:让类实现这个接口  

class Guoer implements小笼包{}

                  

注意:接口不能创建对象,通过父类引用指向子类对象. (接口也能多态)

                  

2.接口的成员特点:

成员变量:

接口中的变量其实就是常量.

默认使用 publicstatic final 顺序无关

 构造方法:

接口中没有构造方法

 成员方法:

成员方法必修都是抽象的方法

默认修饰符: publicabstract

3.类与类,类与接口,接口与接口的关系分别是什么？

                  类与类 :继承,单继承,多层继承

                  类与接口:实现关系,可以单实现,多实现;

                  接口与接口:继承关系,可以是单继承,多继承.

4.抽象类和接口的区别:

                           1)成员上的区别:

                                    抽象类:

                                              成员变量: 变量 ,常量

                                              构造方法:有构造

                                              成员方法:可以是抽象方法,可以是非抽象方法

                                    

                                    接口:

                                              成员变量: 常量

                                              构造方法:没有有构造

                                              成员方法:只能是抽象方法

                           

                           2)理念上的区别:

                                    抽象类:满足 is a关系, Cat Dog是 Animal的一种.把一类共性的数据向上抽取成一个类,定位为抽象的.

                                    接口:满足 (like a)和(has a)原来一个类有一定的功能,但是这个功能不够用,让他实现一个接口,完成一个扩展功能.

                                    

                                    电话 ---打电话 发短信 playGame

                                    老式电话不能玩游戏

                                    新式电话可以玩游戏 ---相当于给新式手机增加扩展功能. --- 实现一个接口,接口里面提供玩游戏的功能.

                                    给电话增加一个playGame方法.

 

/* 手机类 , OldPhone NewPhone; 已知接口IPlay中有一个方法playGame()，NewPhone添加玩游戏的功能跟 再测试类中如何调用该方法？ 需求，一个父类 phone ，接口和接口中的功能 */ class TestDay09Phone { public static void main(String[] args) { Phone p = new OldPhone(); p.call(); System.out.println("Hello World!"); Phone new1 = new NewPhone(); new1.call(); NewPhone new2 = (NewPhone) new1; new2.playGame(); } } //父类 abstract class Phone { public abstract void call (); } //接口的定义 abstract interface IPlay{ public abstract void playGame(); } //旧手机 class OldPhone extends Phone{ public void call(){ System.out.println("恩健打电话"); } } //新手机 先要继承phone 在实现接口完成功能的扩展，实现功能 class NewPhone extends Phone implements IPlay{ public void call(){ System.out.println("说话直接打电话"); } public void playGame(){ System.out.println("可以玩游戏了"); } }