Java中使用switch case语句时很容易出现以下两个报错：
 
1、Duplicate local veriable out. （局部变量重复）
 
2、The local veriable out may not have been initialized. （局部变量可能未被初始化）
 

 第一种情况常见的场景为：
 
switch (type) {
    case 1:
        String test;
        ...
        break;
    case 2：
        String test;
        ...
        break;
}
 
是因为我们在一个变量作用域里声明了两个同名变量“test”。
 
第二种情况常见的场景为：
 
switch (type) {
    case 1:
        String test;
        test = "my error";
        ...
        break;
    case 2：
        System.out.print(test);
        ...
        break;
}
 
​ 是因为虽然声明变量test的位置和使用变量test的位置在同一个变量作用域，但是当type为2时，就会跳过test = "my error"的变量初始化语句，导致程序在运行时变量没有被初始化就被使用报错。
 
​ 下面的写法就是正确的：
 
switch (type) {
    case 1:
        String test;
        ...
        break;
    case 2：
        test = "my error";
        System.out.print(test);
        ...
        break;
}
 

 在Java中使用switch语句还是比较友好的，在C++中使用switch语句时甚至不能在case分支中声明变量。 
 
 
不允许跨过变量的初始化语句，直接跳到该变量作用域的另一个位置。
 ——《C++ primer》
 
 

 
那么我们上文中反复提及到的一个概念——变量作用域，是什么呢？
 
Java的变量作用域一共有四种，分别是类级、对象实例级、方法级、块级.
 
1、类级变量又称全局级变量或静态变量，需要使用static关键字修饰，类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。
 
2、对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。
 
3、方法级变量就是在方法内部定义的变量。
 
4、块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，比如 if、for 语句的块，还有static块。
 
Java用一对大括号作为语句块的范围，称为作用域，在作用域里定义的变量，只有在该作用域结束之前才可使用。
 
public class test {
    public static String TAG = "test";  //类级变量
    public int flag;   //对象实例级变量
    
    static {
        boolean isTest = flase;   //块级变量
    }
    
    public void test() {
        int testFlag = 2;   //方法级变量
    }
  
  public static void main(String[] args) {}
}

main方法里面定义的是局部变量，方法里面产生的变量属于局部变量，不需要加任何限定符，因为这些变量仅在此方法的栈帧中才能被访问到。方法里面涉及到的成员变量已经有了限定符，不需要再加了。
 
public是用来修饰类，方法、类变量、成员变量的，方法里面定义的是局部变量，只有在方法内部有效，本身是有作用域限制的，不能使用访问修饰符。
 
访问修饰符里面没有default这个关键字，不写的情况称为“缺省"，不叫“默认”，所以也不要用default限定符尝试了，一般局部变量的作用域默认是在package范围内。

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+"碗大米饭");
	}
}

1:var
 
没有变量就去var一个,没有对象就去new一个
 
2:let
 1:let和const是ES6中新增声明变量的关键字,
 
2:let声明的变量不会进行变量提升,
 
console.log(name) //name is not undefined
let name='张三'
 
3:let的声明方式和var基本上是一样的,一经声明不赋值输出undefined,后续可以对赋值进行改变.
 
let name='张三';
name='李四';
console.log(name) //李四
 
4:let和const声明变量变量命明具有唯一性,不能重复
 
let name='张三';
var name='李四';
console.log(name);//会报错

 
5:let声明的变量会形成一个块级作用域(也称为暂时性死区)
 
if(1==1){
var name='张三';
let letname='李四';
console.log(let) ;//输出''李四'';
}
console.log(name) //输出''张三'';
console.log(letname)//报错(letname is not defined))
var a=10;
function fn(){
console.log(a); //报错(let声明不会提升,一般a会输出10,但当前a和let a是一个整体
,let声明的变量不能再声明之前调用,会报错,所以称为暂时性死区)
let a =20;
}
fn() //报错
 
6:let和var有什么区别?
 
:let声明变量不会变量提升,使用必须在声明之后
:let声明变量变量名不能重复,否则报错
:let会形成一个块级作用域
 
7:let和const有什么区别?
 
let声明的值可以进行修改.const声明值一经赋值就不可再变
 
8:let会造成块级作用域小案例
 
 
 3:const
 
1: const声明的是一个常量,变量一旦赋值,就不可以重新赋值,
 
/*const name='张三';
name='李四';//报错
console.log(name);//拨错*/
 const obj={};
 obj.name='张三';
 console.log(obj.name)//输出张三
 //obj存的是{}对象的地址,obj.name='张三修改的是obj下面的属性',obj的地址没变也没有重新赋值,所以不会报错.
 
2:const变量不能变量提升
 
console.log(name) //name is not undefined
const name='张三'
 
3:const声明变量变量名具有唯一性,不能重复
 
const name='张三';
const name= '李四' //会报错
 
示例