多态的本质是:让用户不知道引用实际上是什么类型，也能调用里面的方法，让封装更进一步，降低了用户的使用成本；
举例子:
1)集合类:
List<String> list=new ArrayList<>();
2)多线程:显示继承Thread类，重写Runnable,都要提供run方法，JVM内部调用父类的run方法，执行到我们自己用户执行的run方法
3)DataSource，向下转型
1)有了JS之后，所看到的网页，其实就是相当于是一个webapp，就是和普通的客户端程序没有什么区别了，JS和CSS和HTML类似，都是运行在浏览器上面，在浏览器中，内置了一个JS的执行引擎，这个执行引擎就对标于JAVA中的JVM；
2)其中chrome浏览器，内置的JS引擎，也是谷歌自己研发的，一个非常知名的引擎，叫做V8引擎，又有大佬，把这个V8引擎单独的从浏览器中抽取出来，重新包装了一层，叫做Node JS；
3)vue.js只是一个单独的基于JS实现的在浏览器上运行的库或者是框架，就是为了写JS更方便
4)java的运行，主要是靠JVM，JVM把.class文件(二进制字节码文件)加载到内存中，然后再来解析运行，然后再把java的字节码转化成CPU指令，是直接进行查找文件；
5)对于JavaScript来说，是浏览器先要加载HTML，HTML通过一些方式引入JS，JS的代码大多数是通过网络的方式被下载到浏览器上面，然后浏览器在调用V8引擎来解释执行JS的代码，由V8引擎把JS翻译成二进制的机器指令，然后再进行运行；
对于在浏览器上面执行的JS来说，可以分成三个部分:
1)普通的JS代码
2)DOMAPI:浏览器提供了一组API，让JS可以操作网页中的元素；
3)BOMAPI:浏览器提供了一组API，让JS来操作浏览器的窗口，比如说刷新页面；
JS不区分字符和字符串，像onclick这样的属性，本质上是用来触发一个点击事件；当用户点击这个元素，就会触发一个点击事件，我们通过onclick就可以能够捕获这个点击事件，进一步的就触发了这里面的JS代码；
1)行内式:直接嵌入到html元素的内部
<input type="button" value="你点我一下" onclick='alert("HelloWorld")'> 像onclick这样的属性,是可以嵌入一段JS的,它的功能是获取点击事件,当用户点击这个元素时,就会触发这个点击事件,进一步就触发了JS的代码； <div onclick='alert("你还真点呀")'>点我一下</div>2)内嵌式:直接写到script标签中
alert("helloworld");//相当于java中的System.out.println3)外部式:单独把他写到一个JS文件中
<script src="TestDemo5.js"> </script>1)把JS写到一个单独的文件中，由HTML来进行引入，这个操作往往会触发一个网络请求，网络就会根据当前src的路径来到服务器上面进行获取这个指定的文件，当加载了这个JS之后，就会立即执行
2)当script标签里面有了src这个属性，就不可以在script标签里面写具体的执行代码，写了也不会生效，src表示这个js文件在哪里；
3)如果一个页面中包含了多个script标签，就会按照script标签出现的先后顺序来进行决定执行顺序；JS里面的语句后面的，不是必须的，可以写也可以不写；
JS的输出语句：
1）alert()，它的作用是弹出一个对话框，直接在网页上输出结果；
2）console.log()，在控制台里面打印一个日志，这是给程序员来看的
相比之下，web程序有很多天然的优势，客户端不需要进行更新，只要你的服务器部署了新的代码，每一次浏览器启动之后，都会自动地进行加载新的代码
输入:这时会弹出两个输入框
3）在JS中表示字符串，可以使用单引号，也可以使用双引号，单引号和双引号没啥区别
let a=prompt("请输入你的姓名"); alert(a);
一)变量的使用:
1)创建变量:他是不需要指定显示类型的，在JS中，有用的数据类型只有两种，数字类型和字符串类型，而这两种类型的声明，都是用var/let来声明的,在JS中，可以用typeof来查看数据类型；
2)一个函数参数的类型也是动态的(传参的时候不需要考虑是啥类型函数参数的返回值也是可以自己随意指定的；
3)不管你创建的变量是什么类型，此时都是通过var这个关键字来进行表示的，至于你的变量具体是什么类型，取决于初始化的值是啥类型
var a=3;//表明a是一个整数变量 console.log(a) console.log(typeof(a)); a="abcde";//表名a是一个字符串 console.log(a) console.log(typeof(a)) 我们把变量赋值给数字,那么这个类型就是数字类型;我们把这个变量赋值给字符串,那么这个类型就是字符串类型<script> var num=10;//定义了一个名字为num的整型变量 var s="abcdefg";//定义了一个名字为s,字符串类型的变量 var array=[];//创建了一个名字为array,数组类型的变量 </script>
同时也可以这么写
let a=10; console.log(a); console.log(typeof(a)); a="a"; console.log(a); console.log(typeof(a)1)java是一个静态类型的语言，一个变量的类型，在编译阶段就已经确定了，运行时是不可以改变的类型的，但是在JS中，他是一个动态类型的语言，变量的类型是在运行时可以进行改变的，变量的值和赋值的类型密切相关；
2)我们针对与变量来说，也可以不进行初始化，但是不进行初始化的时候，变量的值就是一个特殊的值，就是叫做undefined，类型也是叫做undfined类型，但是你不能创建一个未初始化的变量，同时指定它为字符串类型；
3)针对于JAVA来说，JAVA可以提供很多的方法，可以随时转换类型，这个说法是错误的，JAVA是把数据转换成不同的类型，赋值给了新的变量，旧的类型该是啥类型还是啥类型
二)基本的数据类型:
1)number:数字，不区分小数和整数
例如console.log(1/2)打印出来的值是0.5，因为数字类型包括小数和分数，JS中不区分小数和整数；
2)boolean类型:只有true和false两种类型
在JS中，布尔类型会当成0和1来进行处理，true的值是1，false的值是0；
2.1)这种设定方式，其实并不科学，这就被称之为隐式类型转换
如果说一个编程语言，越支持隐式类型转换，就认为类型越弱，比如python，JS，php，C
如果说一个编程语言，约不支持隐式类型转换，就认为类型越强，比如C++和JAVA
但是类型强弱和动态类型和静态类型没啥关系，就像是说C语言虽然是一个静态类型，但是仍然是动态类型的语言
2.2)强类型意味着类型之间的差距是更大的，界限是更明确的，编译器就可以做更多的检查，但是弱类型意味着类型之间的差异并不大，界限是更模糊的
var a=true; console.log(typeof(a)); 这个代码打印出来的值是boolean3)undefined:只有唯一的值，表示从来没有被定义过的值，也就是说没有被初始化过；undefined与字符串进行相加，得到的是和字符串拼接的结果；
undefined与数字进行相加得到的结果是NaN，表示的是一个非法的状态，最典型的用法，就是访问JS中某个对象的属性，但是这个属性又不存在
<script> let a; console.log(a); console.log(a+"hello"); console.log(a+10); </script>
在JS中他是可以支持字符串和数字之间的拼接的，会自动地把数字转化成字符串的
4)null:只有唯一的值表示空值，是一个已经定义的值；
他们都表示非法的概念，用typeof(null)，结果是Object类型；
<script> let a=null; console.log(a); console.log(a+"hello"); console.log(a+10); </script>
5)string:表示字符串类型，可以用length来求长度，表示字符的长度；
<script> let s1="my name is 'zhangsan'"; let s2='my name is "zhangsan"'; let s3="my 'name' is \"zhangsan\""; console.log(s1); console.log(s2); console.log(s3); </script>
6)NaN:表示不是一个整数
alert("hello"-10);此时打印出来的值就是NaN 如果把减法换成加法 alert("hello"+10)那么此时打印出来的结果就是hello10,接过来是字符串 let a=b||0; 如果b的值是非空,那么就把a的值设成b,如果b的值为空(null/undefined),就把a的值设成09)在while循环中，如果条件是true，就执行循环体里面的代码 ;
10)parselnt是把字符串转化成整数
11)在JS中c=a||b表示，如果a的值为真，那么就不需要再次计算b了
如果a为true那么表达式的值就是a的值，c=a
如果a为false那么表达式的值就是b的值，c=b
c=a&&b，这就是类似于说短路求值，如果在a这边已经可以确定表达式的值了，就不需要再次计算b了；
如果a的值为假，那么此时c的值就是表达式a的值
如果a的值为真，那么此时c的值就是表达式b的值
由此这就衍生出了JS中的一种经典写法，判定变量是否为空值，如果是空值，那么就给他设置成一个默认值
<script> let x=null; if(!x){ x=0; } //他就等价于说 x=x||0; </script>12)使用==的时候是不会考虑类型的，会自动进行隐式类型型转换，只是来进行两个变量的值，而不会比较两个变量的类型，如果说两个变量能够通过隐式类型转换，转换成相同的值，也认为是相等的
如果想要考虑类型，就要用===来表示，不会自动进行隐式类型转换，既要比较变量的类型，也是要比较变量的值，如果类型不相同，那么直接认为不相等
let a=10; let b="10"; console.log(a==b);这时打印的结果是true,==不考虑具体类型,会尽量进行类型转换 console.log(a===b);这是打印的结果是false let a=true;//true表示0,false表示1 let b=a+1;//a=2 //if语句0表示假,非0表示真13)在使用JS的变量的时候，如果说本来a是一个数字类型，在赋值的时候，可以给他赋值成一个数字类型，也可以给它赋值一个字符串类型，也可以是赋值任意类型，a的类型是在程序运行过程中随着赋值的时候在发生动态变化的
14)
1)站在2022年这样的视角来看，静态类型完胜
基本现在业界已经达成共识，认为静态类型比动态类型更好，静态类型因为编译器可以做更多的检查，让有些错误可以提前被发现，开发工具可以基于类型做更多的分析，提供更加丰富的支持
2)但是动态类型也是有自己的好处的，比如说写一个函数，就可以同时支持多种不同的类型的参数，完全不需要重载，泛型这样的类型的参数，虽然有这个优势，但是还是利大于弊
3)也可以使用let来定义变量:
一些特殊的数字值:
Infinity:无穷大，大于任何数字，表示数字已经超过了JS可以表示的数据范围
-Infinity:无穷小，小于任何数字，表示数字已经超过了JS可以表示的数据范围
NaN:表示当前的结果不是一个数字
通过isNaN()方法来判断是否是一个非数字
<script> console.log(isNaN(100)); console.log(isNaN(200)); </script>
undefined和null的区别:
1)一个没有进行初始化过的变量的值就是undefined，这是未定义的情况，也就是非法的情况，JS未来完全有可能设定成，变量不进行初始化，就直接进行编译报错，只不过是当前JS没有要求的那么严格，于是就搞了一个特殊的undefined的这样的值来表示这个非法情况
2)但是null是表示当前这个值属于没有这个值这个概念，属于合法的情况，在实际开发中使用null值完全OK
数组:
1)数组的创建方式；
2)在Java或者C中，要求数组中的每一个元素必须是相同类型的，但是在动态类型的语言中，是不会做要求的；
1)通过new关键字来创建
let arr1=new Array(); arr1[0]=1; arr1[1]="hello"; arr1[2]="world"; arr1[3]="hi"; arr1[4]=2; console.log(arr1); 此时数组的长度不知道，数组里面的元素类型都可以是任意的2)通过[]来指定
2.1)下面的这种创建方式和JAVA差别很大，JAVA在这里定义数组的时候，使用的是int[]类型，JAVA在针对数组进行初始化的时候使用的是{}，而JS使用的是[]，JS中的数组没有具体类型，可以放不同类型；
2.2)通过console.log(数组名)就可以打印出来数组的元素内容；
<script> let array1=[]; let array2=[12,"abcdrf",9.9,true,undefined]; </script>let arr1=[1,2,"hello","world"]; console.log(arr1); 1)直接在console来指定一个数组名,就可以打印一个数组了 2)如果我们此时写arr1[10]="name"也是可以的,JS会构造一个更大的数组 如果尝试写入数组不存在的下标,就会在这个下标里面添加元素，同时可能会修改数组的长度；但是中间元素的值,仍然是undefined
var arr1=[1,2,"helloworld"]; arr1[10]="var"; console.log(arr1.length); 此时打印的值就是11可以超出数组范围来写元素，但是如果超出范围来读元素，读出的结果任然是undefined;
var arr1=[1,2,3,4,5,6,7]; arr1="hello"; 一开始的时候arr1是一个数组，但是后来arr1被转化成字符串了按照之前的理解，JAVA中要求数组的下标范围是，0-array.length-1，如果超出范围就会抛出一个异常，但是在JS中并非如此，当进行访问一个超出范围的下标的时候，得到的结果是undefined，并不会出现异常
1)此时的长度就变成了101，然后数组的内容，前四个元素仍然是1，2，3，4，下标100的元素还是100，但是中间的空属性*96的意思就是中间这些元素的仍然是undefined
2)数组的长度是可以进行修改的:array.length=7；
3)像-1，"hello"这样的字符串或者数字，是可以不可以作为下标当成是数组中的一个元素，自然也就不会影响长度，但是是可以作为数组的一个键值对属性
<script> let array1=[1,2,3,4]; array1[-1]=100; console.log(array1); </script>
1)此时的-1与其说是一个下标，不如说是一个属性，但是并不会影响这个数组的长度，现在访问array[-1]仍然可以去取出，是一个键值对；
2)甚至我们可以给数组指定一个字符串类型的下标，此处下标与数组下表对应元素的关系，相当于是一个键值对，JS的数组本质上是一个对象，对象是可以在运行过程中可以进行动态的新增或者删除属性的，我们可以通过[]或者.都是可以的
let arr1=new Array(); arr1["hello"]="world";//本质上是创建一个hello属性 console.log(arr1["hello"]); console.log(arr1.hello); arr1.hello=123; console.log(arr1.hello);
3)数组里面的元素可以要求是不同类型的元素，如果数组下标越界，读取的数据就是undefined，写入的数据就相当于对数组进行了扩容；数组的下标不一定非得是数字，还可以是字符串，相当于动态的给数组对象添加了一些属性
4)总结:JS中的数组不是一个正经数组，除了能接数组的活，还可以接map的活，也就是表示键值对，这里说，数组是一个map，更准确地说，数组就是一个对象，在JS里面，是可以在运行的时候给对象来增添属性的，arr['hello']的意思就是说在给arr这个对象，新增了一个属性，属性的名字叫做hello，属性的值叫做10；
5)超过数组下标读元素，-1或者别的，就会读到undfined
数组中的常见操作
1)给数组末尾里面追加元素，相当于是ArrayList中的add操作
let arr1=new Array(); for(var i=0;i<10;i++) { arr1.push(i); } console.log(arr1);2)删除元素arr1.splice(a,b)，第一个参数表示数组要进行开始删除的元素位置，第二个参数表示总共要删除的数组元素个数，在指定的区间内进行删除；
var arr1=[1,2,3,4,5]; arr1.splice(2,2); console.log(arr1); 打印的结果是1，2，5
3)进行替换元素:arr1.splice(a,b,ele1,ele2)
<script> let array1=[1,2,3,4]; array1.splice(1,1,89,19); console.log(array1); </script>
函数:
1)函数(function)就是方法(method)，方法就是函数，function指的就是一个独立的函数，但是method指的是某一个类，方法指的就是某一个对象的成员函数
2)传参是传什么类型都是可以的，只要可以支撑传过来的参数的运算(函数体里面的逻辑),不需要支撑泛型这样的语法；
3)传入的实参类型是任意的，只要能够支持函数内部的逻辑即可，这里面要求两个参数可以进行相加即可，无论是字符串拼接还是数字相加，正因为有这样的特性，JS天然就不需要泛型和重载这样的方法
//创建函数//函数声明//函数定义//参数列表的具体类型不需要写,也不需要写返回值类型 function 函数名 （参数列表） { 函数体 return 返回值； } //函数调用 函数名字(实参列表) 不考虑返回值 返回值=函数名(实参列表) 考虑返回值function hello(){ console.log("hello"); } hello(); function add(a,b) { return a+b; } console.log(add("hello","world"));//字符串拼接 console.log(add(5,3));//数字相加 console.log(add("hello",10);//字符串拼接4)一般在进行写代码的时候，都是需要根据调用的时候传入的实参，个数和形参匹配，但是实际上，JS并没有在语法方面在这方面进行限制，如果实参和形参个数不一样，也不是完全不行
Js对于形参和实参的要求不需要指定类型，也不需要指定个数；对于参数个数来说
1)如果实参个数比形参个数多，那多出来的个数不参与函数运算，就拿不到了
2)如果实参个数比形参个数少，那么此时多出来的值为undefined
function add(x,y){ return x+y; } console.log(add(10)); console.log(add(10,20)); console.log(add(10,20,30)); 此时打印的值是NaN,30,30 <script> function add(a,b,c,d) { a=a||0; b=b||0; c=c||0; d=d||0; return a+b+c+d; } console.log(add(10)); console.log(add(10,20)); console.log(add(10,20,30)); console.log(add(10,20,30,40)); </script> 最终的打印结果就是10,30,60,100 这就不会说无论传递什么参数,打印出NaN值1)上面的第二种写法，只能支持数字相加，如果你想你的代码既能支持数字相加，又能支持字符串相加，这个时候就少不了要进行判定了，判定第一个参数是字符串还是数字，在JS中我们可以通过typeof来进行判断，判断参数的类型，来继续决定后续参数的默认值，是0还是"";
在JS中函数被称之为一等公民，函数就作为一个普通的变量一样，可以赋值给其它类型的变量，也可以作为另一个函数的参数，还可以作为另一个函数的返回值，函数和普通的变量其实并没有本质的区别，但是函数相比于普通变量多了一个功能，可以被调用
2)函数表达式:就是把一个函数赋值给一个变量了
定义一个函数，然后再把这个函数赋值给一个变量
var 变量名字=function(函数的参数列表)
最后通过变量()来调用这个函数
第一种写法:
<script> function func(){ console.log("hello"); } let temp=func; alert(typeof(temp)); //1.此时将func这个变量赋值给了temp这个变量,因为此时func后面没有括号,所以说并不是函数的调用,此时的temp是一个function类型 //2.此时我们就可以通过temp这个变量来调用到上面的func函数 temp(); </script>第二种写法:把上面的声明函数再把函数赋值给一个变量的操作进行了合并
<script> let temp=function func(){ console.log("hello"); } temp(); </script>第三种写法:再进一步，就可以直接把函数声明的函数名给去掉，后续就直接通过这个变量名字来找到这个函数:
这就是定义了一个没有名字的函数，并且把这个函数赋值给了f这个变量，后面就可以基于f这个变量来进行调用函数了，没有名字的函数也被称之为匿名函数，没有名字的函数也叫做lamda表达式；
<script> let temp=function(){ console.log("hello"); } temp(); </script>
var add=function(a,b,c,d){ return a+b+c+d; } console.log(add(10,20)); console.log(add(1,2,3,4)); console.log(typeof add); 打印结果是NaN和10 这是我们定义了一个一个匿名，没有函数名的函数，把这个函数赋值给了另一个变量 那么就可以拿着这个变量来进行函数调用了 不定义函数名的函数叫做匿名函数 let add=function(a,b,c,d){//这里面的函数名可以不用写的 return a+b+c+d; } console.log(add(10,20,30,40,50)); console.log(add(10,20,30,40)); console.log(add(10,20,30)); console.log(add(10,20)); console.log(add(10)); 这个代码的打印结果是100,100,NaN,NaN,NaN作用域链:函数是可以定义在函数内部的，内层函数时可以访问外层函数的局部变量的，作用于就描述了这个变量在那些代码可以访问到
var num=1; function test1() { var num=10; function test2() { var num=20; console.log(num); } test2(); } test1();for(var i=0;i<10;i++) { } console.log(i); 把var设置成let,就不可以在循环外边进行访问了1)在ES6中，引入了let，也就有了块级作用域，也就是说一个变量在{}内部进行定义，是无法在{}外部进行访问的
2)在JS里面{}内部的代码是可以访问到{}外部的变量的
<script> let a=10; function hello(){ alert(a); } hello(); </script><script> let a=10; function hello(){ function hello1(){ console.log(a); } hello1(); } hello(); </script>在JS中的作用域是支持逐级向上进行查找的，当前是在hello1这个函数里面进行查找，尝试打印num，但是在hello1里面并没有这个函数，没有找到num变量，于是就继续向上找，找到了hello函数这里，但是在hello函数这里，也没有找到num这个变量
于是还是继续向上找，找到了全局作用域，最后找到了num变量，如果在作用域的不同节点上面，存在多个同名的变量，就从里向外找，先找到谁就算谁
如果我们想要强制来进行访问最外部的a，我们就只能在hello1里面加上一个实参，把外面的这个变量给进行传递进来，还是从里向外找
1)总而言之，JS中某一个函数中尝试使用的变量就会沿着这个函数定义的嵌套关系，逐渐向上找,一直找到最顶层的全局作用栈；
2)这里面最终的打印结果是20，执行test2中的console.log()的时候，会先在test2中的局部作用域去查找num，如果没有找到就继续向test1中去找,如果还没有找到,就去全局作用域去找;3)作用域链:这些大括号，这些代码块，就构成了一个链表这样的数据结构，相当于是一直想上找，函数里面是可以找到函数作用域外之外的变量；
4)此时的参数类型可变操作，不属于动态类型的通用属性，而是属于JS的专用属性，这样做的目的就是为了让代码变得更加灵活，但是编译器会做更少的检查和校验；
对象:
在JS中，类这个概念是很模糊的
通过字面量来创建对象
1)对象其实本质上来说就是一些属性和方法的集合，在JAVA中，需要先有类，然后才会根据类的实例化来产生对象，类就相当于是一个图纸，根据这个图纸可以创建很多房子
2)在JAVA中，类可以被视为是一种自定义的类型，比如说Cat和Dog是两种不同的类型，在JS中，对象是不会依托于类的，在JS中所有的对象都是同一种类型，就全部是Object类型，在JS里面我们就可以直接通过{}的方式来进行创建对象
var a={};//这表示创建一个空的对象 var student={ name: "李佳伟", height:175, weight:208, sayhello:function(){ console.log("hello"); } }; 这就创建了一个对象 let teacher={ name:"刘树军", age:19, sayhello:function(){ console.log("world"); } } let student1=student; console.log(student1.name); console.log(student1.height); student1.sayhello(); student1=teacher; console.log(student1.name); student1.sayhello(); console.log(student1==teacher)//true console.log(student1.name); console.log(student1['name']);
其实从上面来看，每一个属性和方法，其实本质上来说都是通过键值对的方式来表达的，{}表示这是一个对象，键值对之间使用都还来分割，键和值之间使用冒号来进行分割，后续我们就可以通过student.属性名字来进行访问对象中的方法和字面值常量了
<script> let Father={ username:"李树全", password:"12503487", age:"46", say:function(){ alert("我爱中国"); }, run:function(){ alert("每天跑步三小时") } } alert(Father.username); alert(Father.password); alert(Father.age); Father.say; Father.run; </script>1)上面是错误的，Father.say()和Father.run()，对象(当前对象的格式和JSON是很像的)
2)从ES6开始，也引入了class，也引入了继承，也有了构造方法，对象里面的属性是可以使用点号来进行访问问的；
3)也可以通过[]的形式来进行访问，注意以数组下标的形式来进行访问要加上''符号来进行访问
4)注意:我们是通过{}来创建对象的，对象里面的成员属性和方法要用键值对的形式来组织；
其次，键值对之间要用:来分割；键和值之间使用，来分割;
方法的值是一个匿名函数；当调用函数的时候，不要忘了写上小括号；
一个对象可以有任意个这样的属性，况且可以运行时动态新增
2)通过new Object()来创建对象:因为在JS中的对象，都是Object类型
<script> var student=new Object(); student.username="张三"; student.password="12503487"; student['height']="178"; student.sayHello=function(){ console.log("你好我是中国人"); } console.log(student.username); console.log(student.password); console.log(student.height); student.sayHello(); </script>var student=new Object(); student.name="郭宇泽"; //如果当前student类中不包含name属性,那么就会新创建出name属性;如果说包含name属性,就会修改原来的name属性的值 student.height=178; student.weight=200; student.sayhello=function(){ console.log("hello"); } console.log(student.name); student.sayhello(); 这时我们就可以说，一个这样的对象有若干个这样的属性，并且可以进行动态新增3)通过构造函数来创建对象：如果说想要创建出多个类似的对象出来，刚才的方式就有一点麻烦，因为刚才的对象中都有height，age，name属性
当看到函数内部，通过this这样的方式来进行创建属性的时候，这个函数大概率就是构造函数了
new后面的名字，是构造函数的名字，不是类的名字
基本语法： function 构造函数名(形参){ this.属性=值; this.方法=function.... } var s1=new 构造方法名(实参); 形如这样的函数就叫做构造函数注意:在构造函数时内部要写上this关键字来表示当前正在构建的对象，构造函数不需要return，创建对象的时候必须使用new关键字；
在JS底层仍然是通过构造方法的方式来进行创建实例的
new 关键字的执行过程：
1)现在内存中开辟一个空的对象；
2)this 指向刚才的空对象；
3)执行构造函数的代码，给对象创建对应的属性和方法
4)返回这个对象，本身不需要return，new代替了；
function cat(name,age){ this.name=name;//属性 this.gae=age; this.hello=function(){ console.log("我要对你说hello") }//创建构造方法,创建出一个构造方法,主要是为了构建对象 } //上面的内容类似于Java中类的定义,此处是通过函数来进行凑活一下的; //下面相当于创建了一个又一个的对象 let cat1=new cat("中华田园猫",20); let cat2=new cat("波斯猫",19); console.log(cat1.name+cat2.name+"正在一起玩");<script> var student={ username:"zhangsan", password:"12503487", age:18, school:"内蒙古工业大学", success:function(data,status){ console.log(data); console.log(status); } } </script>1)因此在JS中也是有一些现成的对象的，像数组本质上也是一个对象，可以随时给他动态的新增一个属性；
2)JS虽然有对象，但是他不是面向对象的编程语言，JS中没有封装继承，多态这样的面向对象的经典特性；
4212
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
