java面向对象多态

java面向对象多态

多态就是某一个事物，在不同的时态的不同表达，比如猫，鱼，老虎都是动物类，你去家里看的就是猫，水里看的就是鱼，动物园看的就是老虎。
多态格式:  父类 对象名=new 子类  
多态的条件:1.多态的前提是继承
		  2.要有方法的重写，可以不重写，但就没有意义了
		  3.要有父类引用指向子类

多态中的成员变量访问

成员变量：
	编译看左边，运行看左边
成员方法:
	编译看左边，运行看右边
构造方法:
	创建子类对象时候，会访问父类的构造方法，对父类的数据进行初始化
静态方法:
	编译看左边，运行看左边(静态方法属于类方法，算不上重写，所以运行的时候还是左边)
左边值的是父类，右边值的是子类
eg: Animal cat=new Cat();

class Animal{
    String name;
    int age=5;
    Animal(){
        System.out.println("=============");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public static void eat(){
        System.out.println("吃饭");
    }
}
class Cat extends Animal{
    String name;
    int age=3;
    Cat(){
        System.out.println("11111111111111");
    }
    public void sleep(){
        System.out.println("小猫睡觉觉");
    }
    public static void eat(){
        System.out.println("小猫吃饭饭");
    }
}
class MyTest{
    public static void main(String[] args){
        Animal cat=new Cat();      //调用构造方法  结果会先打印Animal类空参构造方法中的话，再打印                                    //Cat类空参构造方法中的话
        System.out.println(cat.age);   //调用成员变量  结果是5  ，所以对应了上面说的调用成员变量编                                         //译看左边，运行看左边
        cat.sleep;  //调用成员方法  打印小猫睡觉觉
        cat.eat;    //调用静态方法  打印吃饭，调用静态方法一般都是类名.方法，                                          //这里是为了说明上面的列子
        
    }
}

向下转型

多态的优点:提高代码的复用性(继承)
		 提高了代码的扩展性(多态)
多态的弊端:就是不能调用子类特有的方法，所以为了解决这个问题，java中可以用向下转型来解决
向下转型:把父类引用，向下转换为子类型
eg： Animal cat=new Cat();
     Cat son=(Cat) cat;

class Animal{
    public void sleep(){
        System.out.println("睡觉")；
    }
}
class Cat extends Animal{
    public void sleep(){
        System.out.println("小猫睡觉觉")；
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}
class MyTest{
    public static void main(String[] args){
        Animal cat=new Cat();    //此时如果想要调用cat类中的catchMouse方法就需要向下转型，如果继续                                   //使用多态来调用就调用不到       多态就是向上转型
        Cat son=(Cat) cat;
        son.catchMouse();
    }
}

抽象类

抽象类就是将子类共性的部分向上抽取，抽取到父类，父类却不知道这些子类的共性功能该如何实现，所以父类没有必要给出子类共性功能的实现
抽象类的特点:
	1.抽象类和抽象方法必须用abstrac关键字修饰
	2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
	3.抽象类可以有构造方法，但是不能实例化，作用是子类访问父类数据时的初始化
	4.抽象类不能实例化，可以通过多态的方式，由具体的子类实例化
	5.抽象类的子类   要么时抽象类，要么重写抽象类中的抽象方法
抽象类成员特点:
	1.成员变量可以是变量，也可以是常量
	2.构造方法:可以有，用来子类访问父类数据的初始化
	3.成员方法:可以是抽象的，也可以时非抽象的，抽象方法子类都要重写，时抽象类强制子类做的，非抽象方法子类继承的事情，提高代码的复用性

abstract class Animal{
    String name;
    int age;
    final static int a=5;           //抽象类中可以有变量和常量
    Animal(){}
    Animal(String name,int age){         
        this.name=name;
        this.age=age;                     //抽象类中可以有构造方法，用来子类访问父类数据的初始化
        System.out.println(this.name);    //抽象类中写了构造方法，子类必须也写出构造方法
        System.out.println(this.age);
    }
    public abstract void eat();
    public void sleep(){                //抽象类中可以有抽象方法和非抽象方法
        System.out.println("睡觉");
    }
}
class Cat extends Animal{
    Cat(){}
    Cat(String name,int age){          
        super(name,age);
    }
    public void eat(){
        System.out.println("吃小鱼干");
    }
}
class MyTest{
    public static void main(String[] args){
        Animal cat=new Cat();         //抽象类通过多态形式进行实例化
        Animal cat1=new Cat("小猫",4);    //调用Animal的构造方法               
        cat.eat();                 
    }
}

abstract关键字

用来定义抽象方法，抽象类的关键字
abstract不能和final、private、static 共存
原因: 1.final修饰的类不能被继承，修饰的变量是常量，修饰的方法不能被重写，所以和abstract冲突
	2.private修饰的类是内部类、修饰的方法、属性只能在本类中访问，所以重写后不能访问到这些方法和属性
	3.static修饰的方法是静态的，是类直接调用，abstract修饰的抽象方法没有方法体不能够直接调用，需要通过类的继承或接口的实现来重写抽象方法后才能使用