this,static,block关键字使用

7月8日学习笔记

1.this关键字

1.指代当前对象(new的对象)–>存储所有指向的对象的地址

2.构造器的首行调用本类中的其他构造器

   this(参数列表)

3.区分同名的成员与局部的问题

1.默认就近原则
2.如果出现同名问题,想要指代调用成员,通过this.成员-->因为this指代对象,通过对象调用成员
3.如果没有同名问题,可以省略this.调用成员
4.在构造器中使用this,默认指代当前new的对象,存储的是this的对象的地址
5.在成员方法中使用this,this在成员方法中默认指代当前调用成员方法的对象

public class Class001_This {
    public static void main(String[] args) {
        Dog dog = new Dog("斑点波比","萨摩耶","白色");
        dog.show();

        Dog dog2 = new Dog("小白");
        dog2.show();
        System.out.println("dog2的地址"+dog2);
    }
}

class Dog{
    public String name;
    public String type;
    public String color;

    //构造器
    public Dog(){
        System.out.println("空构造");
    }

    public Dog(String name){
        System.out.println("一个参数构造");
        this.name = name;
        System.out.println("this地址" + this);
    }

    public Dog(String name,String type){
        System.out.println("二个参数构造");
        this.name = name;
        this.type = type;
    }

    public Dog(String dogName,String dogType,String dogColor){
        this(dogName,dogType);//指代上一个2个参数构造方法
        color = dogColor;
        System.out.println("三个参数构造");
    }

    public void lookDoor(){
        System.out.println(name+"正在看家....");
    }
    public void show(){
        String name = "局部的name值";
        //this在成员方法中默认指代当前调用成员方法的对象
        System.out.println(this.name+"-->"+type+"-->"+color);
    }
}

注意：

1.多个构造器之间不能相互调用,否则无法停止调用
2.在static修饰的内容中不能使用this

2.static 关键字

成员修饰符 : 只能修饰成员位置的内容,不能修饰局部
修饰变量 : 静态变量|类变量
修饰方法 : 静态方法|类方法
修饰块 : 静态块
修饰类 : 静态内部类

静态内容的使用:
            1.跟随类名使用
                类名.静态变量名
                类名.静态方法名(参数列表);
            2.跟随对象使用
                引用.静态变量名
                引用.静态方法名(参数列表);

成员是是属于对象的
静态的是属于类的

成员变量 :
    被static修饰的变量 --> 静态变量|类变量
    不被static修饰的变量 --> 实例变量
成员方法:
    被static修饰的方法 --> 静态方法|类方法
    不被static修饰的方法 --> 实例方法

注意:
    this只能使用在非静态环境中
    在非静态方法中使用this,默认指代当前调用实例方法的对象
    静态内容是独一份的,静态变量存在与静态区中,多个对象共享的资源
    成员内容跟随对象存在与对象的堆内存中,多个对象,就有多份成员
    初始加载顺序: 先静态后成员
    静态内容在类第一次加载完成之后就会进行初始化
    成员变量必须在执行到new对象的时候,才会存在对象的堆内存,在对象的堆内存中才会有成员变量

public class Class001_Static {
    //成员位置: 类中方法外
    //实例变量
    int i = 1;
    //静态变量
    static int j = 2;

    //静态方法
    public static void main(String[] args) {
        //测试静态内容使用方式
        System.out.println(j); //本类中可以省略类名直接使用
        System.out.println(Class001_Static.j);

        Class001_Static cs = new Class001_Static();
        Class001_Static cs2 = new Class001_Static();
        System.out.println(cs.j);

        //测试实例变量的使用
        System.out.println(cs.i);
        //System.out.println(Class001_Static.i);

        cs.j++;
        cs2.j++;

        System.out.println(cs.j);  //4
        System.out.println(cs2.j); //4
        System.out.println(Class001_Static.j); //4


    }
}

1.在静态内容中,可以直接使用静态的内容,需要跟随对象使用成员
2.在成员内容中,可以直接 使用静态内容,可以直接 使用成员内容

this不能使用在静态环境中,静态的方法可以直接跟随类调用,可以能根本不存在对象,静态方法的this,无法指代某个对象

public class Class002_Static {
    //成员位置: 类中方法外
    //实例变量
    int i = 1;
    //静态变量
    static int j = 2;

    public static void main(String[] args) {
        System.out.println(j);
        Class002_Static cs  = new Class002_Static();
        System.out.println(cs.i);

        cs.test();
        testStatic();
    }

    //成员方法中,this默认指代调用成员方法的对象
    public void test(){
        System.out.println("成员方法");
        System.out.println(j);
        System.out.println(this.i);
    }

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

public class Class003_StaticTest {
   public static int id;
   public int age;

   public static void main(String[] args) {
      Class003_StaticTest class003_StaticTest = new Class003_StaticTest(); //红色对象 0x001
      System.out.println(Class003_StaticTest.id);   //0
      System.out.println(class003_StaticTest.age);   //0

      class003_StaticTest.change(); //id=1   age=0       //id=1 class003_StaticTest.age=1
      System.out.println(Class003_StaticTest.id); //1
      System.out.println(class003_StaticTest.id);  //1
      System.out.println(class003_StaticTest.age);  //0
      class003_StaticTest.change();  //id=2   age=0       //id=2 class003_StaticTest.age=1
      System.out.println(id);  // 2
      System.out.println(class003_StaticTest.age);  //0


   }

   public void change() {
      Class003_StaticTest class003_StaticTest = new Class003_StaticTest(); //蓝色对象 0x002   紫色对象0x003
      class003_StaticTest.age++;  //
      Class003_StaticTest.id++;  //
      System.out.println("In change(): id = " + id + " age = " + age);  //id=1  2   age= 0  0
      System.out.println("In change(): id = " + id + " class003_StaticTest.age = " + class003_StaticTest.age);
      //id=1 2  class003_StaticTest.age=1 1

   }
}

/*
    定义清华大学学生类:
      学生编号,学生姓名,学生年龄,学校名称
      学习能力,....
      测试使用

      清华大学正式更名为清清大学

   静态变量|方法的应用场景:
    1.工具类 : Math,Arrays... 静态工厂
        可以跟随类名直接使用静态方法,使用简单
    2.定义一个类,类中的内容,所有当前类型对象共享的,唯一的可以定义为静态的 | 没有对象就可以使用的成员可以定义为静态的
        具体的需要根据业务进行分析,不绝对
 */
public class Class004_StaticTest {
    public static void main(String[] args) {

        System.out.println(Student.schoolName);

        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1.schoolName);

        Student.schoolName = "清清大学";

        System.out.println(s1.schoolName);
        System.out.println(s2.schoolName);
    }

}

//定义清华大学学生类:
class Student{
    public int id;
    public String name;
    public int age;
    //静态变量
    public static String schoolName = "清华大学";
}

// 一天会有很多场比赛,只能统计出一个胜利者
class Racer{
    public static String winner;
}

3.block块

{} 块 自成作用域
  分类                                                 
局部代码块|普通语句块 : {}定义在方法中                                  跟随方法的调用而执行
    1) 作用域看待
    2) 语义化
构造块 : {}定义在类中方法外                                            跟随new一起使用
    1) 成员内容的初始信息,比构造器中的代码跟早执行
    2) 对对象的某些内容进行初始
静态块 : static修饰{},定义在类中方法外                                 在类第一次加载完成之后执行
    1) 会为静态内容进行初始化
    2) 信息的配置,资源的加载
同步块 : 多线程学习

构造块中的代码会先于构造器中的代码之前执行
如果存在多个构造块,会从上到下一次执行
静态块在类第一次加载完成之后执行,并且仅会执行一次
如果存在多个静态块,会从上到下一次执行

静态块-->main-->创建对象 --> 构造块 --> 构造器

public class Class001_Block {
    static int i ;
    int j = 1;

    public Class001_Block(){
        System.out.println("构造器");
    }

    //构造块
    {
        System.out.println("构造块1");
        System.out.println(i);
        System.out.println(this.j);  //当前new的对象
    }
    {
        System.out.println("构造块2");
    }
    {
        System.out.println("构造块3");
    }

    //静态块
    static{
        System.out.println("静态块1");
        System.out.println(i);
        //非静态的成员变量j不能直接在静态内容中使用,需要跟随对象
        //System.out.println(j);
    }
    static{
        System.out.println("静态块2");
        i = 1000;
    }
    static{
        System.out.println("静态块3");
    }


    public static void main(String[] args) {
        System.out.println("main");
        //局部
        //int i =1;

        //局部代码块
        {
            int i = 10;
            System.out.println(i);
        }
        System.out.println(i);

        new Class001_Block();
    }
}

/*
   构造块在编译期间,会被编译到要执行的构造器内部,放在构造器代码的上面
 */
public class Class002_BlockTest {
   public static int a = 0;
   {
      a = 10;
      System.out.println("3、非静态代码块执行a=" + a); //10
   }

   static {
      a = 6;
      System.out.println("1、静态代码块执行a=" + a); //6
   }
   public Class002_BlockTest() {
      this(a); //6


      System.out.println("6、"+a);  //10
      System.out.println("7、无参构造方法执行a=" + a); //10
   }
   public Class002_BlockTest(int n) { //n=6
      //构造块
      /*{
         a = 10;
         System.out.println("3、非静态代码块执行a=" + a); //10
      }*/
      System.out.println("4、"+n); //6
      System.out.println("5、"+a);//10
   }  
   public static void main(String[] args) {
      System.out.println("2、main"); //main
      Class002_BlockTest tsc = new Class002_BlockTest();
   }
}

4.Debug调试工具

Debug 调试工具
   debug的作用:
      1.追踪程序的执行流程
      2.定位异常出现的位置
      3.观察程序运行期间变量变化的情况
      4.根据程序的执行流程学习第三方框架的源码

   步骤:
       1.打断点
          在行号的后面单击设置断点,单击取消断点
    2.debug运行
       step over F8 下一步跳过
          如果遇到方法的调用,不进入,直接跳过进入下一行
          step into F7 步入
             如果下一步遇到自定义方法的调用,进入方法跟随执行,如果是jdk提供的方法,不会进入
           Force step into alt+shift+F7 强制步入
              如果是jdk提供的方法,会强制进入跟随执行
           step out shift+F8 跳出
               如果执行在方法的调用中,下一步直接调出到方法调用的位置
           Run to  Cursor 运行到光标所在位置

public class Class003_Debug {
   public static int a = 0;
   //构造块
   {
      a = 10;
      System.out.println("3、非静态代码块执行a=" + a); //10
   }

   static {
      a = 6;
      System.out.println("1、静态代码块执行a=" + a); //6
   }
   public Class003_Debug() {
      this(a); //6
      System.out.println("6、"+a);  //10
      System.out.println("7、无参构造方法执行a=" + a); //10
   }
   public Class003_Debug(int n) { //n=6
      System.out.println("4、"+n); //6
      System.out.println("5、"+a);//10
   }  
   public static void main(String[] args) {
      System.out.println("2、main"); //main
      Class003_Debug tsc = new Class003_Debug();
   }
}

总结

构造器 : *****
初始化对象信息,不是用来创建对象的
使用: 跟随new一起使用
定义:
修饰符 类名(参数列表){}

注意:
    1.构造器可以实现重载,因为是特殊的方法
    2.没有显示定义构造器,编译器会默认提供空构造
    3.如果存在显示 定义构造器,不会提供任何构造器,包括空构造
    4.至少提供一个空构造...按需提供带参,不绝对,根据需求决定

this *****
指代对象,当前对象,当前new 的对象,当前调用成员方法的对象
在构造器的首行调用本类中的其他构造器
区分同名的成员与局部问题
默认就近原则
this.调用成员

static 静态的 ***
静态的变量
静态的方法
静态的是属于类的,当前这个多个对象共享的
没有对象就可以使用的
静态的变量存在与静态区中的
初始顺序: 先静态后成员

block
局部代码块
构造块
静态块
同步块

debug *****
代码调试工具