java 多态-抽象类-接口

一.多态
1.多态：同一事物在不同时刻存在的不同状态。

 水:固态,汽态 ,液态

2.多态存在的三个必须条件

a.必须存在继承关系b.必须存在方法重写c.有父类引用指向子类对象:向上转型    Fu f = new Zi() ;

3.
多态的成员访问特点:

成员变量:        编译看左边,运行看左边成员方法(非静态的成员方法):        编译看左,运行看右;由于存在方法重写,所以就运行最终的就是子类的成员方法静态成员方法:(静态方法算不上方法重写,静态直接跟类有关系!)        编译看左,运行看左构造方法:还是对象进行初始化,由于是一种继承关系,还是分层初始化!

    class Fu{        public int num = 10 ;        //父类的成员方法        public void show(){            System.out.println("show Fu...");        }        //静态方法        public  void function(){            System.out.println("function Fu....");        }    }    //子类    class Zi extends Fu{        int num = 20 ;        public void show(){            System.out.println("show Zi...");        }        public  void function(){            System.out.println("function Zi....");        }    }    //测试类    public class Test1 {        public static void main(String[] args) {            //创建父类的对象:多态的形式//          有父类引用指向子类对象:向上转型            Fu f = new Zi() ;            //访问成变量            System.out.println(f.num);            //调用成员方法:show()            f.show() ;            //静态方法            f.function() ;        }    }

4.多态的优缺点

a.优点提高代码的复用性提高代码的维护性b.缺点不能访问子类的特有功能

 class Animal{    public void show(){        System.out.println("show Animal2...");    }}//子类class Cat2 extends Animal{    public void show(){        System.out.println("show Cat2....");    }    //特有功能    public void playGame(){        System.out.println("猫玩毛线...");    }}//测试类public class DuoTaiDemo {    public static void main(String[] args) {        //多态的形式:父类引用指向子类对象        Animal a = new Cat() ;        a.show() ;    a.playGame() ;//不能调用    }}

多态的弊端是不能访问子类的特有功能:如何解决?
异常:OOM异常:严重:OutOfMemory:内存溢出!

    解决方案:            1)创建子类的具体对象,来访问自己的特有功能;虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆内存开辟空间,耗费内存,浪费空间!            2)既然多态的第三个前提条件:父类引用指向子类对象,那么可不可以将子类的引用指向父类对象呢?                    可以的:向下转型:将父类的引用强制转换为子类的引用:前提必须有父类的引用存在;                    向下转型必须依赖于向上转型!

class Animal{    public void show(){        System.out.println("show Animal2...");    }}//子类class Cat extends Animal{    public void show(){        System.out.println("show Cat2....");    }    //特有功能    public void playGame(){        System.out.println("猫玩毛线...");    }}public class DuoTaiDemo {    public static void main(String[] args) {        //父类引用指向子类对象        Animal a = new Cat() ; //向上转型        a.show() ;        //不能访问子类特有功能//      a.playGame();        //创建子类具体对象    /*  Cat c = new Cat() ;        c.playGame() ;*/        //父类的引用强制转换为子类的引用        Cat c = (Cat) a ;        c.playGame() ;    }}

二.抽象类

1.抽象类的概念:

        每一个动物的吃和睡的功能不一样,不应该把动物类定义为一个具体类,而是给出一个声明(abstract)        当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类!    问题:一个抽象类中可以有非抽象方法吗?        一个抽象类中可以抽象,也可以有非抽象的(作为一个判断题记忆!)    抽象类不能实例化:抽象类不能创建对象    一个抽象类如何进行实例化:    通过抽象类多态形式:父类的引用指向子类对象,通过子类进行初始化!

2.抽象类的子类的特点:

            抽象类的子类是抽象类,那么没有意义!            最终使用的就是通过子类进行对象初始化的,如果子类都被抽象修饰了,那么也不能创建对象,所以没意义             

3. 抽象类多态:

            强制子类必须重写当前抽象的父类中所有的抽象方法            还可以提高代码的维护性(里面继承关系保证!)

abstract class Animal{    //抽象方法:没有方法体的一个方法    public abstract void eat() ;    public abstract void sleep() ;    //具体方法    /*public void eat(){        System.out.println("eat");    }*/    public void show(){        System.out.println("show Animal....");    }}//抽象的子类//abstract class Cat extends Animal{//  //}//子类是具体类class Cat extends Animal{    @Override    public void eat() {        System.out.println("猫吃鱼");    }    @Override    public void sleep() {        System.out.println("猫趴着睡觉..");    }}//测试类public class AbstractDemo {    public static void main(String[] args) {        //当前Animal已经被abstract修饰了//      Animal a = new Animal();//Cannot instantiate the type Animal:抽象类不能实例化:instaceof        //多态:父类引用指向子类对象        Animal a = new Cat() ; //Animal是抽象类,---->抽象类多态形式        a.eat() ;        a.sleep() ;    }}

三.接口

1.接口的概念:

接口体现的是一种:扩展功能:      比如:猫可以跳高(并不是所有的猫都具有跳高功能)

2.如何表示接口:

    interface 接口名{                    }

3.接口里面的方法可以是非抽象方法吗?

不可以,只能是抽象方法接口中不能有构造方法

4.接口的特点:不能实例化(不能直接创建对象)

接口如何实例化:接口的子实现类:            1)接口的子实现类是抽象类,没有意义,子类都不能创建对象了;实际开发中用的就是子类的对象进行初始化!            2)接口的子实现类是非抽象类            接口的实例化:就是通过子实现类对数据进行初始化!

5.接口的子实现类和接口的关系:implements:

格式:    class 子实现类名    implments(实现) 接口名{    }

//跳高接口public interface Jumping {    //抽象功能    public abstract void jump();} //部分跳高猫首先应该是猫的一种,然后会跳高所以需要实现接口,重写里面的jump()方法public class JumpingCat extends Cat implements Jumping {    public JumpingCat()    {        super();    }    {        super(name, age);    }    @Override    public void jump() {        System.out.println("猫可以跳高了...");    }}

2.接口的特点

接口成员的特点:

    成员变量:            只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)    构造方法:            接口是没有构造方法的    成员方法:            接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)

//定义一个接口interface Inter{    public static final int num = 100 ;    public static final  int num2 = 200 ;    //抽象方法//  public void show();//  void show() ;    //全部给出默认修饰符    public abstract void show() ;    //接口没有构造方法//  public Inter(){//      //  }    public abstract void function() ;}//定义接口的子实现类:见名知意:接口名+implclass InterImpl implements Inter{    @Override    public void show() {        System.out.println(num);        System.out.println(num2);    }    @Override    public void function() {        System.out.println("function InterImpl...");    }}

补充
接口和抽象类的区别?

1)成员的区别:        成员变量:            抽象类:成员变量可以是常量,也可以是变量            接口:成员变量只能是一常量:存在默认修饰符:public static final        构造方法:            抽象类:可以有无参构造,有参构造方法                  作用:通过子类进行数据初始化(通过子类创建对象)            接口:没有构造方法的        成员方法的区别:            抽象类:可以有抽象方法,也可以有非抽象方法            接口:只能是抽象方法:存在默认修饰符:public abstract2)关系的区别:        类与类的关系:            继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!        类与接口的关系:            实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口            (class 子实现类名  enxtends Object implements 接口名1,接口名2...)        接口与接口的关系            继承关系:extends,可以支持单继承,也可以多继承!3)设计理念的区别:            抽象类:                体现的是一种"is a"的关系,存在继承关系!(抽象类多态)            接口:                体现的是一种"like a"的关系,由于接口的一种扩展功能