静态方法，多态，面向对象，抽象类

1.静态方法
静态方法中只能访问静态修饰的变量，不能访问非静态修饰的变量
静态修饰的变量或方法，是随着类的加载而加载，是先于非静态变量的，因此无法访问到。
静态方法中不能调用非静态的方法，因为静态方法是在编译期就存在了，非静态方法在运行期才存在，编译期访问不到，同
静态方法中也不能用this.的形式调用非静态的，因为静态先存在，非静态后存在，this是非静态。

public class Test {
    public static void main(String[] args) {
      Demo a=new Demo();
        System.out.println(a.name);//最好不用对象的方式去调用静态变量，静态变量
                                  //  就使用调用静态方法的办法去调用
        String mingzi=Demo.name;
        System.out.println(mingzi);//用这种办法是最适合的，即类名+静态变量或静态方法
//        静态方法中只能访问静态修饰的变量，不能访问非静态修饰的变量
//        静态修饰的变量或方法，是随着类的加载而加载，是先于非静态变量的，因此无法访问到。
//        静态方法中不能调用非静态的方法，因为静态方法是在编译期就存在了，非静态方法在运行期才存在，编译期访问不到，同理
//        静态方法中也不能用this.的形式调用非静态的，因为静态先存在，非静态后存在，this是非静态。
    }
}

2.多态
A:多态概述
某一个事物，在不同时刻表现出来的不同状态。
举例： Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
B:多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。

ublic class MyTest {
    public static void main(String[] args) {
        //采用多态的形式，去访问成员变量,访问的是父类的成员变量
       /* a:
        成员变量
        编译看左边，运行看左边。
        b:多态形式访问构造方法
      创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
        */
        //
        Fu fu=new Zi();
        System.out.println(fu.num);
        //多态的形式，访问成员方法的特点，如果子类没有重写父类的方法，就以父类的方法为准，如果子类重写了父类的方法，那么运行时，会以子类重写过后的为准。
       /* c:
        成员方法
        编译看左边，运行看右边。*/
        fu.show();

        System.out.println("=========================");

        //静态方法
        fu.fuJingTai();
        Fu.fuJingTai();
    }
}
class Fu{
    int num=20;

    public Fu() {
        System.out.println("父类的构造方法执行了");
    }
    public void show(){
        System.out.println("父类的show方法");
    }

    public static void fuJingTai() {
        System.out.println("父类的静态方法");
    }
}

class Zi extends Fu{
    int num=200;
    int aa=10;

    public Zi() {
        super();
        System.out.println("子类的构造方法执行了");
    }

    @Override
    public void show() {
        System.out.println("zi show  ");
    }

}

3.面向对象
A:多态中的成员访问特点
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

public static void main(String[] args) {
        //面向对象的三大特征；封装（类） 继承（extends）多态
        //多态：指的是一种事物，在不同时期，所表现出的不同状态。
        // 猫 就是 一只猫，猫是一只动物
        // Cat cat=new Cat();
        //   Aniaml an=new Cat();
        // 狗就是狗类型，狗是动物类型。
        // Dog  dog= new Dog();
        // Aniaml an=new Dog()

        //多态的前提：要有继承，如果没有继承多态就无从谈起。
        //多态要有方法重写，当然不重写，语法上来说不报错，但是失去了多态的意义。
        //父类引用指向子类对象。
        Cat cat = new Cat();
        cat.eat();
        System.out.println("=====================");
        //多态:父类引用 指向子类对象。
        Animal an=new Cat();
        an.eat();

    }
}

class Animal{
    public void eat(){
        System.out.println("吃饭");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃小鱼干");
    }
}

4.抽象类
1.抽象类概述
Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
2.抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法

public class MyTest {
    public static void main(String[] args) {
        //抽象类，不能直接创建对象
        // Animal animal = new Animal();
         // animal.eat();
      Animal an=  new Cat();
      an.eat();
      an.sleep();
      an=new Dog();
      an.eat();
      an.sleep();
      //父类把所有子类的共享内容向上抽取出来，但是父类不知道，子类对共性功能的具体实现，所以父类只需要给出功能的声明，而不需给出功能的具体实现，那功能的具体实现，应该交由子类按照自身的需求和差异，去做具体的实现。

    }
}
abstract class  Animal{
    //抽象出来，不需要给出功能的具体，实现，而是由子类，根据自身的差异性，对这个功能进行具体的而实现
    //一旦一个类中，有了抽象方法该类必须为抽象类
    //父类中的抽象方法，是强制子类必须重写
    public abstract void eat();
    public abstract void sleep();
}

class Cat extends Animal{


    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫爱白天睡觉");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗看门，不睡觉");
    }
}