this 题目集合

已于 2022-12-15 17:26:08 修改
阅读量445 收藏 1
点赞数
分类专栏： 练习 文章标签： this
于 2020-11-25 11:18:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A123ppleQueen/article/details/110120425
版权

题目一 说出下列this指向和输出的值

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var _name='global';
		var obj={
			func(){
				const innerFunc=()=>{
					console.log(this._name);
				}
				return innerFunc;
			},
			_name:'local',
		};
	  
	  // 语句1
	  obj.func()();
	  
	  // 语句2
	  var func=obj.func;
	  func()();
	  
	  // 语句3
	  obj.func.bind({_name:"newObj"})()();
	  
	  // 语句4
	  obj.func.bind()()();
	  
	  // 语句5
	  obj.func.bind({_name:'bindObj'}).apply({_name:'applyObj'})();
	</script>
	</body>
</html>

分析：语句1最里面的是箭头函数，箭头函数this和外部保持一致，箭头函数外面是对象点方法(方法es6简写)，所以this指向obj

this._name的值可以看成是obj._name所以值为local,总感觉这里有些迷糊，对象点属性是这样的吗？

这里没有设计变量和函数作用域声明提升这些问题吗？

语句2 无论怎么样我都不理解，假设是把obj.func的值付给了变量func,那么变量func的值就应该为local，那为什么下面还可以调用变量啊。就算把变量func看做是声明表达式，箭头函数内部指向还是看外部，obj.func不还是指向obj吗？怎么就指向window了？

            假设我把obj.func看做是一个取出来独立的函数，就可以理解为window,函数全局下值指向window,window.name值就是global

但是我总是忍不住想这个是不是和函数作用域和声明提升有关系

对了忘了说了，我不能理解为什么把一个方法赋给变量，变量还能进行调用？？？？？，声明表达式可以调用吗？等会去看看

语句3 bind改变this指向，指向由obj变为传入的这个指向对象，值为newObj

语句4 bind没有传入自定义this的时候，null,undefined时，继续指向原来的this,不懂这样的话，值不应该是local吗？

语句5 this一旦被bind后，就不会被call和apply修改，所以值为bindObj

JS专项42：箭头函数中的this指向谁？_哔哩哔哩_bilibili

题目二 改一些地方让下面代码输出值

原代码

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			// 修改前
	     var circle = {
			 radius:10,
			 outerDiameter:function(){
				 var innerDiameter = function(){
					 console.log(this);
					 console.log(2 * this.radius);
				 };
				 innerDiameter();
			 },
		 };
		 circle.outerDiameter();
	   </script>
	</body>
</html>
原代码this指向和输出值

 修改方法一

使用临时变量缓存this

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			// 修改前
	     var circle = {
			 radius:10,
			 outerDiameter:function(){
				 // 增加这一行代码，把this改为_this
				 var _this=this;
				 var innerDiameter = function(){
					 console.log(this,"this指向");
					 console.log(_this,"_this指向");
					 console.log(2 * _this.radius);
				 };
				 innerDiameter();
			 },
		 };
		 circle.outerDiameter();
	   </script>
	</body>
</html>

修改方法二：

bind提前绑定this

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
	     var circle = {
			 radius:10,
			 outerDiameter:function(){
				 var innerDiameter = function(){
					 console.log(this,"this指向");
					 console.log(2 * this.radius);
				 };
				 // 增加代码，改变了this指向
				 innerDiameter = innerDiameter.bind(this);
				 innerDiameter();
			 },
		 };
		 circle.outerDiameter();
	   </script>
	</body>
</html>

修改方法三：

箭头函数，本身没有this,与外面函数this指向一致

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
	     var circle = {
			 radius:10,
			 outerDiameter:function(){
				 var innerDiameter = ()=>{
					 console.log(2 * this.radius);
					 console.log(this,"this指向");
				 };
				 innerDiameter();
			 },
		 };
		 circle.outerDiameter();
	   </script>
	</body>
</html>

 题目三 箭头函数

题目一

思考为啥下面this的值是1，而不是2

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			// 箭头函数中的this是不能被call apply去改变
			// 奇怪，不是说call apply bind就是改变箭头函数this指向的吗？
            //call 改变方法执行的主体
            //生成foo实例的时候，print已经创建了
			class Foo{
				print = () => {
					console.log(this.x);
				};
				
				constructor() {
					this.x = 1;
				}
			}
			let foo = new Foo();
			foo.print.call({ x:2 });
		</script>
	</body>
</html>

题目二

思考下面的值为何改变了

我没听懂，不过证明了以前call没记错，不过场景要细分区别

JS专项42：箭头函数中的this指向谁？_哔哩哔哩_bilibili

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function printThis(){
				let print = () => console.log(this);
				
				print();
			}
			printThis.call([1]);
			printThis.call([2]);
		</script>
	</body>
</html>

题目四 call apply bind

call还可以实现继承喔

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var o1 = {
				number: 1,
				getNumber: function (num) {
					return this.number + num;
				}
			};
			var o2 = {
				number: 2,
			}
			console.log(o1.getNumber(2));
			console.log(o1.getNumber.call(o2,2));
			console.log(o1.getNumber.apply(o2,[2]));
			
			var fn = o1.getNumber.bind(o2);
			console.log((2));
			
			// call与this,继承
			// 父类
			function Animal(name){
				this.name = name;
				this.age = 10;
			}
			
			// 子类
			function Cat(name){
				Animal.call(this,name);//这里用了call，继承了animal诶
				this.catName = 'cat';
			}
			var cat = new Cat('Tom');
			console.log(cat);
		</script>
	</body>
</html>

 题目五

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function Person(name){
				this.name=name;
			}
			var p = new Person("kevin");
			console.log(p.name);
			
			// 假设把这个构造函数当成是一个普通的函数
			Person("kate");
			console.log(window.name);
		</script>
	</body>
</html>

 题目六

经典的我觉得在对象方法里的声明表达式this指向全局

我果然觉得这个和变量提升很像啊，怎样区分是变量还是this呢？ 

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var value = 10;
			var obj = {
				value: 100,
				method: function() {
					var foo = function() {
						console.log(this.value);
						console.log(this);
					}
				foo();
				return this.value;
				}
			}
			// 函数特性就是调用一遍就执行一遍
		   obj.method();
		   
		   var c = obj.method();
		   console.log(c,"obj.method");
		</script>
	</body>
</html>

题目七

我又不懂了，我以为function里面的number都是30,结果是两个都是20,然后函数下面我以为会是30,结果是10，然后我以为最后一个number会是10的时候，结果是20，难道是我又把var那里的知识忘了，需要重新复习

对了，忘了这是csdn，不是hbuildex,不会显示第几行

JavaScript专项40：this到底指向谁？_哔哩哔哩_bilibili

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var number = 10;
		function Person(){
			// 全局变量number覆写
			number = 20;
			// 增加实例变量
			this.number = 30;
			console.log(number);
			console.log(window.number);
		}
		console.log(number);
		Person.prototype.getNumber = function(){
			console.log(this.number);
			return this.number;		
			
		}
		var p = new Person();
		console.log(p.getNumber());
		console.log(number);
		</script>
	</body>
</html>

题目八

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		function getName(){
			console.log(this.name);
		}
		getName();
		</script>
	</body>
</html>

题目九

看this.id值两次调用的不同

它们在玩一个很新的东西

第二个题关于参数的问题是这样的，函数的实参传值需要形参来接受，但是这个off()函数没有形参，然后它执行了这个函数，this指向全局，值为undefined可以理解吗？变量声明未赋值值为undefined。如果不注释掉var war=33,输出值就为33

call还可以这样用，震惊----不对，call本来就是改变this指向的啊

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var id=66;
		function fn5(){
			setTimeout(()=>{
			   console.log(this.id)
			})
		}
		fn5({id:22})
		fn5.call({id:22});
		
		// 函数参数我也懵了，？？？？？
		// var war=33;
		function off(){
			setTimeout(()=>{
			   console.log(this.war)
			})
		}
		off({war:11})

		</script>
	</body>
</html>

题目十

use strict 下this指向undefined

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		function a(){
			function b(){
				console.log(this);
				function c(){
					"use strict";
					console.log(this);
				}
				c();
			}
			b();
		}
		a();
		</script>
	</body>
</html>

题目十一

最后一个是小红没懂

听也听不懂

不对，不对，是我搞混了，这个speacial不是独立的

JavaScript的this关键字 - Web前端工程师面试题讲解_哔哩哔哩_bilibili

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var name = "小白";
		function special(){
			console.log('姓名：' + this.name);
		}
		
		var girl = {
			name:"小红",
			detail: function(){
				console.log("姓名:" + this.name);
			},
			woman: {
				name: "小黄",
				detail: function(){
					console.log("姓名：" + this.name);
				},
			},
			special: special,
		}
		girl.detail();
		girl.woman.detail();
		girl.special();
		</script>
	</body>
</html>

题目十二

第一段代码写了我看见代码的第一反应和想法，大家可以看下面的代码

下面那五个才是执行啊，也对函数要调用才能执行

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var name = "小红";
		function a(){
			var name = "小白";
		    console.log(this.name);
		}
	   function d(i){
	        return i();
	  }
	  var b = {
		  name: "小黄",
		  detail: function (){
			console.log(this.name);
		  },
		  bibi: function(){
			  return function(){
				  console.log(this.name);
			  };
		  },
	  }
	  var c = b.detail;//小黄
	  b.a = a;//小红，但是b哪里来的a,b一个对象怎么点a啊
	  var e = b.bibi();//bibi-this指向b,但是return这里function是不是指向window呢？还是指向bibi
	  
	  a();//函数a指向全局，值为小红   √
	  c();//小黄，执行过程跟之前也一模一样     ×小红
	  b.a();//对象可以直接执行另一个函数？？小黄  √
	  d(b.detai);//返回小黄  ×小红
	  e();//小黄或者小红   答案是小红
		</script>
	</body>
</html>

var c=b.detail 对他进行调用结果为小红，但是b.detail单独执行就是小黄。

好了，恭喜我晕了又不懂了，特别是和题目六联动以后，这两个题逻辑好像是反的

不对劲，题目六好像两个值是一个this.value,一个是return value值，奇怪

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var name = "小红";
		function a(){
			var name = "小白";
		    console.log(this.name);
		}
	   function d(i){
		   return i();
	  }
	  var b = {
		  name: "小黄",
		  detail: function (){
			console.log(this.name);
		  },
		  bibi: function(){
			  return function(){
				  console.log(this.name);
			  };
		  },
	  }
	  var c = b.detail;
	  b.a = a;
	  var e = b.bibi();
	  
	  a();
	  c();
	  b.a();
	  d(b.detail);
	  e();
		</script>
	</body>
</html>

题目十三

【大汉前端】js里this指向你都靠猜？这5种情况快速了解本质！_哔哩哔哩_bilibili

 13.1

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function print() {
				console.log(this);
			}
			let obj = {
				a: 1,
				b: 2,
			};
			obj.print = print;//没有这句就要报错
			obj.print();
		</script>
	</body>
</html>

13.2 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function print() {
				console.log(this);//obj.o
			}
		    let obj = {
				a: 1,
				b: 2,
				o: { }
			};
			obj.o.print = print;
			obj.o.print();
		</script>
	</body>
</html>

13.3 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			let print = () => {
				console.log(this);//window
			}
			let obj = {
				a: 1,
				b: 2,
			};
			obj.print = print;
			obj.print();
		</script>
	</body>
</html>

13.4 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function print  () {
				console.log(this);
			}
			let obj = {
				a: 1,
				b: 2,
			};
			let o = {
				c: 3,
			}
			obj.print = print;
			obj.print.call(o);
		</script>
	</body>
</html>

13.5 

 

let preson=  是在构造实例    person(大可爱)是在把它当函数调用   第三个是在输出name的值  

注意return的值 {}值是undefined  123值是小可爱，基本数据类型值都是小可爱

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function Person(name) {
				this.name = name;
				console.log(this);
				// return {};
				// return 123;
			}
			let person = new Person("小可爱");
			Person("大可爱");
			console.log(person.name);
		</script>
	</body>
</html>

13.6 

不懂 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		// 这种还是闭包
		function print() {
			return function () {
				console.log(this);//window
			}
		}
		let obj = {
			a: 1,
			b: 2
		};
		obj.print = print;
		obj.print()();
		</script>
	</body>
</html>

13.7

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		// 这种还是闭包
		function outer() {
			let obj = {
				inner: function () {
					console.log(this); //obj
				}
			}
			obj.inner();
		}
		let obj = {
			a: 1,
			b: 2
		};
		obj.outer = outer;
		obj.outer();
		</script>
	</body>
</html>

 13.8

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		// 这种还是闭包
		Window.name = "window han";
		let obj = {
			name : "cute",
			outer: function(){
				this.name = "cool";
				function inner () {
					console.log(this);//windwo
				}
				return inner;
			}
		};
		obj.outer()();
		</script>
	</body>
</html>

13.9

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		// 这种还是闭包
		Window.name = "window cute";
		let obj = {
			name : "cool",
			outer: function(){
				this.name = "chain";
				function inner () {
					this.name = "confirm"
					function innerInner () {
						console.log(this.name);//inner
					}
					return innerInner;
				}
				return inner;
			}
		};
		obj.outer()()();
		</script>
	</body>
</html>

13.10 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		function print() {
			let that = this;
			return function () {
				console.log(that);//obj
			}
		}
		let obj = {
			a: 1,
			b: 2
		};
		obj.print = print;
		obj.print()();
		</script>
	</body>
</html>

题目十四

不懂，没懂为什么要说类

this（2）_哔哩哔哩_bilibili

14.1

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		   // 类的本质是一个函数
		   class Test {
			   test () {
				   console.log(this);
			   }
		   }
		      
			const test = new Test();
			test.test();
		</script>
	</body>
</html>

14.2

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		   // 类的本质是一个函数
		   class Test {
			   constructor () {
				   // 类的非静态方法会在实例化（new）的过程中添加到this中
				   this.test = function () {
					   // 非静态方法，在construction中添加的都是非静态方法
					   console.log('none-static:' + this);
				   }
			   }
			   // 这个是静态方法（原型上的静态属性），它是本身在定义中就放到了Test.prototype{...}
			   // 原型链过程   new this->{}->_proto_->Test.prototype{test}->_proto_->...->Object.prototype
			   test () {
				   console.log('statci' + this);
			   }
		   }
		      
			const test = new Test();
			test.test();
		</script>
	</body>
</html>

14.3

这个不是练习题，讲了一下class类 ，虽然不懂为什么要讲这个

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		   class Father {
			   constructor() {
				   this.age = 44;
			   }
			   swim () {
				   console.log('go swimming');
			   }
		   }
		   
		   class Son extends Father {
			   // constructor又是干什么的 20221213
			   constructor () {
				   // super 调用了father上的constuctor ,生成this的绑定->father this ，内部指向了（->）Son的实例
				   // 等于new指向了new father,new father生成了一个对象  this->new Father()->{};
				   super();
				   this.body = 'traval';
				   console.log(this.age);
			   }
			   study () {
				   // 晕，这样可以打印的话，super是干什么的来着 20221213
				   this.swim();
			   }
		   }
		   
		   const son = new Son();
		   son.study();
		</script>
	</body>
</html>

14.4

bind只能生效一次 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		  var obj = {
			  a: 1
		  }
		  
		  var obj2={
			  a:100
		  }
		  var a = 2;
		  
		  function test (b,c) {
			console.log(this.a,b,c);  
		  }
		  
		  // bind只生效一次
		 var t = test.bind(obj2,3,4).bind(obj,3,4);
		 t();
		</script>
	</body>
</html>

14.5

注意：一般情况下use strict下值为undefined,箭头函数下是全局

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		'use strict';
		const test = () =>{
			console.log(this);
		}
		
		function test1() {
			console.log(this);
		}
		
		const test2 = function () {
			console.log(this);
		}
		
		test();
		test1();
		test2();
		</script>
	</body>
</html>

14.6

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1
		}
		obj.test = () => {
			console.log(obj);
			console.log(this);//this指向window
		}
		obj.test();
		</script>
	</body>
</html>

14.7

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1
		}
		obj.test = function () {
			var t = () => {
				console.log(this);//this指向obj
			}
			t();
		}
		obj.test();
		</script>
	</body>
</html>

14.8

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1
		}
		obj.test = function () {
			setTimeout(()=>{
				console.log(this);//指向obj
			},0)
		}
		obj.test();
		</script>
	</body>
</html>

14.9

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1
		}
		obj.test = function () {
			var t1 = ()=>{
				var t2 = () => {
					console.log(this);//指向obj
				}
				 t2();
			}
			t1();
		}
		obj.test();
		</script>
	</body>
</html>

14.10

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1
		}
		obj.test = function () {
			var t1 = function(){
				var t2 = () => {
					console.log(this);//指向window
				}
				 t2();
			}
			t1();
		}
		obj.test();
		</script>
	</body>
</html>

14.11

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1,
			b:2,
			test:function () {
				console.log(this.a);
			},
		   c:{
			   d:4,
			   test3:function() {
				   console.log(this);//this->obj.c 也就是this指向obj.c
				   console.log(this.d);//4
			}
		   }
		}
		obj.c.test3();
		</script>
	</body>
</html>

14.12

这里的function t是一个孤立的成员，不是object的成员，最近的就是window

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1,
			b:2,
			test3:function() {
				 function t () {
					 console.log(this);//this->window
				 } 
				 t();
			} 
		}
		obj.test3();
		</script>
	</body>
</html>

14.13

好麻烦，老师的结果为3，或者改动后为undefined,没有NaN的结果，我是哪里敲的不一样啊啊啊啊啊

我需要全部重敲一遍，对下结果

我说呢，老师的后面有重新给a值,b值，我真的醉了

我本人敲的，与老师最后的结果不一样，他是3 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1,
			b:2,
			test3:function() {
				 function t () {
					 console.log(this);//this->window
				 } 
				 t();
			} 
		}
		obj.test3();
		// 注意：__proto的__按键需要敲两下
		obj.__proto__ = {
			e:20
		}
		console.log(obj.e);//20
		
	
		var obj3 = Object.create({
			test4: function() {
				console.log(this,"obj3");//{}
				console.log(this.a + this.b);//NaN
			}
		})
		obj3.test4();
		</script>
	</body>
</html>
标题 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var obj = {
			a:1,
			b:2,
			test:function() {
					 console.log(this.a);
			}
		}
			
		obj.test();
	
		var obj3 = Object.create({
			test4: function() {
				console.log(this,"obj3");
				console.log(this.a + this.b);//3
			}
		})
		// 就是下面两行代码
		obj3.a=1;
		obj3.b=2;
		
		obj3.test4();
		</script>
	</body>
</html>

14.14

我觉得这一部分应该放到对象里去，不懂为什么将这一部分

构造函数里默认隐式返回this,或者手动返回this,这个this指向的新对象构造都是成功的

如果手动返回了一个新对象，this指向的新对象的构造是失败的

如果手动返回了一个新对象，this指向对象就被忽略了

上面三句话我的大脑都不理解哈哈哈哈哈

感觉是对象那块的知识 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		// 字面量方式定义对象
		// function Object (){}
		
		var obj = {
			a:1,
			b:2
		}
		console.log(obj);
		
		// Object.create
		var obj2 = Object.create({
			c:3,
			d:4
		})
		console.log(obj2);
		
		// 这种创造出来的没链
		var obj3 = Object.create(null);
		obj3.a = 1,
		obj3.b = 2;
		console.log(obj3,"obj3");
		
		// Object.defineProperty();
		// 它可以拦截值和设置值
		var obj4 = {};
		Object.defineProperty(obj4,'a',{
			get:function () {
				console.log('I have money');
				console.log(this);//this->obj4
			}
		})
		obj4.a;
		</script>
	</body>
</html>
上面三句话对应的列子 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		// 构造函数
		// 第一种this->实例化对象
		//过程 this->{} ,找到a/b属性并赋值，再隐式返回出去（就是不用把return写出来）
		function Test () {
			this.a = 1;
			this.b = 2;
			console.log(this);
		}
		new Test();
		
		// 把return写出来，结果一样
		function Cute(){
			this.a = 1;
			this.b = 2;
			console.log(this);
			return this;
		}
		new Cute();
		
		// 把return 写出来，并重新赋值
		function Cool(){
			this.a = 1;
			this.b = 2;
			console.log(this);
			return {
				c:3,
				d:4
			};
		}
		// 这里写出来，结果就不一样了
		// new Cool();
		var cool = new Cool();
		console.log(cool);
		var cool2 = Cool();
		console.log(cool2);
		
		</script>
	</body>
</html>

14.15 重要应用好生看看

不是想要的答案7 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<!-- <button id="J_btn">test</button> -->
		<button id="btn1">+</button>
		<script>
			// test按钮
		// var OBtn = document.getElementById('J_btn');
		
		// 事件处理函数内部的this指向被绑定的DOM元素
		// OBtn.onclick = function () {
		// 	console.log(this);
		// }
		
		// OBtn.addEventListener('click',function() {
		//   console.log(this);	
		// },false)
		
		// +号按钮
		;(function(doc){
			var btn1 = doc.getElementById("btn1");
			function Plus(a,b){
				this.a = a;
				this.b = b;	
				
				this.init();
			}
			Plus.prototype.init = function() {
				this.bindEvent()
			}
			Plus.prototype.bindEvent = function () {
				btn1.addEventListener('click',this.handleBtnClick,false)
			}
			
			Plus.prototype.handleBtnClick = function() {
				console.log(this.a + this.b);
				// 为了明白为什么结果为NaN,打印一下this
				console.log(this.a,this.b);
				console.log(this);
			}
			
			window.Plus = Plus;
		})(document);
		
		new Plus(3,4);//结果为NaN
		</script>
	</body>
</html>

 方法一

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<button id="btn1">+</button>
		<script>
		// +号按钮
		;(function(doc){
			var btn1 = doc.getElementById("btn1");
			function Plus(a,b){
				this.a = a;
				this.b = b;	
				
				this.init();
			}
			Plus.prototype.init = function() {
				this.bindEvent()
			}
			// 使用bind改变this指向
			Plus.prototype.bindEvent = function () {
				btn1.addEventListener('click',this.handleBtnClick.bind(this),false)
			}
			
			Plus.prototype.handleBtnClick = function() {
				console.log(this.a + this.b,"加的和");
				// 为了明白为什么结果为NaN,打印一下this
				console.log(this.a,this.b);
				console.log(this);
			}
			
			window.Plus = Plus;
		})(document);
		
		new Plus(3,4);//结果为NaN
		</script>
	</body>
</html>

方法二

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<button id="btn1">+</button>
		<script>
		// +号按钮
		;(function(doc){
			var btn1 = doc.getElementById("btn1");
			function Plus(a,b){
				this.a = a;
				this.b = b;	
				
				this.init();
			}
			Plus.prototype.init = function() {
				this.bindEvent()
			}
			// 使用_self
			Plus.prototype.bindEvent = function () {
				var _self = this;
				btn1.addEventListener('click',function(){
					_self.handleBtnClick();
				},false)
			}
			
			Plus.prototype.handleBtnClick = function() {
				console.log(this.a + this.b,);
			}
			
			window.Plus = Plus;
		})(document);
		
		new Plus(3,4);
		</script>
	</body>
</html>

14.16

看下两个图的区别

请复习复习类

原代码 
<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			
			class Father {
				// 让函数内部的this指向固定值
				constructor () {
					this.eat = this.eat.bind(this);
				}
				get fruit () {
					return 'apple';
				}
				eat () {
					console.log("我要吃" + this.fruit);
				}
			}
			
			class Son  {
				get fruit () {
					return 'pear';
				}
			}
			
			const father = new Father();
			const son = new Son();
			
			father.eat();
			
			son.eat = father.eat;
			son.eat();
		</script>
	</body>
</html>

代码改变后 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			
			class Father {
				// 让函数内部的this指向固定值
				constructor () {
					this.eat = this.eat.bind(this);
				}
				get fruit () {
					return 'apple';
				}
				eat () {
					console.log("我要吃" + this.fruit);
				}
			}
			
			class Son  {
				get fruit () {
					return 'pear';
				}
			}
			
			const father = new Father();
			const son = new Son();
			
			father.eat();
			
			son.eat = father.eat;
			son.eat();
		</script>
	</body>
</html>

题目十五

快速理解函数this指向问题_哔哩哔哩_bilibili

 15.1

函数一定要执行记住啊啊啊

这里我不懂了，箭头函数外部不是obj吗？所以指向obj，为啥外部是window了 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		let obj = {
			a:1,
			show:()=>{
				console.log(this);
			}
		}
		obj.show();
		</script>
	</body>
</html>

 15.2

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			// 构造函数
		function People(name,age) {
			this.name = name;
			this.age = age;
		}
		let kevin = new People("kevin",16);
		console.log(kevin);
		
		// 构造函数return 1
	    function Cute(act,make){
			this.act = act;
			this.make = make;
			return 1
		}
		 
		let Alan = new Cute('draw',"singer");
		console.log(Alan);
		
		//构造函数return 对象
		function Greet(name,cover){
			this.name = name;
			this.cover = cover;
			return {
				a:1,
				b:2
			}
		}
		let Lucia = new Greet("Lucia","notebook");
		console.log(Lucia);
		</script>
	</body>
</html>

题目十六

函数独立调用指向window

前端JS中重难点--this指向的四种绑定规则&箭头函数中的this_哔哩哔哩_bilibili

16.1

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var obj = {
				a:2,
				foo:function(){
					console.log(this);
					function test(){
						console.log(this,"Test");
					}
					// 好神奇，这个test写在obj.foo下面会报错
					test();
				}
			}
			obj.foo();
			
		</script>
	</body>
</html>

16.2

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var obj = {
				a:2,
				foo:function(){
					console.log(this);
					
					(function(){
						console.log(this,"()");
					})()
				}
			}
			obj.foo();
		</script>
	</body>
</html>

16.3

跟this相比，我更好奇这个代码 return 函数

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var obj = {
				a:2,
				foo:function(){
					console.log(this);
					
					function test(){
						console.log(this);
					}
					// 返回test本身，要让它执行，在加一个()
					return test;
				}
			}
			obj.foo()();
		</script>
	</body>
</html>

16.4

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var a = 0;
			function foo(){
				console.log(this);
			}
			var obj = {
				a:2,
				foo:foo
			}
			// 1
			obj.foo();
			
			// 2
			// 赋值完后没有执行（执行是obj.foo）,等于直接把foo给了bar，bar再执行
			// var bar =foo 等效
			var bar = obj.foo;
			bar();
			
			// 3
			// bar1()再这样写会报错
			var bar1 = obj.foo();
		</script>
	</body>
</html>

16.5

这是人写的代码？我平时学习的时候也没有看见过这种代码啊!!!!!!!!!

代码阅读理解

bar()执行，然后把obj.foo当成实参，bar(fn)里的fn当成形参,如果把obj.fun替换fn()，值就是window,因为obj.foo没有执行,就等于独立调用了函数,值就是window

但是我不懂，obj.fun替换fn()，fn()后面不是本身就有一个（）吗？有括号就执行了啊

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			// 
			var a = 0;
			function foo(){
				console.log(this);
			}
			
			function bar(fn){
				fn();
			}
			var obj = {
				a:2,
		        foo:foo
			}
			
			bar(obj.foo)
bar(obj.foo)
			
			//下面代码值——>obj ,但是fn is not a function，why???
			//bar(obj.foo())
		</script>
	</body>
</html>

16.6

为什么有4个windwo值，是因为循环吗？

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			//父函数决定子函数的this
			var arr = [1,2,3]
			arr.forEach(function(item,idx,arr){
				console.log(this);
			})
			arr.sort(function(a,b){
				console.log(this);
				return a-b
			})
			
			// 这个也是window，会一直加载，不设置停止时间
			// setInterval(function(){
			// 	console.log(this);
			// })
		</script>
	</body>
</html>

16.7

new绑定优先级最高，显示绑定call,bind/apply次之，然后是隐式绑定，然后是默认绑定

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			var obj = {
				a:1
			};
			// 指向window
			// (function(){
			// 	console.log(this);
			// })()
			
			// 指向obj
			(function(){
				console.log(this);
			}).call(obj)
		</script>
	</body>
</html>

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
			function Person(){
				this.a = 1;
				// 一般都不这样做
				return {};
			}
			var person = new Person();
			console.log(person);
		</script>
	</body>
</html>

16.8 一种应用做题·，说下两个值是多少

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var name = "222";
		var a = {
			name:'111',
			say:function() {
				console.log(this.name);
			}
		}
		
		var fun = a.say;
		fun ();
		a.say();
		</script>
	</body>
</html>

16.9

看不懂这段代码，这段代码在我这就是一个错误，一个乱码

obj1.a是怎样成功执行的？？？？  那里来的a，a不是函数里的吗？？？

2_箭头函数的this&this的优先级_哔哩哔哩_bilibili  14分钟那里讲这个

我没有学过这样用的函数啊啊啊啊啊啊啊啊

这个题还可以看优先级

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		function foo(b){
			this.a = b;
		}
		
		var obj1 = {};
		
		var bar = foo.bind(obj1);
		
		bar(2);
		
		console.log(obj1.a);//?
		
		var baz = new bar(3);
		console.log(obj1.a);//?
		
		console.log(baz.a);//?
		</script>
	</body>
</html>

 16.10 重要应用

 翻车指南值得拥有

错了，注意审题 自己猜错了答案 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var a = 0;
		function foo () {
			// 为什么这里都是window，我记得that应该指向
			var that = this;
			function test(){
				console.log(this,"this");
				console.log(that,"that");
			}
			test();
		}
		foo();
		</script>
	</body>
</html>

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var a = 0;
		function foo () {
			var that = this;
			function test(){
				console.log(this,"this");
				console.log(that,"that");
			}
			test();
		}
		
		var obj = {
			a:1,
			foo:foo
		}
		obj.foo();
		</script>
	</body>
</html>
call方法改变this指向 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var a = 0;
		function foo () {
			var that = this;
			function test(){
				console.log(this,"this");
				console.log(that,"that");
			}
			test.call(this);
		}
		
		var obj = {
			a:1,
			foo:foo
		}
		 obj.foo();
		</script>
	</body>
</html>
箭头函数方法 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var a = 0;
		function foo () {
			var that = this;
            //使用箭头函数来达到目的
			var test = () => {
				console.log(this,"this");
				console.log(that,"that");
			}
			test();
		}
		
		var obj = {
			a:1,
			foo:foo
		}
		 obj.foo();
		</script>
	</body>
</html>

16.11

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var a = 0;
		function foo () {
			var that = this;
			var test = () => {
				console.log(this);
			}
			return test;
		}
		
		var obj = {
			a:1,
			foo:foo
		}
		
		var obj2 = {
			a:2,
			foo:foo
		}
		 obj.foo()();//指向obj
		</script>
	</body>
</html>

 16.12

记牢，call/apply/bind无法改变箭头函数的this指向，总是容易把它们记成改变箭头函数

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var a = 0;
		function foo () {
			var that = this;
			var test = () => {
				console.log(this);
			}
			return test;
		}
		
		var obj = {
			a:1,
			foo:foo
		}
		
		var obj2 = {
			a:2,
			foo:foo
		}
		var bar =foo().call(obj2);
		</script>
	</body>
</html>

16.13箭头函数不能作为构造函数使用 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var foo = () =>{
			console.log(this);
		}
		new foo();
		</script>
	</body>
</html>

 16.14

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var name ="window";
		var obj1 = {
			name:"1",
			fn1:function () {
				console.log(this.name);
			},
			fn2:()=>console.log(this.name),
			fn3:function() {
				return function () {
					console.log(this.name);
				}
			},
			fn4:function() {
				return () => console.log(this.name);
			}
		}
		var obj2 = {
			name:'2',
		}
		obj1.fn1();//1
		obj1.fn1.call(obj2);//2
		
		obj1.fn2();//1---错了，箭头函数的父是window,对象没有作用域
		obj1.fn2.call(obj2);//2---错了，window 箭头函数call这些没用啊啊啊啊啊
		
		obj1.fn3()();//window
		obj1.fn3().call(obj2);//2
		obj1.fn3.call(obj2)();//2--错了,window ,最里面的是自调用
		
		obj1.fn4()();//1---对了，但是为什么这里的父又是obj了，之前有个不是window吗？，这里外面是一个函数，有作用域
		obj1.fn4().call(obj2);//2--错了，1，父对象是obj,箭头函数不生效啊啊，记住好吗
		obj1.fn4.call(obj2)();//2
		</script>
	</body>
</html>

16.15 

不懂

第一个是构造函数上的getName,2

第二个全局上的getName，被覆盖了，所以是4

第三个 return this,独立调用，是全局window,然后前面有个没var的getName，重写了，所有结果为1

第四个全局为1

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		function Foo(){
			getName = function () {
	         console.log(1);
			}
			return this;
			}
			Foo.getName = function () {
				console.log (2);
			};
			
			Foo.prototype.getName = function () {
				console.log (3);
			};
			
			var getName = function () {
				console.log (4);
			};
			
			function getName() {
				console.log (5);
			};
			
			Foo.getName();//2
			getName();//这里几个getName，我怎么知道它说的是哪个
			Foo().getName();
			getName();
			
		</script>
	</body>
</html>

题目17

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script>
		var name='hammer';

		var obj={
		name:"小王",
		  func1:function(){
		      console.log(this.name)
		},
		func2:function(){
		    setTimeout(function(){
		         this.func1()
		    }.apply(obj),100);
		  }
		}

		obj.func2()
		</script>
	</body>
</html>

题目18 

 

 

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<button>按钮</button>
		<script>
		let btns=document.getElementsByTagName('button')
		for(var btn of btns){
		   btn.onclick=function(){
		     console.log(this)
		    }
		}
		</script>
	</body>
</html>

有关于 this 的基础练习题
m0_57448314的博客
09-15 264
this 基础练习题 10 / 100
【Verilog题目练习】HDLBits题目集合
G1309183173的博客
03-27 2741
个人HDLBits练习
图解 | THIS的题目
aningde的博客
06-23 240
找THIS的方法： 1、给元素的某个事件绑定方法，当事件触发执行的时候，方法中的this就是当前操作的元素本身 2、当方法执行时，我们看方法前面是否有【点】：没有【点】,this=>window(严格模式：undefined)；有【点】，this=>点前面是谁 1 / 题目解析 本着以上两条原则来看题目 （1）请问打印几次，.
javascript的一道this综合题目
qiu265843468的专栏
07-30 640
var number = 2; var obj = { number : 4, fn1 : (function(){ this.number *= 2;//这里this为window number=number*2; var number=3; return function(){ this.nu
360一道关于this的题目
qiqi学习园地
01-20 305
原题目是这样子的： window.val = 1； var obj = { val: 2, dbl: function () { this.val *= 2; val *= 2; console.log(val); console.log(this.val); } }; // 说
this的使用—练习题
sunhongfu123的博客
11-09 298
需求：使用java类描述一个学生，学生有 name 、age两个属性， 还具备一个功能就是比较年龄。     要求：      1. 一旦创建了学生对象，学生就有了对应的属性值。 （构造函数、this） //学生类 class Student{ String name; int age; //构造方法 public Student(String name,int age){ ...
java集合习题及答案
03-04
#### 题目三：实现List集合去重 **题目描述：** 编写一个Java程序，实现对一个`List<Integer>`集合进行去重操作。 **代码分析：** ```java import java.util.ArrayList; import java.util.List; public class ...
java 集合练习题
07-26
- **HashMap**：虽然题目没有明确提及HashMap，但在实际场景中，如果需要快速查找学生信息（如按姓名查询），可以使用HashMap。键是学生的姓名，值是学生对象，提供O(1)的时间复杂度查找。 3. **学生类（Student）...
常用集合题目练习
chuan211026的博客
03-22 204
1、定义一个方法 listTest(ArrayList<String> list, String name)，要求返回 name 在 list 里面第一次出现的索引，如果 name 没出现过返回-1。 import java.util.ArrayList; import java.util.Scanner; public class FindFirstName { public static void main(String[] args) { ArrayL
CCS-CSP 2014-12 批次 题目3 集合竞价
JoeTwan 的博客
08-20 307
题目描述 描述 题目 问题描述 某股票交易所请你编写一个程序，根据开盘前客户提交的订单来确定某特定股票的开盘价和开盘成交量。　　该程序的输入由很多行构成，每一行为一条记录，记录可能有以下几种：　　1. buy p s 表示一个购买股票的买单，每手出价为p，购买股数为s。　　2. sell p s 表示一个出售股票的卖单，每手出价为p，出售股数为s。　　3. cancel i表示撤销第i行的记录。　　如果开盘价为p0，则系统可以将所有出价至少为p0的买单和所有出价至多为p0的卖单进行匹配。因此
经典面试题(3)：关于this指向的常见面试题
qq_24520459的博客
02-18 2286
大年初三凌晨1点，继续我们的经典面试题系列，今天我们了解一下关于函数内部this指向的问题，用一个简单的例子来讲解一下：看下面的代码，你觉得输出的结果是什么？var my...
一个关于javascript闭包和this的题目
w13508763507的专栏
10-27 184
##1. var name = "The Window"; var object = { name: "My Object", getNameFunc: function(){ return this.name; } } 问:object.getNameFuc()的返回值是什么? 答:”My Object” ##2. var name = "The Window"...
几道很好的this指向的题目。
weixin_43405946的博客
01-25 841
箭头函数的this指向最近一层的非箭头函数，否则指向全局。
js中this详解
douzixh的博客
10-23 220
学了这么久前端后变成搜集各个大佬的博客 转自https://zhuanlan.zhihu.com/p/82504422 解释下JavaScript中的this是怎么工作的？ 来来来，给你看下面这一段程序，这里的this.bar打印出来是什么值？下面这个this.bar打印出来又是什么值呢？ 在前端的面试当中，this的指向是面试官一定要问的问题。废话少说，这篇文章带你10分钟搞懂this的世界。 本文参考了Kyle Simpson的《高级JavaScript》（Advanced JavaScript）这门课
箭头函数的this指向谁_面试题目（考点：变量，函数提升，this指向，原型，优先级）...
weixin_39637571的博客
12-10 308
面试题目 考点：变量，函数提升，this指向，原型，优先级functionFoo(){getName=function(){console.log(1)}returnthis}Foo.getName=function(){console.log(2)}Foo.prototype.getName=function(...
ES6箭头函数的this以及各类this面试题总结
skyandairchild的博客
05-18 277
https://blog.csdn.net/yangbingbinga/article/details/61424363
JavaScript中this面试题, 四道题彻底清楚this指向问题
m0_71485750的博客
06-08 5617
如果不清楚this绑定规则可以看上一篇有详细说明 打印结果:解释: 打印结果解释:person1.foo1(): 隐式绑定, this指向发起调用的对象person1person1.foo1.call(person2): 显示绑定, this指向person2person1.foo2(): foo2是一个箭头函数, 箭头函数中没有this, 会向上级作用域寻找, 上级作用域this指向windowperson1.foo2.call(person2): foo2是一个箭头函数, 对箭头函数绑定this是不生
箭头函数中的this
qq_27411845的博客
03-30 167
笔试中遇到箭头函数与call的this指向问题 function max(){ return ()=>{ return ()=>{ return ()=>{ console.log(this.name) } } } } var f = max.call({'name':'foo'}) var bar = f.call({'name':'...
this指向详解+笔试题解析
最新发布
垂死病中惊坐起，菜鸟竟是我自己，于是含泪写下博客
10-01 479
秋招笔试期间做了很多关于this指向的笔试题，虽然都知道this指向问题很重要但真的能用大白话讲懂的又比较少。故记录下自己一路以来对this指向问题的理解，几乎包含了可能遇到的所有情况，希望对各位有所帮助
Java面试必备知识点：题目集合
1. **super()与this()的区别**：`super()`用于调用父类的构造器，而`this()`用于在同一个类的不同构造器之间传递参数。 2. **作用域public, protected, private以及默认区别**：public成员对所有类可见，protected...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值