一、代码块

1、代码块：Java中代码块分为静态代码块和非静态代码块。
2、特点：静态代码块只在类加载时执行一次；静态代码块每次创建对象时都会执行。

    {
        System.out.println(age);
    }
    static {
        System.out.println(name);
    }

3、static修饰符：可修饰变量，代码块，方法。
public class Dui {
    static int age=1;//成员变量被static修饰，则其被所有对象共享。

    //非静态数码块
    {
        int age = 1;//无初始值，且不能加访问控制符和static。
        System.out.println(age);
    }
    //静态的比非静态的早执行
    static int a=2;//加载时赋初值

    static {//加载时执行
        System.out.println(a);
    }

    public static void print(int age) {//类加载时分配地址
        System.out.println(age);
    }

    public static void main (String[] args) {//类加载时分配地址
        System.out.println(a);
        new Dui();//静态的可以通过对象创建，使用非静态的变量。
        new Dui().prints(14);//静态的可以通过对象创建，执行非静态的方法，不能直接调用（静态的先执行）
        print(24);//静态的可以直接调用静态方法。
    }

    //非静态
    int b =12;//创建对象时赋初值
    {
        System.out.println(b);//创建对象时执行
    }

    public void prints(int age) {//创建对象时分配地址
        System.out.println(age);
        print(12);//非静态的可以直接调用静态方法
        System.out.println(a);//非静态的可以直接使用静态变量
    }

二：全局变量/局部变量

1、全局变量：直接在类中声明的变量叫成员变量(又称全局变量)。注：如果未对成员变量设置初始值，则系统会根据成员变量的类型自动分配初始值：int分配初始值0、boolean分配初始值false，而自定义类型则分配初始值null。
2、作用范围：成员变量定义后，其作用域是其所在的整个类。注：成员变量的定义没有先后顺序，但是最好将成员变量的定义集中在类的顶部。
3、局部变量：方法中的参数、方法中定义的变量和代码块中定义的变量统称为局部变量。注：局部变量在使用以前必须显式初始化或赋值，局部变量没有默认值。
注：声明局部变量时，数据类型前除final外不允许有其他关键字，即其定义格式为： [final] 数据类型 变量名 = 初始值；
4、作用范围：局部变量的作用域范围从定义的位置开始到其所在语句块结束。

//局部变量,只作用于所在代码块（即一个大括号），局部变量没有初始值，从定义到所属代码块结束。
    {
        int age = 1;//无初始值，且不能加访问控制符和static。
        System.out.println(age);
    }

5注意点：
1、如果局部变量的名字与全局变量的名字相同，则在局部变量的作用范围内全局变量被隐藏，即这个全局变量在同名局部变量所在方法内暂时失效。
2、如果在局部变量的作用域范围内访问该成员变量，则必须使用关键字this来引用成员变量。

    public static void print() {
        System.out.println(age);//当局部变量和全局变量重名时，（不强调数据类型），从局部变量定义到期结束作用范围，全局变量起作用，除非加上this.
        int age=9;
        System.out.println(age);
        if(age==1) {
            String names ="wangming";
            System.out.println(names);
        }

    }

1 变量

1.1 概念

可以改变的数，称为变量。在Java语言中，所有的变量在使用前必须声明。
一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
变量的使用原则：就近原则,即尽量控制变量的使用范围到最小

1.2 局部变量

位置:定义在方法里或者方法的声明上
注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
生命周期:随着方法的调用而存在,方法运行完毕就释放了

1.3 成员变量

位置:定义在类里方法外
注意:不用初始化,也会自动被初始化成默认值
生命周期:整个类中,类消失了,成员变量才会释放

1.4 练习：变量的默认值测试

创建包: cn.tedu.basic
创建类: TestVariable1.java

package cn.tedu.design;
/*本类用于测试各种类型变量的默认值*/
public class TestVariable1 {
        static String name;
        static byte b;//整数类型默认值都是0
        static short c;
        static int d;
        static long e;
        static float f;//小数类型的默认值是0.0
        static double g;
        static char j;//char类型的默认值是\u0000
        static boolean h;//boolean类型的默认值是false

        public static void main(String[] args) {
            System.out.println(name);//null,引用类型的默认值
            System.out.println(b);
            System.out.println(c);
            System.out.println(d);
            System.out.println(e);
            System.out.println(f);
            System.out.println(g);
            System.out.println(h);
            System.out.println(j);
            System.out.println(h);
        }
    }

1.5 练习：局部变量与成员变量测试

创建包: cn.tedu.basic
创建类: TestVariable2.java

package cn.tedu.oop;
/**本类用于测试变量的使用*/
public class TestVariable2 {
    //2.定义成员变量:
    //1)位置:类里方法外
    //2)无需手动初始化,会自动赋予对应类型的默认值
    //3)作用域:在整个类中生效,类消失,变量才会消失
    static int count;
   
    //3.变量有一个使用的原则:就近原则
    static int sum = 200;
    public static void main(String[] args) {
        //1.定义局部变量:
        //1)位置:在方法里/局部代码块里
        //2)必须手动初始化
        //3)作用域:在方法/局部代码块中,对应的代码执行完局部变量就被释放
        int sum = 100;//定义在方法中的局部变量sum
        System.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100
        System.out.println(count);
       
        for (int i = 0; i < 10; i++) {//局部变量i只能在循环中使用
            System.out.println(i);
        }
        //System.out.println(i);//报错:无法引用变量i:i cannot be resolved to a variable
    }
}

2 方法

2.1 概述

被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。

2.2 方法定义的格式

2.3 方法调用顺序图

顺序执行代码,调用指定方法,执行完毕,返回调用位置

2.4 练习:测试方法的调用顺序/参数/返回值

创建包:cn.tedu.method
创建类:TestMethod .java

package cn.tedu.method;
/**本类用于测试方法*/
public class TestMethod {
	//1.创建程序的入口函数main()
	public static void main(String[] args) {
		System.out.println(1);
		/**2.我们通过方法名+参数列表的方式来调用方法的功能*/
		method1();//调用method1()
		System.out.println(2);
		method2(3);//调用method2()
		int result = method3(1,2);//调用method3()
		System.out.println(result);
	}

	/**3.如果方法想要返回值,必须修改返回值类型
	 * 并且return对应类型的结果
	 * 如果方法的返回值类型是void,不允许有返回值
	 * */
	/*本方法用来测试方法的返回值类型*/
	public static int method3(int i, int j) {
		/**4.通过return关键字将方法结果返回到调用位置*/
		return i+j;
	}

	/**1.方法的修饰符 方法的返回值类型 方法名(方法参数){方法体}*/
	/*method1()想测试方法的调用顺序*/
	public static void method1() {
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
	}
	
	/*本方法用来测试方法的参数,参数的位置在小括号里*/
	public static void method2(int a) {
		System.out.println("海绵宝宝今年:"+ a +"岁啦~");
	}	
}

2.5 方法的重载

方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

2.6 练习：测试方法的重载

创建包: cn.tedu.method
创建类: TestMethodOverload.java

package cn.tedu.method;
/**本类用于测试方法的重载*/
public class TestMethodOverload {
	public static void main(String[] args) {
		/**1.我们根据方法名+参数列表确定具体调用哪个方法*/
		/**2.方法的重载:
		 * 在同一个类中,存在方法名相同,但参数列表不同的方法
		 * 如果在同类中,同名方法的参数个数不同,一定构成重载
		 * 如果在同类中,同名方法的参数个数相同,
		 * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
		 * (int a,String b)与(int b,String a)--不构成重载
		 * (int a,String b)与(String a,int b)--构成重载
		 * */
		//2.调用method()
		method();
		//4.调用method(int)
		method(666);
		//6.调用method(int,String)
		method(888,"泡泡");
	}

	//1.创建一个无参的method()
	public static void method() {
		System.out.println("哈哈哈哈我没参数");
	}
	//3.创建一个method(int n)
	public static void method(int n) {
		System.out.println("哈哈哈哈我的参数是:"+n);
	}
	//5.创建一个method(int n,String s)
	public static void method(int a,String b) {
		System.out.println(b+"今晚要干他"+a+"碗大米饭");
	}
	public static void method(String a,int b) {
		System.out.println(b+"今晚要干他"+a+"碗大米饭");
	}
}

3 拓展 成员变量与局部变量的区别