static、多态（Java学习第二十天）

static 关键字是静态的意思，可以修饰成员方法、成员变量

static修饰的特点

1、被类的所有对象共享（也是判断是否使用静态关键字的条件）

2、可以通过类名调用（推荐，因为还能通过）。

package day20b;

public class Student {
     public String name;
     public int age;
     //实例共享属性
     public static String gender;
     public void show(){
         System.out.println(name+age+gender);
     }

}


package day20b;

public class Person {
    public static void main(String[] args) {
        //推荐用类名调用
        Student.gender = "女";
        Student p1 = new Student();
        p1.name = "1";
        p1.age = 22;
        //不推荐对象调用
        //p1.gender = "男";
        p1.show();


        Student p2 = new Student();
        p2.name = "2";
        p2.age = 23;
        p2.show();
    }
}

static访问特点

非静态的成员方法：

1、能访问静态的成员变量；

2、能访问非静态的成员变量；

3、能访问静态的成员方法；

4、能访问非静态的成员方法

静态的成员方法:

1、能访问静态的成员变量；

2、能访问静态的成员方法；

静态成员方法只能访问静态成员

package day20b;

public class Student1 {
    //两个成员变量，静态和非静态
    private String name = "gw";
    private static int age = 22;

    //非静态成员方法
    public void show1(){
        System.out.println(name);
        System.out.println(age);
        show2();
        show3();
        show4();
    }
    public void show2(){

    }
    //静态成员方法
    public static  void show3(){
        //System.out.println(name);
        System.out.println(age);
        //show1();
        show3();
    }
    public static  void show4(){

    }


}

多态：同一个对象，在不同时刻体现出来的不同形态

多态的前提和体现：

1、有继承/实现管理；

2、有方法重写；

3、有父类引用指向子类对象

举例说明 

package day20b;

public class Animal {
    public void  eat(){
        System.out.println("这是动物！");
    }
}


package day20b;

public class Dog extends  Animal{
    @Override
    public void eat() {
        System.out.println("狗吃屎");
    }
}



package day20b;

public class Result {
    public static void main(String[] args) {
        //注意这里是父类的引用，指向子类的对象
        Animal d = new Dog();
    }
}

多态中成员访问特点

成员变量： 编译看左边，执行看左边

成员方法：编译看左边，执行看右边

两个执行不一样的原因是： 因为成员方法有重写，成员变量没有

package day20b;

public class Animal {
    public String name = "动物";

    public void  eat(){
        System.out.println("这是动物！");
    }
}
package day20b;

public class Dog extends  Animal{
    public String name = "猫";
    @Override
    public void eat() {
        System.out.println("狗吃屎");
    }
}
package day20b;

public class Result {
    public static void main(String[] args) {
        //注意这里是父类的引用，指向子类的对象
        Animal d = new Dog();
        d.eat();
        System.out.println(d.name);
    }
}

多态的好处和弊端：

多态的好处：提高了程序的扩展性

多态的弊端： 不能使用子类的特有功能

举例如下：

package day20b;

public class Animal {
    public String name = "动物";

    public void  eat(){
        System.out.println("这是动物！");
    }
}

package day20b;

public class Dog extends  Animal{
    public String name = "猫";
    @Override
    public void eat() {
        System.out.println("狗吃屎");
    }
}


package day20b;

public class Pig extends Animal{
     public  void  eat(){
         System.out.println("猪吃白菜");
     }
     public void hobby(){
         System.out.println("睡觉，等死");
     }
}


package day20b;

public class AnimalDemo {
    public void  show(Animal a ){
        a.eat();
    }
}



package day20b;

public class Result {
    public static void main(String[] args) {
        //注意这里是父类的引用，指向子类的对象
        AnimalDemo ad = new AnimalDemo();
        Dog d = new Dog();
        ad.show(d);

        Pig p = new Pig();
        ad.show(p);
        //会报错，因为没办法调用子类的特有功能
        //ad.hobby();
    }
}