animal

解构赋值 数组解构 let input = [1, 2]; let [first, second] = input; console.log(first); // outputs 1 console.log(second); // outputs 2 上面的写法等价于： first = input[0]; second = input[1]; 利用解构赋值交换变量： [first, second] = [second, first]; 函数参数解构： function f ([first, second]: [number, number]) [ console.log(first) console.log(second) ] f(1, 2) 解构剩余参数： let [first, ...rest] = [1, 2, 3, 4] console.log(first) // 1 console.log(rest) // [2, 3, 4] 也可以忽略其它参数： let [first] = [1, 2, 3, 4]; console.log(first); // outputs 1 或者跳过解构： let [, second, , fourth] = [1, 2, 3, 4] 对象解构 示例一： let o = { a: "foo", b: 12, c: "bar" }; let {

多态从字面上讲很简单, 就是一个对象, 多种形态. 这个东西有什么用, 我们来看一段代码. package com.xyq.bao; public class Dog{ public void eat(){ System.out.println("狗吃骨头"); } } package com.xyq.bao; public class Cat{ public void eat(){ System.out.println("猫吃鱼"); } } package com.xyq.bao; public class Person{ public void feedCat(Cat c){ c.eat();// 让猫吃 } public void feedDog(Dog d){ d.eat();// 让狗吃 } } package com.xyq.bao; public class Test { public static void main(String[] args) { Person p = new Person(); Cat c = new Cat(); Dog d = new Dog(); p.feedCat(c); f.feedDog(d); } } 大家发现没有. 这个人啊. 好累哦. 喂猫, 喂狗的. 是吧, 但是如果再来一种动物怎么办? 比如养了一只鹦鹉. package

多态 1. 什么是多态 多态是继封装、继承之后，面向对象的第三大特性。 生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。 多态 ： 是指同一行为，具有多个不同表现形式 【前提】 1 . 继承或者实现【二选一】：实现可以理解为抽象方法 2. 方法的重写【意义体现：不重写，无意义】 3. 父类引用指向子类对象【格式体现】 public abstract class Animal { public abstract void eat ( ) ; } class Cat extends Animal { public void eat ( ) { System . out . println ( "吃鱼" ) ; } } class Dog extends Animal { public void eat ( ) { System . out . println ( "吃骨头" ) ; } } public class Test { public static void main ( String [ ] args ) { // 多态形式，创建对象 Animal a1 = new Cat ( ) ; // 调用的是 Cat 的 eat a1

一 、 原型链继承 父类型实例赋值给子类型原型 function Animal ( ) { this . value = 'animal' ; } //父类型的方法 Animal . prototype . run = function ( ) { return this . value + '' + 'is runing' ; } function Cat ( ) { } //继承,用构造函数创建对象 //通过new 将构造函数的作用域赋给新对象，链接到原型 //绑定this，执行代码，添加属性，返回新对象 //Cat.prototype.__proto__=Animal.prototype Cat . prototype = new Animal ( ) ; //Cat.prototype 变成了 Animal 的一个实例，所以 Animal 的实例属性 names 就变成了 Cat.prototype 的属性。 var instance = new Cat ( ) ; instance . value = 'hellokitty' ; console . log ( instance . run ( ) ) ; //hellokitty is run 原型链如图 此方法有以下缺点： 当原型链中包含引用类型值的原型时,该引用类型值会被所有实例共享 function Animal

ES5中的类 es5中的类 function Person ( ) { this . name = '张三' ; this . age = 12 ; } var p = new Person ( ) ; console . log ( p . name ) 构造函数和原型链里面增加方法 function Person ( ) { this . name = '李四' ; this . age = 23 ; this . run = function ( ) { console . log ( ` ${ this . name } 运动了~` ) // console.log(this) } } // 在原型链上扩展属性和方法（原型链上的属性会被多个实例共享，构造函数不会） Person . prototype . sex = '男' ; Person . prototype . work = function ( ) { console . log ( `性别： ${ this . sex } ` ) } var p = new Person ( ) ; p . run ( ) ; p . work ( ) 类的静态方法 function Person ( ) { } Person . love = function ( ) { console . log ( '我是类的静态方法

一、原型链继承 1.1 实现 基本思想： 重写子类的原型对象，让原型对象等于父类的实例 function Animal(color) { this.kind = ['cat', 'dog']; this.color = color; } Animal.prototype.getKind = function () { return this.kind; } function Cat(name) { this.name = name; } // 让Cat.prototype等于Animal的实例 // 传入超类Animal的构造函数中的参数，被Cat的所有实例共享 Cat.prototype = new Animal('black'); Cat.prototype.getColor = function () { return this.color; } const cat1 = new Cat('wangcai'); let kind1 = cat1.getKind(); console.log(kind1); // [ 'cat', 'dog' ] console.log(cat1.getColor()); // black const cat2 = new Cat('xiaohei'); let kind2 = cat2.getKind(); console.log(kind2

多态 多态是继封装、继承之后，面向对象的第三大特性。 生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。 定义 多态 ： 是指同一行为，对于不同的对象具有多个不同表现形式。 程序中多态: 是指同一方法,对于不同的对象具有不同的实现. 前提【重点】 继承或者实现【二选一】 父类引用指向子类对象【格式体现】 方法的重写【意义体现：不重写，无意义】 知识点-- 实现多态 讲解: 多态体现的格式： 父类类型 变量名 = new 子类对象； 变量名 . 方法名 ( ) ; 父类类型：指子类对象继承的父类类型，或者实现的父接口类型。 代码如下： Fu f = new Zi ( ) ; f . method ( ) ; 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。 代码如下： 定义父类： public abstract class Animal { public abstract void eat ( ) ; } 定义子类： class Cat extends Animal { public void eat ( ) { System . out . println ( "吃鱼" ) ;

1.普通枚举 public class EnumTest01 { /** *普通枚举 */ public enum Fruit { APPLE, BANANA, PEAR, CHERRY; } public static void main(String[] args) { //遍历 for (Fruit f : Fruit.values()) { System.out.println(f); } Fruit f = Fruit.APPLE; //结合switch switch (f) { case APPLE: System.out.println("APPLE"); break; case BANANA: System.out.println("BANANA"); break; case PEAR: System.out.println("PEAR"); break; case CHERRY: System.out.println("CHERRY"); break; default: System.out.println("UNKNOW FRUIT"); break; } } } View Code 2.带构造方法，普通方法，静态方法，成员变量，重写toString()方法 package com.jte.enum1; public class EnumTest01 { /**

Java异常中我们常见的异常主要是检查异常，其中检查异常zhuy主要有如下四种： 1、空指针异常，具体代码体现如下 String str = null; try { System.out.println(str.length()); }catch(Exception e){ System.out.println("空指针异常了"); } 2、数组下标越界异常 int []a = {1,2,3}; try { for(int i = 0;i<=3;i++) { System.out.println(a[i]); } }catch(Exception e) { System.out.println("数组下标越界了！！！"); } 3、数据类型转换异常 class Animal(){ } class Dog extends Animal(){ } calss Cat extends Animal(){ } Animal a1 = new Dog(); Animal a2 = new Cat(); Dog d1 = (Dog) a1; Dog d2 = (Dog) a2; 3、算术异常，只要是分母为0的情况 int a= 12; int b= 0; try { System.out.println(a/b); }catch(Exception e) { System.out

之前在Emit的学习过程中，多次碰到了方法的调用，发现有时候是使用Call而有时候是使用Callvirt，一直对这两者的区别不甚了解。然后就查阅了MSDN，MSDN中对这两者的解释为： 　　l　 Call：调用由传递的方法说明符指示的方法； 　　l　 Callvirt：对对象调用后期绑定方法，并且将返回值推送到计算堆栈上。 　　但是看了之后还是很不明白，我想可能是因为中文版的缘故吧。今天下午再次看到了对Callvirt指令的解释，“对对象调用后期绑定方法”，突然想到，这个好像是指多态的意思吧？在一看virt，应该就是virtual的缩写，于是就更加肯定了自己的想法（外派在农行，不能上网，不然在园子随便一找就有结果了，伤心啊！），立马动手开始实践。 　　我们用最经典的Animal的例子来验证这个想法，首先定义相关的类型，如下： class Animal { public virtual void Speak() { Console.WriteLine("Animal.Speak"); } } class Cat : Animal { public override void Speak() { Console.WriteLine("Cat.Speak"); } } class Dog : Animal { public override void Speak() { Console