精华内容
下载资源
问答
  • Lua初识之局部变量代码块-八

    千次阅读 2014-12-27 17:42:31
    Lua初识之局部变量代码块 num = 10 -- 声明全局变量 num local i = 1 -- 声明局部变量 i  while i  local num = i * 2; -->声明局部变量 num  print("local num = " .. num) --> 2 4 6 8 ..  i = i + 1 ...
    Lua初识之局部变量与代码块
    
    num = 10  -- 声明全局变量 num
    local i = 1  -- 声明局部变量 i
    
    while i <= num do
        local num = i * 2;  -->声明局部变量 num
        print("local num = " .. num) --> 2 4 6 8 ..
        i = i + 1 
    end  
    --在while语句块内改变的 num 为 local num 的值,全局的num的值不发生变化
    
    print("num = " .. num)  --> 10
    --> 11 local i 的值在while发生了变化
    print("i = " .. i)  
    
    if ( i > 20) then --> i = 11 条件不成立
        local num
        num = 5
        print("num = " .. num) -->  
    else
        print("num  " .. num)  --> 10
    end
    
    -- 如果在交互模式下可能不会输出期望的结果,因为第二句的 local num是一个完整的chunk
    --在交互模式下执行完这一句后,Lua将开始一个新的chunk,这样第二句的i已经
    -- 超出了他的有效范围,可将这句放 do .. end 块中
    -- 为了避免调用变量值发生冲突,访问局部变量的速度比全局变量更快
    
    
    do
        local a1 = 3;
        local a2 = 6;
     
        x1 = a1 * 2  --全局变量 x1
        x2 = a2 * 3  --全局变量 x2
     
        print("x1 = " .. x1) --> 6
        print("x2 = " .. x2) -->18
    end
    
    -- 该句报错,因为找不到 a1 的赋值,所以 a1的值为nil
    --print("a1 = " .. a1) 
    
    -- 该句报错,同上
    --print("a2 = " .. a2) 
    
    print("x1  " .. x1) --> 6
    print("x2  " .. x2) --> 18
    
    -- 该例子说明 a1和a2 为局部变量,只在 do .. end 范围内有效,
    -- x1 和 x2 为全局变量,在全局都有效
    -- 所以想定义一个局部变量最好写在 do .. end 块、 while 、 for 或者 if end等语句块内
    

    展开全文
  • LUA教程局部变量代码块(block)-14

    千次阅读 2020-07-12 09:46:09
    使用local创建一个局部变量,与全局变量不同,局部变量只在被声明的那个代码块内有效。代码块:指一个控制结构内,一个函数体,或者一个chunk(变量被声明的那个文件或者文本串)。 x = 10 local i = 1 -- local ...

    使用local创建一个局部变量,与全局变量不同,局部变量只在被声明的那个代码块内有效。代码块:指一个控制结构内,一个函数体,或者一个chunk(变量被声明的那个文件或者文本串)。

    x = 10
    local i = 1              -- local to the chunk
     
    while i<=x do
        local x = i*2        -- local to the while body
        print(x)             --> 2, 4, 6, 8, ...
        i = i + 1
    end 
     
    if i > 20 then
        local x              -- local to the "then" body
        x = 20
        print(x + 2)
    else
        print(x)             --> 10  (the global one)
    end
     
    print(x)                 --> 10  (the global one)

    注意,如果在交互模式下上面的例子可能不能输出期望的结果,因为第二句local i=1是一个完整的chunk,在交互模式下执行完这一句后,Lua将开始一个新的chunk,这样第二句的i已经超出了他的有效范围。可以将这段代码放在do..end(相当于c/c++的{})块中。

    应该尽可能的使用局部变量,有两个好处:


    1. 避免命名冲突


    2. 访问局部变量的速度比全局变量更快.

    我们给block划定一个明确的界限:do..end内的部分。当你想更好的控制局部变量的作用范围的时候这是很有用的。

    do
        local a2 = 2*a
        local d = sqrt(b^2 - 4*a*c)
        x1 = (-b + d)/a2
        x2 = (-b - d)/a2
    end            -- scope of 'a2' and 'd' ends here
     
    print(x1, x2)

    原文:LUA一个小巧脚本语言学习笔记

               LUA教程局部变量与代码块(block)-14

    展开全文
  • 新手小白学 JAVA 方法 局部变量 成员变量

    万次阅读 多人点赞 2021-04-01 23:59:30
    2.2 局部变量 位置:定义在方法里或者局部代码块中 注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5; 作用域:也就是方法里或者局部代码块中,方法运行完内存就释放了 2.3 成员变量 位置:定义在类里方法...

    1 变量

    1.1 概念

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

    1.2 局部变量

    位置:定义在方法里或者局部代码块中
    注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
    作用域:也就是方法里或者局部代码块中,方法运行完内存就释放了

    1.3 成员变量

    位置:定义在类里方法外
    注意:不用初始化,也会自动被初始化成默认值
    作用域:整个类中,类消失了,变量才会释放
    8大类型速查表(含默认值)

    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+"碗大米饭");
    	}
    }
    
    展开全文
  • 局部变量:在函数内部(代码块内部)声明的变量,也称为“自动变量”,进入代码块创建,退出代码块销毁 #include int fun() { int a = 19; { int a = 20; { int a = 21; printf("%d\n", a); //21,局部...

    局部变量:在函数内部(代码块内部)声明的变量,也称为“自动变量”,进入代码块创建,退出代码块销毁

    #include<stdio.h>
    int fun()
    {
    	int a = 19;
    	{
    		int a = 20;
    		{
    			int a = 21;
    			printf("%d\n", a);    //21,局部优先,但只在当前代码块起作用,出代码块就销毁。
    		}
    		printf("%d\n", a);     //20,局部优先,但只在当前代码块起作用,出代码块就销毁。
    
    		return a;
    	}
    }
    int main()
    {
    	int word = 0;
    	int a=0;
    	word = fun(a);
    	system("pause");
    	return 0;
    }
    
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
    	printf("hello\n");
    	int num = 20;       //(不同平台下可能会)出现error,C语言中变量声明必须放在在当前代码块的最前面,不是所有代码块的最前面
    	printf("%d", num);
    	system("pause");
    	return 0;
    }
    在局部变量之前加上static(静态变量)放在不同的位置:

    #include<stdio.h>
    void fun()
    {
    	int i = 0;
    	static int num = 0;
    	for (i = 0; i < 10; i++)
    	{
    		num++;
    		printf("%d\n", num);  //1,2,3,4,5,6,7,8,9,10
    	}
    }
    int main()
    {
    	fun();
    	system("pause");
    	return 0;
    }
    #include<stdio.h>
    void fun()
    {
    	int i = 0;
    	
    	for (i = 0; i < 10; i++)
    	{
    		static int num = 0;  //初始化num,只执行一次,num是一个静态变量,创建后不再销毁,直到程序当前代码块结束
    		num++;
    		printf("%d\n", num);  //1,2,3,4,5,6,7,8,9,10
    	}
    }
    int main()
    {
    	fun();
    	system("pause");
    	return 0;
    }
    <pre class="objc" name="code">#include<stdio.h>
    void fun()
    {
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		int num = 0;     num是局部变量,每次进入循环时创建,出代码块时销毁
    		num++;
    		printf("%d\n", num); //1,1,1,1,1,1,1,1,1,1
    	}
    }
    int main()
    {
    	fun();
    	system("pause");
    	return 0;
    }

    
    
    #include<stdio.h>
    void fun()
    {
    	int i = 0;
    	static int num = 0;
    	for (i = 0; i < 10; i++)
    	{
    		num = 0;   //赋值,不管num的值是多少,进入循环后,每次都会被赋值为0.
    		num++;
    		printf("%d\n", num); 1,1,1,1,1,1,1,1,1,1
    	}
    }
    int main()
    {
    	fun();
    	system("pause");
    	return 0;
    }
    #include<stdio.h>
    int main()
    {
    	void fun(void);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		fun();   //调用fun函数,j是局部变量,调用一次,销毁一次,每次调用,重新创建
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }
    void fun(void)
    {
    	int j = 0;
    	j++;
    	printf("%d ", j);   //1,1,1,1,1,1,1,1,1,1
    }
    #include<stdio.h>
    int main()
    {
    	void fun(void);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		fun();  //j是一个静态变量,创建后,直到程序当前代码块结束时销毁
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }
    void fun(void)
    {
    	static int j = 0;
    	j++;
    	printf("%d ", j);  //1,2,3,4,5,6,7,8,9,10
    }
    #include<stdio.h>
    int main()
    {
    	void fun(void);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		fun();
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }
    static int j = 0;
    void fun(void)
    {
    	j = 0;   //赋值,每次调用都会给j赋值为1
    	j++;
    	printf("%d ", j);    //1,1,1,1,1,1,1,1,1,1
    }   
    

    形式参数:把定义声明在函数参数里面,也相当于局部变量,只对当前代码块起作用。使用完成后自动销毁

    #include<stdio.h>
    int is_in(char *s, char c)  //*s和c都属于形式参数
    {
    	while (*s)
    	if (*s == c)
    	{
    		printf("exist");
    		return 1;
    	}	
    	else
    	{
    		s++;
    	}
    		
    	return 0;
    }
    int main()
    {
    	char *p = "abcdef";
    	char c = 'd';
    	is_in(p, c);
    	system("pause");
    	return 0;
    }

    全局变量:所有在代码块之外({}大括号之外)定义的变量,当全局变量与局部变量冲突时,局部优先。

    #include<stdio.h>
    int a = 20;
    int b;    //声明
    int fun1()
    {
    	printf("b=%d", b);  //20
    	return 0;
    }
    int b = 30;  //定义,b在所有代码块的外部,是一个全局变量,对程序所有代码块起作用,所以fun1可以调用,但需要提前声明
    int fun2()
    {
    	return 1;
    }
    int main()
    {
    	fun1();
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 代码块局部变量x只能作用于定义它的代码块,也就是说出了代码块该x就被销毁了
  • 1、代码块:Java中代码块分为静态代码块和非静态代码块。 2、特点:静态代码块只在类加载时执行一次;静态代码块每次创建对象时都会执行。 { System.out.println(age); } static { System.out.println(name...
  • 代码块中的局部变量与作用域

    千次阅读 2016-09-18 19:39:26
    作用域决定了在其内定义的变量名的可见性生命周期。在C、C++Java中,作用去由花括号的位置决定。例如:{ int x = 12; //only x available { int q = 36; //both x & q available } //only x availa
  • 一、代码块 静态代码块只执行一次,非静态代码块每创建一个实例对象时,就会执行一次。 public class Dui { static int age=1;//成员变量被static修饰,则其被所有对象共享。 //非静态数码块 { int age = 1...
  • 局部变量和成员变量的定义和区别

    千次阅读 多人点赞 2018-06-23 15:38:07
    局部变量和成员变量的区别和定义 局部变量 成员变量 定义位置: 方法方法的内部 类的内部,方法的外部 默认值: 无默认值 字面值,(与数组相同)的默认值 使用范围: 从定义行到...
  • 1 序言: Java中子类、父类变量,...变量: 成员变量(静态变量又叫类变量、实例变量)和局部变量  方法: 成员方法和构造方法  代码块:普通代码块、构造代码块、静态代码块、同步代码块  想要弄清楚子类、父类变
  • JAVA之旅(四)——面向对象思想,成员/局部变量,匿名对象,封装 , private,构造方法,构造代码块 加油吧,节奏得快点了 1.概述 上篇幅也是讲了这点,这篇幅就着重的讲一下思想案例 就拿买电脑来说吧,首先...
  • python的局部变量和全局变量区别

    千次阅读 2018-01-16 15:37:59
    局部变量:函数内部定义的变量 或者代码块里的变量 1.函数内部的变量名如果第一次出现,且出现在=前面,即被视为定义了一个局部变量,不管全局域中有没有该变量名,函数中使用的将是局部变量。 (即声明了一...
  • python的 局部变量和全局变量

    万次阅读 2017-07-31 19:12:06
    全局变量:所有函数之外定义的变量局部变量:函数内部定义的变量 或者代码块里的变量1.函数内部的变量名如果第一次出现,且出现在=前面,即被视为定义了一个局部变量,不管全局域中有没有该变量名,函数中使用的将是...
  • Java 之 代码块中的局部变量

    千次阅读 2012-09-28 23:47:06
    很有意思的问题,下面这段代码会输出预期的结果,int x在代码块中被赋值,而后... * 普通代码块中的局部变量 * @author zendao */ public class CodeBlock { public static void main(String args[]) { { // 普
  • 关于java成员变量和局部变量

    万次阅读 多人点赞 2018-09-14 10:46:45
    1、成员变量和局部变量简述 在Java语言里,根据定义变量位置的不同,可以将变量分成两大类:成员变量(存在于堆内存中,和类一起创建)和局部变量(存在于栈内存中,当方法执行完成,让出内存,让其他方法来使用内存)...
  • 【C语言】C语言局部变量和全局变量

    千次阅读 2016-02-13 16:41:30
    目录: 【局部变量】 · 定义 · 作用域 · 生命周期 · 用static修饰局部变量 【全局变量】 · 定义 · 作用域 ...在函数(代码块)内部定义的变量称为局部变量(函数的形参也是局部变量
  • 1. java中静态变量,静态代码块,静态方法,实例变量,匿名代码块 在Java中,使用{}括起来的代码称为代码块代码块可以分为以下四种: (1)普通代码块:就是类中方法方法体 public void xxx(){ //code } ...
  • java中的局部变量和全局变量

    万次阅读 多人点赞 2017-08-18 15:09:10
    Java变量 java中主要有如下几种类型的变量: ...一、局部变量 ...只在特定的过程或函数中可以...局部变量可以全局变量重名,但是局部变量会屏蔽全局变量。在函数内引用这个变量时,会用到同名的局部变量,而不会
  • 成员变量和局部变量区别

    多人点赞 2020-06-18 17:13:43
    成员变量和局部变量区别 ...局部变量:随着方法的调用或代码块的执行而存在,随着方法的调用完毕或者代码块的执行完毕而消失 初始值 成员变量:有默认初始值 局部变量:没有默认初始值,使用前需赋值 注意
  • 成员变量(实例变量) 局部变量... 局部变量是定义在方法里面的普通变量以及方法的形参  3.类变量:属于类的,被static修饰的属性    作用上的区别:  1. 成员变量是用来描述一类事物的公共属性   2. 局部变
  • 文章目录1、考点:2、局部变量和成员变量的区别3、具体的测试代码4、过程分析(重点)5、补充 1、考点: 就近原则 变量的分类 成员变量:类变量、实例变量 局部变量 非静态代码块的执行:每次执行实例对象都会...
  • 局部变量和全局变量,以及作用范围

    万次阅读 多人点赞 2018-11-11 13:56:55
    变量按存储区域分:全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域,局部变量存放在内存的栈区。 变量按作用域分:  全局变量:在整个工程文件内都有效;“在函数外定义的变量”,即从定义变量...
  • 局部变量和全局变量的作用域

    千次阅读 2014-03-13 16:58:54
    局部变量:作用在它定义的方法或者方法里面的程序变量。只能作用在方法里面或者方法里面的程序里面。局部变量必须初始化,否则使用时编译会出错。 全局变量:分为实例变量和类变量。区别在于类变量使用static...
  • C语言的局部变量和外部变量

    千次阅读 2015-08-14 06:03:04
    在函数体或复合语句中声明的变量为局部变量。函数中的形式变量也是局部变量。在所有函数体外定义的变量称为外部变量(或全局变量)。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 265,393
精华内容 106,157
关键字:

方法局部变量和代码块局部变量