static 关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

static 修饰属性:

属性是否使用static修饰 又分为静态属性和非静态属性(实例变量)    
        实例变量: 我们创建了类的多个对象,每个对象都独立拥有一套类
                 不会导致其他对象中相同的属性值的修改   
        静态变量: 我们创建了类的多个对象, 多个对象共享一个静态变
                 获取到的是修改后的值

一个类的属性被static修饰之后无论实例化多少个对象那么其中的一个对这个属性进行了操作其他的对象获取的是这个被操作后的静态属性

public cl
ass StaticTest {
    public static void main(String[] args) {

        Chinese chineseOne = new Chinese();
        chineseOne.name = "隔壁老王";
        chineseOne.age = 32;


        Chinese chineseTwo = new Chinese();
        chineseTwo.name = "隔壁未婚姐姐";
        chineseTwo.age = 26;
        System.out.println(chineseTwo.nation); // null 现在未进行设置值
    }


}


class Chinese {
    String name;
    int age;
    static String nation;
}

如果类的一个属性加上了static就是静态属性那么无论实例化多少对象都公用这一个属性 ,其中一个改变其他对象调用也随着改变

如上

  Chinese chineseOne = new Chinese();                                     
  chineseOne.name = "隔壁老王";                                               
  chineseOne.age = 32;                                                    
  chineseOne.nation = "CNN";                                              
                                                                          
                                                                          
  Chinese chineseTwo = new Chinese();                                     
  chineseTwo.name = "隔壁未婚姐姐";                                             
  chineseTwo.age = 26;                                                    
  System.out.println(chineseTwo.nation); // CNN  因为是static 的静态属性大家公用一个

static修饰方法

4: static 修饰方法: 静态方法                                                     
          a 随着类的加载而加载, 可以通过"类.静态方法" 来调用                                  
          b  静态方法中只能调用静态的方法或者属性, 非静态的方法中可以调用静态和非静态的                      
          c                                                              
                    类方法      实例方法                                        
             类      yes           no                                     
                                                                         
             对象      yes          yes                                    
                                                                         
静态方法注意点:                                                                 
     在静态方法中不可以使用this关键字,super关键字

static + 方法()

class Chinese {                                                                 
    String name;                                                                
    int age;                                                                    
    static String nation;                                                       
                                                                                
                                                                                
    public  void eat(){                                                         
        System.out.println("吃饭");                                               
    }                                                                           
    public static  void play(){                                                 
       // System.out.println(name);  // 静态方法不可以调用非静态属性和方法                       
        System.out.println(Chinese.nation); // 调用静态属性前面省略的不是this而是类名.           
        walk(); //可以调用静态的方法                                                     
        System.out.println("玩耍");                                               
    }                                                                           
    public static  void walk(){                                                 
        System.out.println("走路");                                               
    }                                                                           
}

在类中如何设计属性和方法是否是static:

类属性的设计思想:

类属性作为该类各个对象之间共享的变量。在设计类时,分析哪 些属性不因对象的不同而改变，将这些属性设置为类属性。相应 的方法设置为类方法。
 如果方法与调用者无关，则这样的方法通常被声明为类方法，由 于不需要创建对象就可以调用类方法，从而简化了方法的调用

开发中如何确认一个属性是否是static 静态的
     属性可以被多个对象所共享,不会随着对象的不同而不同的

开发中如果确定一个方法是否声明为static的
     操作静态属性的方法通常是static的,
     工具类中的方法通过是声明static  eg : Math, Arrays
     类中的常量通常声明为static

static特性:

使用范围:
在Java类中，可用static修饰属性、方法、代码块、内部类
 被修饰后的成员具备以下特点: 
     随着类的加载而加载
     优先于对象存在 修饰的成员，被所有对象所共享 
     访问权限允许时，可不创建对象，直接被类调用

因为static是随着类的创建而加载时优先对象创建的所以他的输出也是优先构造方法先执行的

public class JuneFiveAfternoonTestMain {
    public static void main(String[] args) {
        JuneFiveAfternoonSummary summary = new JuneFiveAfternoonSummary();
    }
}


class JuneFiveAfternoonSummaryFather{
    public JuneFiveAfternoonSummaryFather(){
        System.out.println("我是父类Method");
    }

    static {
        System.out.println("I'm father's static method");
    }
}

class JuneFiveAfternoonSummary extends JuneFiveAfternoonSummaryFather{

    public JuneFiveAfternoonSummary(){
        System.out.println("This is Son's structure method");
    };

    static {
        System.out.println("I'm Son's static method");
    }
}

输出

I'm father's static method
I'm Son's static method
我是父类Method
This is Son's structure method

因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)

 static修饰的方法不能被重写

例题: 编写一个圆类这个圆类的实例后 id自增

public class CircleTest {
    public static void main(String[] args) {
        Cirle circleOne = new Cirle();
        Cirle cirleTwo = new Cirle();
        Cirle cirleThree = new Cirle(3.7);

        System.out.println("circleOne的id:"+circleOne.getId());   // 第一次创建对象就是1001  第二次然后就在这个共有属性上自增
        System.out.println("circleTwo的id"+cirleTwo.getId());
        System.out.println("circleThree的id:"+ cirleThree.getId());
        System.out.println("circle的个数"+cirleTwo.getTotle());
    }

}


class Cirle {
    private double radius;
    private int id;
    private static int totle;  // 记录圆的个数
    private static int init = 1001;

    public Cirle() {
        totle++;
        id = init++;  //id 不停的增加
    }

    public  Cirle(double radius){
        this();
        this.radius = radius;
    }


    public double findArea() {

        return 3.14 * radius * radius;
    }


    public double getRadius() {
        return radius;
    }

    public int getId() {
        return id;
    }

    public int getTotle() {
        return totle;
    }
}

练习:

编写一个类实现银行账户的概念，包含的属性有“帐号”、“密 码”、“存款余额”、“利率”、“最小余额”，定义封装这些 属性的方法。账号要自动生成。
 编写主类，使用银行账户类，输入、输出3个储户的上述信息。 考虑:哪些属性可以设计成static属性。

public class BankTest {
    public static void main(String[] args) {
        Bank bank = new Bank();
        Bank bank1 = new Bank("qwerty", 2000);
        bank.setMiniBalance(0.588);
        System.out.println(bank);
        System.out.println(bank1);
        System.out.println(bank1.getMiniBalance());
    }


}


class Bank {
    private int id;
    private String password = "0000";
    private double balance;
    private static double interest; //利率
    private static double miniBalance;  //最小余额

    public static int init = 1000;  // 用于自动设置id

    public Bank() {
        id = init++;
    }

    public Bank(String password, double balance) {
        this();
        this.password = password;
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public static double getInterest() {
        return interest;
    }

    public static void setInterest(double interest) {
        Bank.interest = interest;
    }

    public static double getMiniBalance() {
        return miniBalance;
    }

    public static void setMiniBalance(double miniBalance) {
        Bank.miniBalance = miniBalance;
    }

    @Override
    public String toString() {
        return "Bank{" +
                "id=" + id +
                ", password=" + password +
                ", balance=" + balance +
                '}';
    }
}

解答

Practices

1. static 修饰的属性，相较于实例变量，有哪些特别之处(>=3点)

随着类的加载而加载；早于对象的创建；
只要权限允许，可以通过”对象.static属性”的方式进行调用；
存在于方法区的静态域

1. static 修饰的属性，相较于实例变量，有哪些特别之处(>=3点)