Java 12 面向对象—参数传递 + 实例代码块

static

static修饰的方法 静态方法
static修饰的属性 静态变量

静态变量在类加载的时候初始化，内存在 方法区中开辟。
所有静态数据，都可以采用类名.名 方式访问，也可以采用对象.名 方式访问。但是不推荐后者。

static修饰和不修饰

声明为实例变量：
所有对象都有该属性，但这个属性值会随着对象变化而变化

声明为静态变量：
所有对象都有这个属性，并且这个属性在所有对象中都是一样的。

package test3;

public class Chinese{


    // 实例变量：一个对象一个实例，100个java对象，就100个实力变量。
    // 实例变量存储在java对象的堆内存当中
    String id;
    String name;

    //中国人国籍为中国，没必要一个对象一个属性，浪费内存，前面加static，变为 类属性
    //加了static 就变成了静态变量，在类加载的瞬间就初始化，不需要创建对象，存储在方法区中。
    static String country = "中国";

    //构造函数
    public Chinese(){
    }

    public Chinese(String id,String name){
        this.id = id;
        this.name = name;
    }
}

package test3;

/*
声明为实例变量：
    所有对象都有该属性，但这个属性值会随着对象变化而变化

声明为静态变量：
    所有对象都有这个属性，并且这个属性在所有对象中都是一样的。

静态变量在类加载的时候初始化，内存在 方法区中开辟。
所有静态数据，都可以采用类名.名 方式访问，也可以采用对象.名 方式访问。但是不推荐后者。
 */

public class Test {
  public static void main(String[] args) {
    //创建中国人对象1
    Chinese zs = new Chinese("1","zs");
    System.out.println(zs.id + zs.name + Chinese.country);
    //创建中国人对象2
    Chinese ls = new Chinese("2","ls");
    System.out.println(ls.id + ls.name + Chinese.country);
  }
}

静态方法在类加载之前执行，并且只执行1次。
静态代码可以在一个类中编写多个，并且遵循自上而下的顺序依次执行。

public class Test {
  static {
    System.out.println("类加载--->1");
    System.out.println("类加载--->2");
    System.out.println("类加载--->3");
  }
  public static void main(String[] args) {
    System.out.println("main begain");
  }
}

静态代码块的作用

eg: 在类加载时刻，执行代码完成日志的记录。
这段记录日志的代码可以写到静态代码当中，完成日志记录。

静态变量使用

所有对象都有这个属性，而且这个属性的值都是一样的。

静态变量在类加载的时候初始化，内存在方法区中开辟，访问的时候不需要创建独享，直接使用 类名.属性名的方式访问。

所有static修饰的元素都 是静态
static修饰的方法 静态方法
static修饰的变量 静态变量

中国人例题：

代码 + 图片

package lab6;

public class Chinese{
    // 实例变量：1000个java对象，就有100个country
    private String id;
    private String name;
    // 静态00变量，在类加载的时候初始化，不需要创建对象，内存就开辟了。
    static private String country; // 所有中国人的国籍都是中国，没有必要为每个对象都创建一个空间，提升为整个模板的特征



    //类变量
    public Chinese(){}
    public Chinese(String id, String name, String country){
        this.id  = id;
        this.name = name;
    }
  public static void main(String[] args) {
      // create a Chinese object
    Chinese zs = new Chinese("1", "张三","中国");

    Chinese ls = new Chinese("2","李四","中国");
    
    // 所有静态数据都可以采用 类型.静态变量名 访问 可以用 对象.静态变量名 访问。
    System.out.println(Chinese.country);
    System.out.println(zs.country);
  }
}

实例语句块

实例语句块 ：是在 构造方法执行之前 执行，可以编写多个。

public class Test{

  // constructor

    // 实例语句块/代码块（使用非常少）
    {
    System.out.println(1);
    }
    // 实例语句块/代码块
    {
    System.out.println(2);
    }
    // 实例语句块/代码块
    {
    System.out.println(3);
    }

    // main method
    public static void main(String[] args) {
        System.out.println("begin");
        new Test();
        new Test();
  }
}

理解 main 方法

public class Test {

  // public 表示公开的，在任何位置都可以访问
  // static 表示静态的，使用 类名. 方式访问，不需要创建对象，就可以调用
  // void 表示main方法执行完成之后，不返回任何值
  // main 是main方法的 方法名
  public static void main(String[] args) {
    main(10);
    main("hello world!");
  }

  public static void main(int i) {
    System.out.println(i);
  }

  public static void main(String args){
    System.out.println(args);
  }
}

什么时候 定义 方法为 static 静态？

什么时候 定义 方法为 static 静态？
方法描述的是动作，当所有对象执行这个动作的时候，最终产生的影响是一样的。
这个动作已经不再属于某一个对象的动作，可以将这个动作提升为 类级别 的时候，模板级别的动作。

静态方法中无法直接访问 实例变量 和 实例方法。

大多数方法，都定义为 实例方法，一般一个行为or一个动作发生的时候，都需要对象的参与。
但是例外， 大多数工具类 的方法 都是 静态方法，因为工具类就是方便编程，为了方便的调用，自然不需要new对象。

/*
什么时候 定义 方法为 static 静态？
    方法描述的是动作，当所有对象执行这个动作的时候，最终产生的影响是一样的。
    这个动作已经不再属于某一个对象的动作，可以将这个动作提升为 类级别 的时候，模板级别的动作。

  静态方法中无法直接访问 实例变量 和 实例方法。

  大多数方法，都定义为 实例方法，一般一个行为or一个动作发生的时候，都需要对象的参与。
  但是例外， 大多数工具类 的方法 都是 静态方法，因为工具类就是方便编程，为了方便的调用，自然不需要new对象。
 */
public class Test {

  // 实例对象
  int i = 100;
  // 实例方法
  public void doSome(){
  }

  // 静态方法【静态上下文】
  public static void main(String[] args) {
    Test t = new Test();
    System.out.println(t.i);
    t.doSome();
  }
}


/*
总结：

class 类{
    静态代码块；
    实例代码块；

    静态变量
    实例变量

    构造方法

    静态方法
    实例方法
    }

this
static
 */

工具类举例子：

public class MathUtil{

  public static int sumInt(int a, int b){
    return a + b;
  }
  public static int divide(int a, int b){
    return a / b;
  }
}

public class Test {

  // 实例对象
  int i = 100;
  // 实例方法
  public void doSome(){
  }

  // 静态方法【静态上下文】
  public static void main(String[] args) {
    Test t = new Test();
    System.out.println(t.i);
    t.doSome();
    int a = 1;
    int b = 2;
    int c = MathUtil.sumInt(a,b);
    System.out.println(c);
  }
}