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() ;
}

//定义接口的子实现类:见名知意:接口名+impl
class 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 abstract

2)关系的区别:
        类与类的关系:
            继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
        类与接口的关系:
            实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
            (class 子实现类名  enxtends Object implements 接口名1,接口名2...)

        接口与接口的关系
            继承关系:extends,可以支持单继承,也可以多继承!

3)设计理念的区别:
            抽象类:
                体现的是一种"is a"的关系,存在继承关系!(抽象类多态)
            接口:
                体现的是一种"like a"的关系,由于接口的一种扩展功能