Java多态

一.多态概念　

　　注：Python支持多态（同样还有鸭子类型【可以不必继承重写方法，只要方法名相同，动态语言的特性】）

　　意味着允许不同类的对象对同一信息做出不同的反应。

　　分类：

　　　　　　编译时多态：设计时多态，方法重载

　　　　　　运行时多态：程序运行时动态决定调用哪个方法

　　Java多态必要条件：

　　　　　　满足继承关系；

　　　　　　父类引用指向子类对象

二.向上转型和向下转型

　　1.向上转型（隐式转型/自动转型）：

　　　　父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有的方法【小类转型为大类】

　　　　注意：父类中的静态方法无法被子类重写，所以向上转型之后，只有调用父类原有的静态方法（如果想调用子类的静态方法就得向下转型）

 　　2.向下转型（强制类型转换）：

　　　　 子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法【 必须满足转换条件才能进行强制转换】

package com.swpu.test;

import com.swpu.plo.Animal;
import com.swpu.plo.Cat;
import com.swpu.plo.Dog;

public class Test {

    public static void main(String[] args) {
        /**
         * 向上转型，隐式转型，自动转型
         * 父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有的方法
         * 【小类转型为大类】
         */
        Animal one =new Animal();
        Animal two=new Cat();
        Animal three=new Dog();
        one.eat();
        //无法调用Cat和Dog独有的方法
        two.eat();
        three.eat();
        /**
         * 输出：
         * 所有的动物都要吃东西
               小猫吃东西！！！
               狗吃东西！！！

         */
        System.out.println("**************");
        
        /**
         * 向下转型，强制类型转换
         * 子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法
         * 必须满足转换条件才能进行强制转换
         */
        Cat tmp=(Cat)two;
        tmp.eat();
        tmp.run();
        //会报错，Cat和Dog没有关系，能转换为Cat是因为two原来指向的就是Cat空间【相当于还原】
//        Cat tmp2 =(Dog)two;
        
        

    }

}

 　　3.instanceof：判断对象是否是某个类的实例

　　　　注：相当于Python中的isinstance方法（会检查继承链，肯定是所实例类的对象实例，也是其所继承类的实例），而Python中type只判断是否指向同一个对象（不会检查继承链）

　　　　

　　　　

    if(two instanceof Cat){
            Cat tmp=(Cat)two;
            tmp.eat();
            tmp.run();
            System.out.println("我是猫对象");
        }
        
        if (two instanceof Dog){
            Dog tmp=(Dog)two;
            tmp.eat();
            tmp.sleep();
            System.out.println("我是狗对象");
        }
        if (two instanceof Animal){
            System.out.println("我是Animal对象");

            
        }
        if (two instanceof Object){
            System.out.println("我是Object对象");

        }
        /*输出：
         *  小猫吃东西！！！
            小猫跑步~~~
            我是猫对象
            我是Animal对象
            我是Object对象

         */
                
        

 　　4.类型转换总结：

 　　

　　　　注意：父类的静态方法不能在子类中被重写，可以同名（但是不构成重写，是子类特有的静态方法）

　　5.instanceof使用例子：

package com.swpu.plo;

public class Master {
    /**
     * 猫：吃完东西就跑
     * 狗：吃完东西就睡觉
     * 如果有很多动物，则需要一直重载方法
     */
    //方案一：编写方法，传入不同类型得动物，调用各自的方法
//    public void feed(Cat cat){
//        
//        cat.eat();
//        cat.run();
//    }
//    public void feed(Dog dog){
//            
//        dog.eat();
//        dog.sleep();
//        }
    /**
     * 使用instanceof
     */
    //方案二：编写方法传入动物的父类，方法中通过类型的转换，调用指定子类的方法
    //视情况用不同的方案
    public void feed(Animal obj){
        obj.eat();
        if(obj instanceof Cat){
            Cat tmp=(Cat)obj;
            //tmp.eat();
            tmp.run();
        }
        else if(obj instanceof Dog){
            Dog tmp=(Dog)obj;
            //tmp.eat();
            tmp.sleep();
        }
    }
    
    /**
     * 饲养何种动物
     * 时间多：养狗
     * 时间少：养猫
     */
    //方案一
    public Dog hasManytime(){
        System.out.println("时间多，养狗");
        return new Dog();
    }
    public Cat hasLittletime(){
        System.out.println("时间少，养猫");
        return new Cat();
    }
    //方案二
    public Animal raise(boolean haManyTime){
        if(haManyTime){
            System.out.println("时间多，养狗");
            return new Dog();
        }
        else{
            System.out.println("时间少，养猫");
            return new Cat();
        }
    }
}

package com.swpu.test;

import com.swpu.plo.Animal;
import com.swpu.plo.Cat;
import com.swpu.plo.Dog;
import com.swpu.plo.Master;

public class MasterTest {

    public static void main(String[] args) {
        Cat cat=new Cat();
        Dog dog=new Dog();
        Master master=new Master();
        master.feed(cat);
        master.feed(dog);
        System.out.println("**************");
        boolean hasManyTime=true;
//        if(hasManyTime){
//            master.hasManytime();
//        }
//        else{
//            master.hasLittletime();
//        }
        Animal tmp=master.raise(hasManyTime);
        
        

    }

}

 三.抽象类和抽象方法

　　1.抽象类：加关键字abstract

　　　　不允许实例化，可以通过向上转型指向子类实例。

　　　　注：Python中使用abc模块实现抽象基类和抽象方法，但是抽象基类仍然可以是实例化，但抽象方法必须被重写。

　　　　

 无法调用抽象类Animal（如果要用，可以向上转型，Animal one=new Cat();）

　　2.抽象方法：　

　　　　不允许包含方法体且抽象方法需要在抽象类中，子类当中需要重写父类的方法，否则子类也是抽象类。　

　　3.总结：

　　　　abstract定义抽象类；

　　　　抽象类不能直接实例化，只能被继承，可以通过向上转型完成对象实例；

　　　　abstract定义抽象方法，不需要具体实现；

　　　　包含抽象方法的类是抽象类；

　　　　抽象类中可以没有抽象方法；

　　　　static（不允许子类重写），final（最终得，不能改变），private（私有的，只能当前类使用）不能和abstract并存。

 四.接口

　　如电脑，手机，只能表都有照相的功能，如果分别写，则需要给每个类定义照相的方法。

　　1.定义接口并测试：

　　　　建立关系，把接口引用指向实现类的方式，从而完成不同的功能

　　　　1.1接口定义：

package com.swpu.photos;
//定义接口
public interface Iphoto {
    //具有照相功能
    public void photo();

}

　　　　1.2重写接口方法：

package com.swpu.photos;

public class Computer implements Iphoto {
    public void game() {
        System.out.println("电脑可以玩游戏");

    }

    @Override
    public void photo() {
        System.out.println("电脑也可以照相");

    }
}

package com.swpu.photos;

public class Phone implements Iphoto{
    public void phone(){
        System.out.println("手机可以打电话");
    }
    @Override
    public void photo() {
        System.out.println("手机可以照相");
        
    }
}

package com.swpu.photos;

public class Watch implements Iphoto{
    public void times() {
        System.out.println("智能手表可以看时间");
        
    }
    @Override
    public void photo() {
        System.out.println("智能手表也可以照相");
        
    }

}

　　　　1.3测试：

package com.swpu.test;

import com.swpu.photos.Computer;
import com.swpu.photos.Iphoto;
import com.swpu.photos.Phone;
import com.swpu.photos.Watch;

public class Test1 {
    public static void main(String[] args){
        Iphoto ip=new Phone();
        ip.photo();
        ip =new Computer();
        ip.photo();
        ip=new Watch();
        ip.photo();
    }
    

}
/**
 * 输出：
 *  手机可以照相
    电脑也可以照相
    智能手表也可以照相
**/

　　2.接口成员：

　　　　2.1接口规则：

　　　　　　接口定义了某一批类所需要遵守的规范；

　　　　　　接口不关心这些类的内部数据，也不关心这些类里的方法的实现细节，它只规定这些类里必须提供什么方法。　

　　　　　　注：

　　　　　　　　接口最好以I开头【规范】，接口访问修饰符只能是public或者是默认的；

　　　　　　　　接口当中抽象方法可以不写abstract关键字，修饰符可以不写public【默认也会使用public】；

　　　　　　　　当类实现接口时，需要去实现接口中的所有抽象方法，否则可以将类定义为抽象类不重写，继续延续下去；

　　　　　　　　接口中可以定义常量 ，默认public static final,可以用接口名(引用)加常量直接访问(INet.TMP)；

　　　　　　　　如果实现类和接口中的有同名的常量，如果是接口引用指向实现类，调用的是接口的常量，如果是实现类引用指向实现类实例，则是实现类中的常量　　　

package com.swpu.photos;

//接口最好以I开头【规范】，接口访问修饰符只能是public或者是默认的
public interface INet {
    // 接口当中抽象方法可以不写abstract关键字，修饰符可以不写public【默认也会使用public】
    // 当类实现接口时，需要去实现接口中的所有抽象方法，否则可以将类定义为抽象类不重写，继续延续下去
    public void net();
    public void connection();

    // 接口中可以定义常量 ，默认public static final,可以用接口名(引用)加常量直接访问(INet.TMP)
    // 如果实现类和接口中的有同名的常量，如果是接口引用指向实现类，调用的是接口的常量，如果是实现类引用指向实现类实例，则是实现类中的常量
    int TMP = 20;
}

 　　3.默认方法和静态方法：

　　　　3.1默认方法：　　

　　　　　　default：默认方法 可以带方法体 JDK1.8后新增；
　　　　　　可以在实现类中重写，并可以通过接口的引用调用。

　　　　3.2静态方法：　　　　

　　　　　　static：静态方法 可以带方法体 JDK1.8后新增；
　　　　　　不可以在实现类中重写，可以使用接口名调用。

　　　　3.3例：　　

package com.swpu.photos;

//接口最好以I开头【规范】，接口访问修饰符只能是public或者是默认的
public interface INet {
    // 接口当中抽象方法可以不写abstract关键字，修饰符可以不写public【默认也会使用public】
    // 当类实现接口时，需要去实现接口中的所有抽象方法，否则可以将类定义为抽象类不重写，继续延续下去
    public void net();

    // 接口中可以定义常量 ，默认public static final,可以用接口名(引用)加常量直接访问(INet.TMP)
    // 如果实现类和接口中的有同名的常量，如果是接口引用指向实现类，调用的是接口的常量，如果是实现类引用指向实现类实例，则是实现类中的常量
    int TMP = 20;
    //default：默认方法  可以带方法体 JDK1.8后新增
    //可以在实现类中重写，并可以通过接口的引用调用
    default void connection(){
        System.out.println("我是接口中的默认方法");
    }
    //static：静态方法 可以带方法体  JDK1.8后新增
    //不可以在实现类中重写，可以使用接口名调用
    static void stop(){
        System.out.println("我是接口中的静态方法");
    }
}

package com.swpu.photos;

public class Phone implements INet{
    public void phone(){
        System.out.println("手机可以打电话");
    }
    @Override
    public void net() {
        System.out.println("手机能上网");
    }
    @Override
    public void connection() {
        INet.super.connection();//调用接口中默认方法
    }
    
    
}

 　　　　3.4处理多接口同名的默认方法：

　　　　　　需要在子类中重写同名方法。

package com.swpu.photos;

//接口最好以I开头【规范】，接口访问修饰符只能是public或者是默认的
public interface INet {
    // 接口当中抽象方法可以不写abstract关键字，修饰符可以不写public【默认也会使用public】
    // 当类实现接口时，需要去实现接口中的所有抽象方法，否则可以将类定义为抽象类不重写，继续延续下去
    public void net();

    // 接口中可以定义常量 ，默认public static final,可以用接口名(引用)加常量直接访问(INet.TMP)
    // 如果实现类和接口中的有同名的常量，如果是接口引用指向实现类，调用的是接口的常量，如果是实现类引用指向实现类实例，则是实现类中的常量
    int TMP = 20;
    //default：默认方法  可以带方法体 JDK1.8后新增
    //可以在实现类中重写，并可以通过接口的引用调用
    default void connection(){
        System.out.println("我是INet接口中的默认方法");
    }
    //static：静态方法 可以带方法体  JDK1.8后新增
    //不可以在实现类中重写，可以使用接口名调用
    static void stop(){
        System.out.println("我是接口中的静态方法");
    }
}

package com.swpu.photos;
//定义接口
public interface Iphoto {
    //具有照相功能
    public void photo();
    default void connection(){
        System.out.println("我是Iphoto接口中的默认方法");
    }


}

package com.swpu.photos;

public class Phone implements INet,Iphoto{
    public void phone(){
        System.out.println("手机可以打电话");
    }
    @Override
    public void net() {
        System.out.println("我是INet接口中的方法，手机能上网");
    }
    @Override
    public void connection() {
        System.out.println("我自己的collection方法 ");
    }
    @Override
    public void photo() {
        System.out.println("我是Iphoto接口中的方法，我可以照相");
        
    }
    
    
}

　　　　3.5注：

　　　　　　可以继承加实现接口（注继承要在实现类前，如public class Phone extends Tel implements IPhoto,INet(){}，只能继承一个类，当可以实现多个接口）

　　　　　　如果继承的类里面和实现的接口里面有同名的方法，默认指向父类当中的方法。

　　　　3.6处理多接口同名的常量：

　　　　　　需要明确表明是哪个接口中的常量。

package com.swpu.test;
interface one{
    static int x=10;
}
interface two{
    static int x=20;
}

public class Test2 implements one,two{
    public void test(){
        System.out.println(one.x);
        System.out.println(two.x);
    }
    public static void main(String[] args){
        new Test2().test();
    }

}

 　　　　　　如果继承的类里面和实现的接口有同名的常量：无法像同名方法那样默认为父类，需要自己在实现类中从新定义常量才不会报错。

　　4.接口的继承：

　　　　　接口的继承可以继承多个接口，如果有重名的默认方法，需要在子接口中自定义。　

package com.swpu.photos;

public interface ISon extends IFather1,IFather2{
    void fly();
    void run();
}

 五.内部类

　　1.含义：

　　　　在Java中，可以将一个类定义在另一个类里面或者方法里面，这样的类被称为内部类。与之对应，包含内部类的类被称为外部类。

　　2.作用：

　　　　内部类隐藏在外部类之内，更好的实现消息隐藏。

　　3.内部类分类：

　　　　成员内部类；静态内部类；方法内部类；匿名内部类

　　　　3.1成员内部类：

　　　　　　内部类中最常见的，也成为普通内部类。

package com.swpu.people;
//外部类
public class Person {
    int age;
    public Heart getheart(){

        return new Heart();
    }
    public void eat(){
        System.out.println("吃东西");
    }
    //成员内部类
    /*
     * 1.内部类在外部使用时，无法直接实例化，需要借由外部信息才能完成实例化；
     * 2.内部类的访问修饰符可以任意。但是访问范围会受到影响;
     * 3.内部类可以直接访问外部类的成员；如果出现同名的属性，优先访问内部类定义的；
     * 4.可以通过外部类.this.成员的方式，访问外部类中同名的信息；
     * 5.外部类访问内部类信息，需要通过内部类实例，无法直接访问；
     * 6.内部类编译后.class文件命名：外部类$内部类.class
     */
    class Heart{
        public void eat(){
            System.out.println("我是内部类里的吃东西");
        }
        public String beat(){
            //调用外部类的eat方法
            Person.this.eat();
            return age+"heart is running";
        }
    }

}

package com.swpu.people;

public class PeopleTest {

    public static void main(String[] args){
        Person p1=new Person();
        p1.age=15;
        /**
         * 获取内部类对象实例：
         *     方式一：new 外部类.new 内部类
         * 
         */
        Person.Heart heart=new Person().new Heart();
        System.out.println(heart.beat());
        //方式二：外部类对象.new 内部类
        heart =p1.new Heart(); 
        System.out.println(heart.beat());
        //方式三：外部类对象.获取方法
        heart =p1.getheart();
        System.out.println(heart.beat());

    }
}

　　　　3.2静态内部类：

　　　　　　静态内部类对象可以不依赖于外部类对象直接创建。

package com.swpu.people;
//外部类
public class Person {
    int age;
    public Heart getheart(){

        return new Heart();
    }
    public void eat(){
        System.out.println("吃东西");
    }
    /*
     * 静态内部类：
     *     1.静态内部类中，只能直接访问外部类的静态方法，如果需要调用非静态方法可以通过对象实例调用
     */
    static class Heart{
        static void say(){
            System.out.println("Hello");
        }
        public String beat(){
            //调用外部类的eat方法
            new Person().eat();
            return new Person().age+"heart is running";
        }
    }

}

package com.swpu.people;

public class PeopleTest {

    public static void main(String[] args){
        Person p1=new Person();
        p1.age=15;
        /*
         * 获取静态内部类实例的方法:
         *     1.静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例；
         *  2.静态内部类对象实例时，可以不依赖于外部类对象；
         *  3.可以通过外部类.内部类.静态成员的方式，访问内部类的静态成员；
         *  4.当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；
         *      如果需要访问外部类中的静态属性，则可以通过   外部类.属性   的方式
         *      如果需要访问外部类中的非静态属性，则可以通过   new 外部类().属性   的方式
         * 
         */
        Person.Heart heart=new Person.Heart();
        System.out.println(heart.beat());
        Person.Heart.say();
    }
}

　　　　3.3方法内部类：

　　　　　　定义在外部类方法中的内部类，也称局部内部类。

package com.swpu.people;
//外部类
public class Person {
    int age;
    public void eat(){
        System.out.println("吃东西");
    }
    
    public Object getheart(){
        /*
         * 方法内部类：
         *     1.定义在方法内部，作用范围也在方法内；
         *     2.和方法内部成员使用规则一样，class前面不能加public，private，protected，static；
         *     3.类中不能包含静态成员’
         *     4.类中可以包含final，abstract修饰的成员（不推荐）
         * 
         */
       class Heart{
            public void say(){
                System.out.println("Hello");
            }
            public String beat(){
                //调用外部类的eat方法
                new Person().eat();
                return new Person().age+"heart is running";
            }
    }
    return new Heart().beat();
 
    }

}

package com.swpu.people;

public class PeopleTest {

    public static void main(String[] args){
        Person p1=new Person();
        p1.age=15;
        /*
         * 获取方法内部类
         */
        System.out.println(p1.getheart());
    }
}

　　　　3.4匿名内部类：

　　　　　　没有名字，将类的定义和创建一起完成（如果只用一次可以这样，对系统内存消耗相对较小）

package com.swpu.test;

import com.swpu.people.Man;
import com.swpu.people.Person;
import com.swpu.people.Woman;

public class PersonTest {
    //方案一
    /*
    public void getRead(Man man){
        man.read();
    }
    public void getRead(Woman woman){
        woman.read();
    }
    */
    //方案二
    public void getRead(Person p){
        p.read();
    }
    public static void main(String[] args) {
        PersonTest p1=new PersonTest();
        // TODO Auto-generated method stub
        /*
        Man man=new Man();
        Woman woman =new Woman();
        p1.getRead(man);
        p1.getRead(woman);
        */
        //匿名内部类
        /*
         * 1.匿名内部类没有类型名称，实例对象名称；
         * 2.编译后的文件命名：外部类$数字.class；
         * 3.无法使用private/public/protected/adstract/static等；
         * 4.无法在匿名内部类编写构造方法，可以添加构造代码块；
         * 5.不能出现静态成员
         * 6.匿名内部类可以继承父类，也可以实现接口（但是不能同时实现）
         */
        p1.getRead(new Person(){
            @Override
            public void read() {
                // TODO Auto-generated method stub
                System.out.println("我是匿名内部类");
                
            }
        });
        

    }

}