2022-7-27 第八组韦柳盈Java面向对象（8）---static静态

今日重点：

一、代码块

类的内部结构有属性、方法、构造器、代码块、内部类。

代码块又称为初始化块，属于类的一个成员，它是将逻辑语句封装在方法体中，通过{}包裹。代码块没有方法名字，没有参数，没有返回值，只有方法体，它是不需要通过对象或者类进行显式的调用，它会在类加载或者创建对象时主动的隐式调用。

（1）静态代码块

一个类被加载时只会被调用一次（只要它被加载就执行），做一些初始化的工作

public class Ch01 {
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
    {    //方法体

    }

    public static void main(String[] args) {
          Ch01 ch01=new Ch01();
         
    }

}

运行结果 ：

（2）实例代码块

 每次创建实例，都会被调用一次（创建一个对象就走一次，创建两个就走两次），相较静态代码块它用的很少。

public class Ch01 {
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
    {    //方法体
       //实例代码块
     System.out.println("实例代码块");

    }

    public static void main(String[] args) {
          Ch01 ch01=new Ch01();
          Ch01 ch02=new Ch01();
    }

}

 运行结果

一个类中可以有n多个静态代码块，但是在开发中写一个就可以了，示例代码块也是一样

（3）面试题：比较类中有静态代码块、实例代码块、构造器时，谁先执行输出

先执行各种块，再走构造器（静态块优于其他，实例块优于构造器），在继承关系中，先实例化父类再子类

 1.当没有继承关系

静态代码块 > 实例代码块 > 构造器

 2. 当有继承关系

父类静态块 > 子类静态块 > 父类实力块 > 父类构造器 > 子类实力块 > 子类构造器

  

父类代码：

package com.jr.morning;

public class Father {//静>实>构
    public Father(){
        System.out.println("父类构造器");
    }
    {
        System.out.println("父类实例块");
    }
    static {
        System.out.println("父类静态块");
    }

    public static void main(String[] args) {
        Father father=new Father();//创建对象
    }
}

子类代码： 

package com.jr.morning;

public class Ch02 extends Father{
  public Ch02(){
      System.out.println("子类构造器");
  }
  {
        System.out.println("子类实例块");
    }
    static {
        System.out.println("子类静态块");
    }

    public static void main(String[] args) {
        new Ch02();
    }
}

二、static静态方法

（1）概念

static静态（在开发中避免使用静态）----有属性，方法，代码块。

（2）修饰结构

①用static修饰的结构，不属于任何一个对象
②静态的结构的加载，随着类的加载而加载! !
③非静态的结构，随着对象的创建而加载! !.

④调用静态结构，直接用  类名.  的方式，也可以用调用对象的方式来调用静态结构，但是不建议，因为从严格意义上来说是不可以的。

public class Ch03 {
    static String name ="溜溜盈";//修饰属性

    public static void show(){  //静态方法
      
        System.out.println("静态方法");

    }

    public static void main(String[] args) {
        System.out.println(Ch03.name);
        Ch03.show();
        //也可以用下面调用对象的方式来调用静态结构，但是不建议
//        Ch03 ch03=new Ch03();
//        System.out.println(ch03.name);
//        Ch03.show();

    }
}

（3）内存解析

①静态的变量或者静态方法存在于方法区的。静态的结构不会被垃圾回收。
②不属于某（任何）一个实例对象，只存在于方法区。

（4）实例方法（非静态方法）和静态方法相互调用

①在静态方法中不可以直接调用实例方法
  如果想用，必须得 对象.方法名

②实例方法中可以直接调用静态方法

 在实例代码块中可以几乎可以调用很多东西包括静态方法，但是在静态代码块中依旧不可以调用实例方法，可以调用自己的静态方法

（5）特点

①在Java中调用实例方法，必须要有主体，可以用this调用当前类的对象或者 类名.方法名

②静态方法无论在哪里都是  类名.方法名  进行调用，同一个类的静态方法之间可以省略类名

（6）填坑 

1.接口里的常量

①开发中，基本上常量的声明都是public static final

② 静态方法没有重写这个概念的！其实接口也很少写静态方法

package com.jr.morning;


public interface Inter01 {

    // 接口中的常量默认public  static final
    // 开发中，基本上常量的声明都是public static final
    String STR = "哈哈";

    void show();

    default void fun(){

    }

    static void sta() {

    }
}

package com.jr.morning;

public class Impl implements Inter01 {

    @Override
    public void show() {

    }

    @Override
    public void fun() {
        Inter01.super.fun();
    }

    static void sta() {// 静态方法没有重写这个概念的！其实接口也很少写静态方法

    }
}

 2.this和super

①无论是this方法还是super方法，都不可以在静态结构中使用。
②静态结构是属于类的，静态结构是优先于对象就存在的。
③this和super，必须有对象才能出现。必须得有实例。

（6）案例

以下都是静态方法
Arrays. toString();
Arrays. sort();
Integer.parseInt();
String.value0f();

1.工具类

package com.jr.morning;

/**
 *  工具类
 */
public class Demo01 {

    public static void plus(int i,int j){

    }

    public static void sub(int i,int j){

    }
}

2.汽车小案例

需求： 

一汽车间：
 * 生产车：
 * 丰田001、大众002、奥迪003....
 * 生产的车是不同型号的，但是车的编号是累加的...
 * 编号不属于任何一台车，属于车间的。

public class Workshop {

    public static String no = "1001";

    private static Integer i;

    static{
        i = Integer.parseInt(no);
    }

    public static Car product(String brand,String color) {

        System.out.println("正在生产第" + no + "号汽车！");
        i++;
        no = String.valueOf(i);
        return new Car(brand,color);
    }
}

package com.jr.morning.test;

public class Car {

    private String brand;
    private String color;

    public Car() {
    }

    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

package com.jr.morning.test;

public class Test {

    public static void main(String[] args) {
        System.out.println(Workshop.product("大众", "黑色"));
        System.out.println(Workshop.product("丰田", "白色"));
        System.out.println(Workshop.product("奥迪", "银色"));
    }
}

三、外部类

①一个public声明的类，类名必须和  .java 的文件名相同
②生成的.class文件是两个独立的.class
③外部类就是两个类
④开发中尽量不要用外部类，因为代码解读性太差

public class Ch05 {
    int i=10;


    public static void main(String[] args) {

    }
}
class Outer{//外部类

    public static void main(String[] args) {

    }
}

 下午上课的内容！！！！！还没有掌握