一、回顾java中的变量

1、java中怎么定义/声明变量?

数据类型 变量名;
例如:

int i;
double d;
boolean flag;

2、java中的变量怎么赋值?

使用“=”运算符进行赋值运算。("="运算符右边先执行,将右边执行的结果赋值给左边的变量。
变量名 = 值;
例如:

i = 10;
d = 3.14;
flag = false;

3、java语言是一种强类型语言,强类型怎么理解?

java语言存在编译阶段,假设有代码:int i;
那么在Java中一个特点是:java程序编译阶段就已经确定了i变量的数据类型,该i变量的数据类型在编译阶段是int类型,那么这个变量到最终内存释放,一直都是int类型,不可能变成其他类型

  • int i = 10;
    double d = i;
    这行代码是说声明一个新的变量d,double类型,把i变量中保存的值传给d。i还是int类型。
  • i = “abc”; 这行代码编译的时候会报错,因为i变量的数据类型是int类型,不能将字符串赋给i。

==java中要求变量声明的时候是什么类型,以后永远都是这种类型,不可变。==编译期强行固定变量的数据类型。称为强类型语言。

二、javascript当中的变量

1、怎么声明变量

var 变量名;
怎么给变量赋值?
变量名 = 值;
javascript是一种弱类型语言,没有编译阶段,一个变量可以随意赋值,赋什么类型的值都行。

var i = 100;
i = false;
i = "abc";
i = new Object();
i = 3.14;

重点:javascript是一种弱类型编程语言。

2、演示

<script type="text/javascript">
   var i;
    // undefined 在JS中是一个具体存在值.
    alert("i= " + i);//i = undefined
    alert(undefined);//undefined
    var k = undefined;
    alert("k = " + k);//k = undefined

    // 一个变量没有声明/定义,直接访问?
    // alert(age); //语法错误:age is not defined (变量age不存在。不能这样写。)

    //只会给最后一个变量赋值
    var a,b,c = 200;
    alert("a = " + a);//a = undefined
    alert("b = " + b);//b = undefined
    alert("c = " + c);//c = 200

    //javascript是一种弱类型语言,没有编译阶段,一个变量可以随意赋值,赋什么类型的值都行。
    a = false;
    alert(a);//false

    a = "abc";
    alert(a);//abc

    a = 1.2;
    alert(a);//1.2

</script>

三、javascript中的函数

等同于java语言中的方法,函数也是一段可以被重复利用的代码片段
函数一般都是可以完成某个特定功能的。

1、回顾java中的方法

[修饰符列表] 返回值类型 方法名(形式参数列表){
    方法体;
}

例如:

public static boolean login(String username,String password){
    ...
    return true;
}
boolean loginSuccess = login("admin","123");

2、JS中函数定义

语法格式:
第一种方式:

function 函数名(形式参数列表){
            函数体;
        }

第二种方式:

函数名 = function(形式参数列表){
     函数体;
}

JS中的函数不需要指定返回值类型,返回什么类型都行

3、演示

<script type="text/javascript">
function sum(a,b){
// a和b都是局部变量,他们都是形参(a和b都是变量名,变量名随意。)
    alert(a + b);
}

sum(10,20);//30

sayHello = function(username){
    alert("hello " + username);
}

sayHello("zhangsan");//hello zhangsan

</script>

<input type="button" value=计算10和20的和 onclick="sum(10,20)"/>//30
<br/>
<input type="button" value="hello" onclick="sayHello('jack');"/>//hello jack

4、JS的重载

在 Java 中函数允许重载。但是在 JS 中函数的重载会直接覆盖掉上一次的,JS当中的函数在调用的时候,参数的类型没有限制,并且参数的个数也没有限制,JS就是这么随意。(弱类型)
重载的含义:方法名或者函数名一样,形参不同(个数、类型、顺序)

function sum(a,b){
    return a + b;
}

alert(sum(10,20));//30

var returnValue = sum("abc");//abc赋值给a变量,b变量没赋值系统默认赋值undefined,+在字符串里连接作用
alert(returnValue);//abcundefined

alert(sum(1,2,4));//3,1赋值给a,2赋值给b,4没用处丢弃

alert(sum());//NaN(NaN是一个具体存在的值,该值表示不是数字。Not a Number)

/*
在JS当中,函数的名字不能重名,当函数重名的时候,后声明的函数会将之前声明的同名函数覆盖
*/

function test(username){
     alert("test1");
 }

 function test(){
     alert("test1test1");
 }

 test("lili");//test1test1,这个调用的是第二个test()函数.

5、函数的 arguments 隐形参数(只在 function 函数内)

就是在 function 函数中不需要定义,但却可以直接用来获取所有参数的变量。我们管它叫隐形参数。
隐形参数特别像 java 基础的可变长参数一样。
public void fun(Object…args);
可变长参数其实是一个数组。那么 js 中的隐形参数也跟 java 的可变长参数一样。操作类似数组*/

function f(a) {
    alert(arguments.length)//可看参数个数

    alert("a = " + a);

    for (var i = 0; i < arguments.length; i++) {
        alert(arguments[i]);
    }

}

f(1,"abc",2);//3 a = 1 1 abc 2
f(1,"abc",2,true);//4 a = 1 1 abc 2 true

    //需 求 : 要 求 编 写 一 个 函 数 。 用 于 计 算 所 有 参 数 相 加 的 和 并 返
    function sum1(num1,num2) {
        var result = 0;
        for (var i = 0; i < arguments.length; i++) {
            if(typeof(arguments[i]) == "number"){
                result += arguments[i];
            }
        }
        alert("num1 = " + num1);//num1 = 1
        alert("num2 = " + num2);//num2 = 2
        return result;
    }

    alert(sum1(1,2,3,"abc",4,5,true));//15

四、局部变量和全局变量

全局变量:
在函数体之外声明的变量属于全局变量,
全局变量的生命周期是:浏览器打开时声明,浏览器关闭时销毁,尽量少用。因为全局变量会一直在浏览器的内存当中,耗费内存空间。能使用局部变量尽量使用局部变量。
局部变量:
在函数体当中声明的变量,包括一个函数的形参都属于局部变量
局部变量的生命周期是: 函数开始执行时局部变量的内存空间开辟,函数执行结束之后,局部变量的内存空间释放。
局部变量生命周期较短。

<body>
<script type="text/javascript">
    // 全局变量
    var i = 100;

    access1 = function(){
        // 访问的是全局变量
        alert("i = " + i);
    }
    access1();//i = 100

    // 全局变量
    var username = "jack";
    function accessUsername(){
        // 局部变量
        var username = "tom";
        // 就近原则:访问局部变量
        alert("usernameIn = "  + username);
    }

    accessUsername();//usernameIn = tom
    // 访问全局变量
    alert("usernameOut = " + username);//usernameOut = jack

    function accessAge(){
        var age = 20;
        alert("ageIn = " + age);
    }

    accessAge();//ageIn = 20
    // 报错(语法不对)
   // alert("ageOut = " + age);

    // 以下语法是很奇怪的.
    function  fun() {
        // 当一个变量声明的时候没有使用var关键字,那么不管这个变量是在哪里声明的,都是全局变量.
        myName = "朴灿烈";
        return myName;
    }

    alert(fun());//朴灿烈

    alert("myName = " + myName);//myName = 朴灿烈

</script>

</body>