修饰符static

修饰符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); 
    }
}

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

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

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();//继承自抽象类的普通方法
    }
}

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