1、static属性

1.static属性的用途

· static被称为静态，可以用来修饰类的属性和方法。

·如果类的某个属性，不管创建多少个对象，属性的存储空间只有唯一的一个，那么这个属性就应该用static修饰，被static修饰的属性被称为静态属性。

2.静态成员的访问

（1）对象.静态成员

System.out.println(emp1.count);

（2）类.静态成员

System.out.println(Emp.count);

问题：为什么几种不同的访问方式下，静态属性count的值都一样？

（1）静态成员是属于类的。

（2）类的对象可以共享类的静态成员。

2、static方法

用途：

·如果某个方法不需要与某个特定的对象绑定，那么该方法可以使用static修饰，被static修饰的方法称为静态方法。

·基本结构如下：

访问权限 static修饰符 返回值类型 方法名称

public static void sellticket(){
  System.out.println("所有车票都是12306卖的");
}

静态方法的定义

public class Math {
    public static int add(int a ,int b) {
        return a + b;
    }
}

静态方法的调用：类.方法名()

public class Client {
    public static void main(String[] args) {
        int c = Math.add(1,2);
        System.out.println(c);
    }
}

区别：静态方法与非静态方法的调用

静态方法的调用：类.方法名()

非静态方法的调用：先实例对象，在对象.方法名()

3、常用系统中的静态方法

                //Math类的静态方法
        System.out.println( Math.abs(-1));
        System.out.println(Math.random());
        
        //Math类中的静态属性
        System.out.println(Math.PI);
        System.out.println(Math.E);
        
        //包装类中的静态属性
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        
        //包装类中的静态方法
        System.out.println(Integer.valueOf(10));
        System.out.println(Integer.parseInt("10"))

4、static块

定义：static块和static的属性以及方法的性质是相同的，用static修饰的代码块表示静态代码块，当Java虚拟机加载类时，就会执行该代码块。

区别在于语法不同

static块语法：

直接在代码块前，加上关键词static即成为静态块。

static{
      System.out.println("123");
}

static块的用途：

·静态块只有在类加载的时候被执行一次，不管创建多少个对象，都不会再执行。

·如果一个类加载的时候，总要预先做一些事情，则可以放在静态块中。例如，读取一个属性文件，进行一些常规配置，写一些日志等。

·一个类可以有多个静态块，按照顺序执行。

public class Demo {
    
    public static int count;
    
    {
        //实例块
        System.out.println("我是实例块");
    }
    
    static {
        //静态块
        //初始化静态属性
        Demo.count = 1;
        
        System.out.println("我是静态块1");
    }
    static {
        //静态块
        System.out.println("我是静态块2");
    }
    static {
        //静态块
        System.out.println("我是静态块3");
    }
}

public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo demo1 = new Demo();
        Demo demo2 = new Demo();
        Demo demo3 = new Demo();
        
        //1.静态块在类加载的时候加载一次，和对象的创建个数无关
        //2.静态块在实例块之前调用
        //3.如果一个类中有多个静态块，它们会顺序执行    
    }
}

运行结果：
我是静态块1
我是静态块2
我是静态块3
我是实例块
我是实例块
我是实例块

5、静态类（只能是内部类，外部类不允许static修饰）

static类基本语法：

public class Outer {
    
    //静态内部类
    static class Inner{
        
    }
}

public class Client {
    public static void main(String[] args) {
        //语法：外部类.内部类,是把外部类当作特殊的包名来使用
        Outer.Inner inner =new Outer.Inner();
    }
}

static父子类继承：

public class Message {
//父类
    static class TextMessage extends Message{
        //子类
    }
    
    static class VoiceMessage extends Message{
        
    }
}


public class Client {
    
    public static void main(String[] args) {
        //外部类.内部类
        //父类.子类
        Message.TextMessage textMessage =new Message.TextMessage();
    }
}

静态内部类是外部类的实例

//接口：飞
public interface FlyAble {
    
    //静态内部类，是外部类型的实现类
    static class Bird implements FlyAble{
        
    }
    
    static class Leaf implements FlyAble{
        
    }
}

public class Client {
    public static void main(String[] args) {

                //外部类.静态内部类
        //接口.静态内部类
        FlyAble.Bird bird = new FlyAble.Bird();
        FlyAble.Leaf leaf = new FlyAble.Leaf();
    }
}