2. 程式人生 > >es6學習筆記-proxy對象

es6學習筆記-proxy對象

阿新 • • 發佈：2019-04-28
res 註意點 revoke href oca 實例對象 上一個 轉化 很多

前提摘要

尤大大的vue3.0即將到來，雖然學不動了，但是還要學的啊，據說vue3.0是基於proxy來進行對值進行攔截並操作，所以es6的proxy也是要學習一下的。

一 什麽是proxy

Proxy 對象用於定義基本操作的自定義行為（如屬性查找，賦值，枚舉，函數調用等） --摘自MDN
Proxy 用於修改某些操作的默認行為，等同於在語言層面做出修改，所以屬於一種“元編程”（meta programming），即對編程語言進行編程。 --摘自阮一峰的ES6入門
Proxy 這個詞的原意是代理，用在這裏表示由它來“代理”某些操作，可以譯為“代理器”。
Proxy 也可以理解成，在目標對象之前架設一層“攔截”，外界對該對象的訪問，都必須先通過這層攔截，因此提供了一種機制，可以對外界的訪問進行過濾和改寫。

總結來說：Proxy對象就是要在目標對象上設置自定義的規則和方法，讓它按照自己定義的規則去實行某些操作。

二 Proxy聲明

ES6 原生提供 Proxy 構造函數，用來生成 Proxy 實例，所以可以按照構造函數創建對象的形式去實例化一個Proxy對象。

var proxy = new Proxy({},{})
console.log(proxy) // Proxy{}

註意點：
1 實例化一個Proxy對象時，必須要傳兩個參數對象,否則會報錯：Uncaught TypeError: Cannot create proxy with a non-object as target or handler,不能創建沒有對象的proxy對象。

2 傳兩個空對象時，默認的是簡單聲明了一個Proxy實例，（好像沒啥卵用……）

參數對象解釋：

  • 第一個參數：target，目標對象，是你要代理的對象.它可以是JavaScript中的任何合法對象.如: (數組, 對象, 函數等等)
    tip:

    var arr = []
var obj = {}
var Person = class{}
var foo = function (){}
console.log(Person instanceof Object) // true
console.log(foo instanceof Object)  // true
console.log(arr instanceof Object)  // true
console.log(obj instanceof Object)  // true

  • 第二個參數：handler，配置對象，用來定制攔截行為，對於每一個被代理的操作，需要提供一個對應的處理函數，該函數將攔截對應的操作。
    Proxy支持的攔截操作，有13種，使用方法可以參考 阮一峰的ES6入門

三 常見情況

3.1 當目標對象為空時

var proxy = new Proxy({},handler)
這樣直接代表著，攔截的對象是空的，所以直接對proxy對象進行操控。

var target = {};
var handler = {
  get(target,propKey,receiver){
    return 'peter'
  }
};
var proxy = new Proxy(target, handler);
proxy.name = 'tom';
console.log(proxy.name) // tom
console.log(target.name) // undefined

上面的代碼說明了：target是個空對象，但是操作了proxy，也影響不了target
ps：要使得Proxy起作用，必須針對Proxy實例進行操作，而不是針對目標對象進行操作

3.2 當攔截對象為空時

var proxy = new Proxy(target,{})
handler沒有設置任何攔截，那就等同於直接通向原對象。

var target = {};
var handler = {};
var proxy = new Proxy(target, handler);
proxy.name = 'peter';
console.log(proxy.name) // peter
console.log(target.name) // peter

上面的代碼說明了：handler是一個空對象，沒有任何攔截效果，訪問proxy就等同於訪問target

四 方法解析

Proxy實例化的對象默認帶有get和set方法。也可以在這些基礎上進行攔截操作，其他的13種方法也是如此。

  1. get() 用於攔截某個屬性的讀取（read）操作，換句話講，就是在讀取目標對象的屬性之前，操作該屬性。
    參數解釋：
    • target：目標對象
    • property：屬性名

    • receiver：proxy實例
      例子：

      var person = {
  name: "張三"
};

var proxy = new Proxy(person, {
  get: function(target, property) {
    if (property in target) {
      return target[property];
    } else {
      throw new ReferenceError("Property \"" + property + "\" does not exist.");
    }
  }
});

proxy.name // "張三"
proxy.age // Property "age" does not exist.

      參考阮一峰的例子，上述說明了，如果輸入目標函數不存在的屬性，就直接報錯。

  2. set() 用來攔截目標對象的賦值（write）操作
    參數解釋：
    • target：目標對象
    • propertyName：屬性名
    • propertyValue：屬性值

    • receiver：Proxy實例本身
      例子：

      var target = {}
var handler = {
  set(target, propKey, value, receiver) {
    if (typeof value !== 'string') {
      target[propKey] = String(value);
    }else{
      target[propKey] = value;
    }
  }
}
var proxy = new Proxy(target, handler)
proxy.name = 'peter'
proxy.age = 25
console.log(typeof proxy.name) // string
console.log(typeof proxy.age) // string

      上面例子就是攔截對象是不是字符串，不是字符串的話會強制轉化為字符串。

  3. apply() 用來攔截函數的調用、call和apply操作
    參數解釋：
    • target：目標對象
    • context：目標對象的上下文對象(this）

    • arguments：目標對象的參數數組
      例子：

      var target = function(a,b){
  return 10 + a + b
}
var handler = {
  apply(target,context,arguments){
    arguments[0] = 10
    arguments[1] = 20
    return arguments.reduce(function(prev, curr, idx, arr){
        return prev + curr;
    });
  }
}
var proxy = new Proxy(target,handler)
console.log(proxy(1,2)) // 30

      上面的例子，就是目標函數是要傳兩個參數，並且返回之和，攔截目標做的就是改變目標對象的參數，並且求和，所以這樣寫觸發了apply方法，返回30，而不是13

  4. has() 用來攔截hasProperty操作，即判斷對象是否具有某個屬性時，這個方法會生效。典型的操作就是in運算符。
    參數解釋：
    • target：目標對象

    • key： 需查詢的屬性名,是一個字符串！！！！！
      例子：

      var target = {
  name: 'peter',
  age:25
}
var handler = {
  has(target,key){
    return key in target;
  }

}
var proxy = new Proxy(target,handler)
console.log('age' in proxy) // true
console.log('colors' in proxy) // false

      上面的例子是典型的has的方法，判斷所要查詢的屬性名是不是在目標對象上的屬性名，返回布爾值。
      ps：has攔截對for...in循環不生效。

  5. construct() 用於攔截new命令，要返回是一個對象，否則會報錯
    參數解釋：
    • target：目標對象
    • args：構造函數的參數對象

    • newTarget：創造實例對象時，new命令作用的構造函數
      例子：

      var p = new Proxy(function () {}, {
  construct: function(target, args) {
    console.log('called: ' + args.join(', '));
    return { value: args[0] * 10 };
  }
});

(new p(1)).value
// "called: 1"
// 10

      由此可見，是針對構造函數而言的，對目標對象的構造函數進行攔截。

  6. defineProperty() 攔截了Object.defineProperty操作，在聲明時進行攔截，設置的是一個布爾值
    • 參數解釋：
      • target：目標對象
      • key：要定義或修改的屬性的名稱
      • descriptor： 將被定義或修改的屬性描述符,是一個對象

    • 拓展：
      Object.defineProperty(),聲明對象的屬性，參數說明和上述一樣
      例子：

      var obj = {}
Object.defineProperty(obj, "key", {
  enumerable: false,
  configurable: false,
  writable: false,
  value: "static"
});

    • 例子：

      var target = {
  name: 'peter',
  age:25
}
var handler = {
  defineProperty(target,key,descriptor){
    if(key === 'color'){
      throw new Error('不能定義顏色')
    }
    Object.defineProperty(target, key, descriptor)
    // return true
  }
}
var proxy = new Proxy(target,handler)
var descriptor = {
  writable : true,
  enumerable : true,
  configurable : true
}
descriptor.value = 'sport'
Object.defineProperty(proxy, 'favor', descriptor)
console.log(proxy.favor) // sport
descriptor.value = 'red'
Object.defineProperty(proxy, 'color', descriptor)  // 不能定義顏色
console.log(proxy.color)

      如果目標對象不可擴展（non-extensible），則defineProperty不能增加目標對象上不存在的屬性，否則會報錯。另外，如果目標對象的某個屬性不可寫（writable）或不可配置（configurable），則defineProperty方法不得改變這兩個設置。

  7. deleteProperty() 用於攔截delete操作，如果這個方法拋出錯誤或者返回false，當前屬性就無法被delete命令刪除。
    • 參數解釋：
      • target：目標對象
      • key：要刪除的屬性名
        (delete是關鍵字，目前用到的就是刪除對象的某個屬性)

    • 例子：

      var target = { _prop: 'foo' };
var handler = {
  deleteProperty (target, key) {
    if (key[0] === '_') {
      throw new Error(`Invalid attempt to ${target} private "${key}" property`);
    }
    delete target[key];
    return true;
  }
};
var proxy = new Proxy(target, handler);
delete proxy._prop // Error: Invalid attempt to delete private "_prop" property

      上面代碼中，deleteProperty方法攔截了delete操作符，刪除第一個字符為下劃線的屬性會報錯。
      註意，目標對象自身的不可配置（configurable）的屬性，不能被deleteProperty方法刪除，否則報錯。

  8. getOwnPropertyDescriptor() 攔截Object.getOwnPropertyDescriptor()，返回一個屬性描述對象或者undefined。
    • 參數解釋：
      • target：目標對象
      • key： 屬性名
    • 拓展：
      Object.getOwnPropertyDescriptor(obj,prop) 返回指定對象上一個自有屬性對應的屬性描述符
      • 參數解釋：
        • obj：需要查找的目標對象
        • prop: 目標對象內屬性名稱
      • 返回值：
        如果指定的屬性存在於對象上，則返回其屬性描述符對象（property descriptor），否則返回 undefined。

      • 例子：

        o = { bar: 42 };
d = Object.getOwnPropertyDescriptor(o, "bar");
console.log(d)
// d {
//   configurable: true,
//   enumerable: true,
//   value: 42,
//   writable: true
// }

    • 例子：

      var target = { _foo: 'bar', baz: 'tar' };
var handler = {
  getOwnPropertyDescriptor (target, key) {
    if (key[0] === '_') {
      return;
    }
    return Object.getOwnPropertyDescriptor(target, key);
  }
};
var proxy = new Proxy(target, handler);
Object.getOwnPropertyDescriptor(proxy, 'wat')
// undefined
Object.getOwnPropertyDescriptor(proxy, '_foo')
// undefined
Object.getOwnPropertyDescriptor(proxy, 'baz')
// { value: 'tar', writable: true, enumerable: true, configurable: true }

      上述說明：對於第一個字符為下劃線的屬性名會返回undefined。

  9. getPrototypeOf() 用來攔截獲取對象原型,主要攔截以下操作：
    • 如下：
      • Object.prototype.__proto__
        -- 該特性已經從 Web 標準中刪除
      • Object.prototype.isPrototypeOf()
        用於測試一個對象是否存在於另一個對象的原型鏈上。
        • 參數：
          • object 在該對象的原型鏈上搜尋
        • 返回值：
          • 返回值 表示調用對象是否在另一個對象的原型鏈上。布爾值

        • 例子：

          function Baz() {}
var baz = new Baz();
console.log(Baz.prototype.isPrototypeOf(baz)); // true
      • Object.getPrototypeOf(obj) 返回指定對象的原型（內部[[Prototype]]屬性的值）
        • 參數：
          • obj 返回其原型的對象
        • 返回值：
          給定對象的原型。如果沒有繼承屬性，則返回 null 。

        • 例子：

          var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
      • Reflect.getPrototypeOf()
      • instanceof

    • 例子：

      var proto = {};
var p = new Proxy({}, {
  getPrototypeOf(target) {
    return proto;
  }
});
Object.getPrototypeOf(p) === proto // true
      上面代碼中，getPrototypeOf方法攔截Object.getPrototypeOf()，返回proto對象。
      ps:
      1. getPrototypeOf方法的返回值必須是對象或者null，否則報錯
      2. 如果目標對象不可擴展（non-extensible）， getPrototypeOf方法必須返回目標對象的原型對象。
  10. isExtensible() 攔截Object.isExtensible()操作
    • Object.isExtensible() 判斷是否可以為對象添加新的屬性
      參數：
      • object 要進行判斷的對象
        返回值：

      • 是個布爾值，true是可以添加，false不可以添加
        例子：

        let obj = { 
  name: 'peter',
  age:25
}
console.log(Object.isExtensible(obj)) // true
      對象默認情況下是可以添加新的屬性的。

    • 例子：

      var p = new Proxy({}, {
  isExtensible: function(target) {
    console.log("called");
    return true;
  }
});
Object.isExtensible(p) // called

      這個方法有一個強限制，它的返回值必須與目標對象的isExtensible屬性保持一致，否則就會拋出錯誤。
      即：Object.isExtensible(proxy) === Object.isExtensible(target)

  11. preventExtensions() 攔截Object.preventExtensions()操作
    • Object.preventExtensions(object) 不能再為此對象添加新的屬性或者方法
      • 參數：object，要成為不可擴展的對象的對象
      • 無返回值

      • 例子

        let obj = { 
  name: 'peter',
  age:25
} 
Object.preventExtensions(obj)
obj.color = 'red' // object is not extensible
    • 例子
      ————————————
  12. setPrototypeOf() 攔截Object.setPrototypeOf方法
    • Object.setPrototypeOf(obj,proto) 設置對象的原型
      此方法修改的是對象實例的內部屬性[[Prototype]]，也就是__proto__屬性所指向的對象，它只是修改了特定對象上的原型對象，對於構造函數的prototype指向的原型對象沒有影響
      • 參數：
        • obj 對其設置原型的對象
        • proto 新的原型對象

      • 例子：

        let proto = {
        color: red
        };
        let obj = {
        name: ‘peter‘
        age: 26
        };
        Object.setPrototypeOf(obj, proto);
        console.log(obj.color); // red

    • 例子

      var handler = {
  setPrototypeOf (target, proto) {
    throw new Error('Changing the prototype is forbidden');
  }
};
var proto = {};
var target = function () {};
var proxy = new Proxy(target, handler);
Object.setPrototypeOf(proxy, proto);
// Error: Changing the prototype is forbidden
      上面代碼中，只要修改target的原型對象，就會報錯。
    • ps
      1. 該方法只能返回布爾值，否則會被自動轉為布爾值
      2. 如果目標對象不可擴展（non-extensible），setPrototypeOf方法不得改變目標對象的原型
  13. ownKeys() 用來攔截對象自身屬性的讀取操作
    • 如下：
      • Object.getOwnPropertyNames(obj) 獲取對象的屬性名稱，並存儲在數組中。
        • 參數解釋： obj 要獲取屬性名稱的對象
        • 返回值：存放屬性名稱的數組
        • 只能拿到對象的自有屬性，拿不到原型上的屬性，另外，defineProperty的值也可以拿到

        • 例子：

          function Person(){
  this.name = 'peter'
  this.age = 26
}
Person.prototype={
  address:"北京"
}
let peter=new Person();
console.log(Object.getOwnPropertyNames(peter)); // ['name','age']
      • Object.getOwnPropertySymbols(obj) 返回一個給定對象自身的所有 Symbol 屬性的數組
        • 參數解釋： obj 要返回 Symbol 屬性的對象
        • 返回值： 在給定對象自身上找到的所有 Symbol 屬性的數組。

        • 例子：

          var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0])      // Symbol(a)
      • Object.keys() 返回一個由一個給定對象的自身可枚舉屬性組成的數組，數組中屬性名的排列順序和使用 for...in 循環遍歷該對象時返回的順序一致
        • 參數：obj 要返回其枚舉自身屬性的對象
        • 返回值： 一個表示給定對象的所有可枚舉屬性的字符串數組

        • 例子：

          var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.keys(obj)); // ['0', '1', '2']
      • for...in循環
        ————————————

    • 例子之一：

      var p = new Proxy({}, {
  ownKeys: function(target) {
    return ['a', 'b', 'c'];
  }
});

Object.getOwnPropertyNames(p)
// [ 'a', 'b', 'c' ]

五 Proxy.revocable(target, handler)

返回一個可取消的 Proxy 實例

  • 參數解釋：
    • target 用Proxy包裝的目標對象（可以是任何類型的對象，包括原生數組，函數，甚至另一個代理）。
    • handler 攔截對象，其屬性是當執行一個操作時定義代理的行為的函數。
  • 返回值
    返回一個包含了所生成的代理對象本身以及該代理對象的撤銷方法的對象
    其結構為： {"proxy": proxy, "revoke": revoke}，其中：
    • proxy
      表示新生成的代理對象本身，和用一般方式 new Proxy(target, handler) 創建的代理對象沒什麽不同，只是它可以被撤銷掉
    • revoke
      撤銷方法，調用的時候不需要加任何參數，就可以撤銷掉和它一起生成的那個代理對象

  • 例子：

    var revocable = Proxy.revocable({}, {
  get(target, propKey) {
    return propKey + '啦啦啦';
  }
});
var proxy = revocable.proxy;
console.log(proxy.foo) // foo啦啦啦
revocable.revoke(); // 執行撤銷方法
console.log(proxy.foo); // Uncaught TypeError: Cannot perform 'get' on a proxy that has been revoked

總結

剛開始學proxy時，都是懵逼的狀態，阮一峰ES6入門一開始看代碼有點難度，所以我一邊看一邊查資料，裏面關於Object對象的方法居多，也順便學習了一下，知識很多，需要日常回顧加深理解，經過查閱，對於代理模式 Proxy 的作用主要體現在三個方面:1攔截和監視外部對對象的訪問，2降低函數或類的復雜度，3在復雜操作前對操作進行校驗或對所需資源進行管理，目前還沒有大量運用，最常見的應該是攔截和監聽對象的變化吧。
我把筆記放到GitHub裏了，如需要可以去看看，有什麽不對的地方，歡迎指正，大家一起進步加油。

參考文獻

阮一峰ES6入門
詳解ES6中的代理模式——Proxy
MDN
[譯] 實例解析 ES6 Proxy 使用場景

es6學習筆記-proxy對象

相關推薦

es6學習筆記-proxy對象

res 註意點 revoke href oca 實例對象 上一個 轉化 很多 前提摘要 尤大大的vue3.0即將到來，雖然學不動了，但是還要學的啊，據說vue3.0是基於proxy來進行對值進行攔截並操作，所以es6的proxy也是要學習一下的。 一 什麽是proxy Pr

es6學習筆記--promise對象

遍歷 請求超時 settime start 兩個 param 接受 鏈式 handler Promise對象是為了簡化異步編程。解決回調地獄情況 Promise，簡單說就是一個容器，裏面保存著某個未來才會結束的事件（通常是一個異步操作）的結果。從語法上說，Promise

jvm學習筆記之對象詳解

時間 分代 創建 com 詳解 要求 技術 wid src 一、對象的組成 　　　　　　 　　　　對象頭（Header）： 　　　　　　　　　　運行時數據：存儲對象運行時的數據，如哈希碼、GC分代年齡、鎖狀態標誌、線程持有的鎖、偏向線程ID、偏向時間戳等，這部分數據官方成為

Kotlin學習筆記-----面向對象

pre style 初始 line var lin position this otto 構造方法 kotlin中, 一個類的構造方法有好幾種形式 constructor關鍵字 ?class User { private var username:String

python3學習筆記面向對象；過程；類

程序開發 結構 行為 問題 to do 解決問題 特定 oop 原因 編程範式 編程是 程序 員 用特定的語法+數據結構+算法組成的代碼來告訴計算機如何執行任務的過程 ， 一個程序是程序員為了得到一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，實現一個任務的方式有

PHP學習筆記--面向對象的構造方法和析構方法

對象 iss 學習筆記 名稱 構造 功能 call() 方法名 面向對象 1. 對象中成員的訪問（就是在一個對象的內部方法中，去訪問本對象中的其它方法和成員屬性） * 2. 在對象中的方法中都默認有一個$this關鍵字， 這個關鍵字代表調用這個方法的對象 * * 3

PHP學習筆記--面向對象的三大特性之封裝性

查看 php學習 HP 是否 方法 成員 學習筆記 設置 獲取 封裝性： 面向對象的三大特性之一 * * 1. 就是把對象的成員（屬性，方法）結合成一個獨立的相同單位，並盡可能隱藏對象的內部細節 * * public protected * *

python學習筆記-面向對象

exceptio 次循環 打開文件 錯誤類型 student str turn 一行代碼 rip Ctrl+/ 給選中的內容添加註釋False和True首字母需要大寫break 終止循環continue 跳出當前循環pass 忽略當前，執行下一行代碼boo

JavaScript學習筆記之對象

列表 strong result charat() 移動 mouseup getc 刪除 chan 目錄 1、自定義對象 2、Array 3、Boolean 4、Date

ES6學習筆記之map、set與數組、對象的對比

fin 唯一性 ron foreach -o pty pan es6 odi ES6 ES5中的數據結構，主要是用Array和Object。在ES6中主要新增了Set和Map數據結構。到目前為止，常用的數據結構有四種Array、Object、Set、Map。下面話不多說了

ES6學習筆記10 Proxy

Proxy簡介 Proxy用於修改某些操作的預設行為，等同於在語言層面做出修改，所以屬於一種“超程式設計”（meta programming），即對程式語言進行程式設計。 Proxy 可以理解成，在目標物件之前架設一層“攔截”，外界對該物件的訪問，都必須先通

Es6學習筆記

js es6 1、關於let-- let變量必須先聲明，後使用-- 在同一作用域，let不能重復聲明-- let增加了塊級作用域，從而從某種意義上取消了自我執行函數2、關於const-- const只聲明一個常量，一旦聲明，就不能改變(本質是引用地址不能改變)-- const變量必須先聲明，後使用3、

js-ES6學習筆記-Set結構和Map結構

基本類 實例 記錄 lba post 而且 同名 方法 zha http://www.cnblogs.com/lonhon/ 1、ES6 提供了新的數據結構 Set。它類似於數組，但是成員的值都是唯一的，沒有重復的值。 Set 本身是一個構造函數，用來生成 Set 數

Python學習：面向對象(OOP)

python類和實例1、類(class)：有屬性有方法就是類。下面是Student類：class Student(object): def __init__(self, name, score): self.name = name self.score = score

python筆記--面向對象

python、面向對象、類面向對象編程面向對象編程是一種編程方式，需要使用 “類” 和 “對象” 來實現：類就是一個模板，模板裏可以包含多個函數，函數裏實現一些功能，實現對具有共同特征的事物的描述；對象是類的實體，是一種數據類型。它不存在內存中，不能被直接操作，只有被實例化對象時，才會變的可操作。舉例說明：#

zmq筆記一: 對象關系

strong rep 其中 base tex 結束 基本 發送消息 ray int major, minor, patch;zmq_version(&major, &minor, &patch); //4.2.0 本文主要是分析代碼,方便自己日後查閱

ES6學習筆記(一)

message 提升 java syn log mes scrip 默認值 script 1.ES6學習之let、const (1).var、let、const 變（常）量聲明 ES5 只有全局作用域和函數作用域，沒有塊級作用域，這帶來很多不合理的場景。 在ES6中l

ES6學習筆記(二)——字符串擴展

兩個 -m 開始 部分 學習筆記 erro xxx ocs 個數 相信很多人也和我一樣，不喜歡這樣循規蹈矩的逐條去學習語法，很枯燥乏味。主要是這樣學完一遍之後，沒過一段時間就忘到九霄雲外了。不如實際用到的時候研究它記得牢靠，所以我就整理成筆記，加深記憶的同時便於復習查看。

4.3-全棧Java筆記:面向對象的內存分析

java面向對象的內存分析為了讓大家對於面向對象編程有更深入的了解，我們要對程序的執行過程中，內存到底發生了什麽變化，進行剖析，讓大家做到“心中有數”，通過更加形象的方式理解程序的執行方式。老鳥建議： 本節是為了讓初學者更深入了解程序底層執行情況，為了完整的體現內存分析流程，會有些新的名詞，比如

5.4-全棧Java筆記:面向對象進階之對象的轉型 | FINAL關鍵字 |抽象方法和抽象類

java對象的轉型(casting)引用變量只能調用它編譯類型的方法，不能調用它運行類型的方法。這時，我們就需要進行類型的強制轉換！【示例1】對象的轉型public class TestCasting { public static void main(String[] args) {