修饰符static和abstract

static

static可以修饰类中的方法，属性等，被修饰后的方法和属性可以通过类名直接调用也可以通过对象调用。普通的变量只能通过对象进行调用。

静态方法直接可以互相直接调用，非静态方法也可以直接调用静态方法，但是静态方法不能直接调用非静态方法。

eg：

package shiyan;

public class Person {

    public static int age; //静态属性

    public int score;      //非静态

    public static void go(){ //静态方法

        System.out.println("静态方法");

    }

    public void run()//非静态

    {

        System.out.println("非静态");

    }

    public static void main(String[] args) {

      Person.age=1; //通过类调用

      Person.go(); //通过类调用

      go();     //静态方法互相调用

        Person p1=new Person();//创建对象

             p1.score=22;     //只能通过对象调用

             p1.run();        //只能通过对象调用

             p1.age=1;        //通过对象

             p1.go();         //通过对象

    }

}

静态代码块

在类内将代码通过static{}括起来，在构造器之前执行，仅执行一次。类似的还有匿名代码块{}。

eg：

package shiyan;

public class StaticStatement {

     static {

        System.out.println("静态代码块"); //仅执行一次

            }

       {

           System.out.println("匿名代码块");//每次建对象都执行

       }

          public StaticStatement()  //每次建对象都执行

         {

           System.out.println("构造器");

         }

    public static void main(String[] args) {

        StaticStatement s1=new StaticStatement();

        StaticStatement s2=new StaticStatement();

    }

}

运行结果：

静态代码块

匿名代码块

构造器

匿名代码块

构造器

静态导入包

导入包时，仅仅导入类内的单个方法或属性

导入后可以直接使用该方法，不需要使用类调用方法。

eg：

import static java.lang.Math.random; //静态导入包random

import static java.lang.Math.PI;  //静态导入包 PI为 π是常量

public class Test{

    public static void main(String[] args)

    {

    System.out.print(random());   //直接调用Math类的方法random()

         System.out.print(PI);

    }

}

abstract

abstract抽象类，抽象类不能实例化，他只是一个约束后面可以理解为会有人帮我们实现具体的功能。抽象类里可以有抽象类也可以有普通方法，但是普通类内不能存在抽象方法。

不能new这个抽象类，只能靠子类去实现它：约束！
抽象类中可以写普通方法
抽象方法只能在抽象类中

eg：

//父类：

package shiyan;

public abstract class Abstract {

    public Abstract(){

        System.out.println("Abstract的构造器");

    }

    public static void go(){

        System.out.println("Abstract的普通方法");

    }

    public abstract void run();//仅仅约束，证明有这个方法方法没有实现的方法体

    public static void main(String[] args) {

    }

}

//子类：

package shiyan;

public class  Son extends Abstract {//继承

    @Override

    public void run() { //实现方法

        System.out.println("子类实现父类的抽象方法");

    }

       public Son()

       {

           System.out.println("StaticStatement的构造器");

       }

    public static void main(String[] args) {

    Son s1=new Son();

        s1.run();//抽象方法，实现体已写

        s1.go();//继承自抽象类的普通方法

    }

}

主要还是为了提高效率减少重复的代码，对于可以直接使用的用普通方法可以直接继承使用，对于有变化的可以使用抽象方法每次重新写出实现。