java的多态和构造方法

---恢复内容开始---

Java多态

多态是继封装，继承之后，面向对象的第三大特性

多态最终呈现为父类引用指向子类对象

多态的前提是必须有子父类继承的关系

使用多态后的父类引用变量调用方法时，会调用子类重写之后的方法

多态的定义格式和使用格式：

多态的定义格式：就是父类的引用变量指向子类对象

父类类型  变量名 = new 子类类型();
变量名.方法名();

普通类多态的定义格式：

父类 变量名 = new 子类();
如：    class Fu {}
    class Zi extends Fu {}
    //类的多态使用
Fu f = new Zi();

抽象类定义多态的格式：

抽象类 变量名 = new 抽象类子类();
如：    abstract class Fu {
         public abstract void method();
         }
class Zi extends Fu {
public void method(){
              System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();

接口多态的定义格式：

接口 变量名 = new 接口实现类();
如： interface Fu {
             public abstract void method();
}
class Zi implements Fu {
             public void method(){
              System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();

注意事项：同一个父类的方法会被不同的子类重写，当变量名指向不同的子类对象时，由于每个子类重写父类方法的内容不同，所以会调用不同的方法

多态成员的特点：

多态成员变量

　　编译时期：参考引用型变量所属的类中是否被调用的成员变量

　　运行时期：调用引用型变量所属的类中的成员变量

　　总结：编译运行看左边

多态成员方法：

　　编译时期：参考引用变量所属的类，如果类中没有调用的方法，编译失败

　　运行时期：参考引用变量所致的对象所属的类，并运行对象所属类中的成员方法

　　总结：编译看左边，运行看右边

instanceof关键字：

作用：用来浦安端某个对象是否属于某种类型。格式：boolean b=对象 instabceof 数据类型；

Person p1 = new Student();
boolean flag = p1 instanceof Student; //true
boolean flag2 = p1 instanceof Teacher; //false

多态转型：

向上转型：子类对象赋值给父类引用就是向上转型，多态本身即是向上转型的过程

格式：父类类型变量名=new 子类类型（）

向下转型：通过向上转型创建出来的父类对象，只能使用父类里面的方法，要想使用子类独有的方法必须强制转变为子类引用，这个过程就是向下转型，

格式：

子类类型变量名= （子类类型）父类类型的变量；

多态的好处和弊端：

当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。

弊端，只能使用父类共性的内容，而无法使用子类特有功能，功能有限制

//描述动物类，并抽取共性eat方法
abstract class Animal {
    abstract void eat();
}
 
// 描述狗类，继承动物类，重写eat方法，增加lookHome方法
class Dog extends Animal {
    void eat() {
        System.out.println("啃骨头");
    }

    void lookHome() {
        System.out.println("看家");
    }
}

// 描述猫类，继承动物类，重写eat方法，增加catchMouse方法
class Cat extends Animal {
    void eat() {
        System.out.println("吃鱼");
    }

    void catchMouse() {
        System.out.println("抓老鼠");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog(); //多态形式，创建一个狗对象
        a.eat(); // 调用对象中的方法，会执行狗类中的eat方法
        // a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用
        
        // 为了使用狗类的lookHome方法，需要向下转型
// 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常
        // 那么，在转之前需要做健壮性判断 
        if( !a instanceof Dog){ // 判断当前对象是否是Dog类型
                 System.out.println("类型不匹配，不能转换"); 
                 return; 
        } 
        Dog d = (Dog) a; //向下转型
        d.lookHome();//调用狗类的lookHome方法
    }
}

总结：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型

当要使用子类特有功能时，就需要使用向下转型

向下转型的好处：可以使用子类中独有的方法

弊端：向下转型的是很容易放生类型转换异常，因此需要在转化之前使用instanceof来判断一下数据类型

总结封装继承多态的作用：

封装：吧对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式

继承：子类自动继承父类所有可继承的属性和方法

多态：配合继承和方法重写提高了代码的复用性和扩展型，如果没有方法重写，则多态同样没有意义

====================================================================================================================================

构造方法：在用new创建对象的同时赋给对象明确的初始值（对象创建时要执行的方法）

构造方法的格式：

修饰符 构造方法名(参数列表)
{
}

构造方法的体现：

1.构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束

2.构造方法的名称必须和类名一样

3.构造方法没有具体的返回值

构造方法代码例子：

package com.oracle.demo12;

public class person {
    //person的成员变量
    private String name;
    private int age;
    //person的构造方法
    public person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //person的成员方法
    public void work(){
        System.out.println(age+"岁的"+name+"在修车");
    }
}

构造方法调用：

package com.oracle.demo12;

public class man {
    public static void main(String[] args) {
        //new新对象的时候同时赋值
        person p1=new person("张三",20);
        p1.work();
    }
}

默认构造方法和细节：

class  Person {
    //如果没有显示指定构造方法，编译会在编译时自动添加默认的构造方法
    //Person(){}  //空参数的默认构造方法
}

细节：

1.一个类中可以有多个构造方法，多个构造方法是以方法重载的形式存在的

2.构造方法是可以用private修饰的，作用是不让其他程序创建该类的对象

构造方法和一般方法的区别：

构造方法是在创建新对象的时候调用，而且只用一次

一般方法实在对象创建完后，需要使用了就调用，可以用多次

---恢复内容结束---