精华内容
下载资源
问答
  • 1.下面关于类概念描述中,__ _是错误的。A.类是抽象数据类型的实现B.类是具有共同行为的若干对象的统一描述体C.类是创建对象的样板D.类是C语言中的结构体类型2.下列说法中正确的是___ _。A.类定义中只能说明...

    1.下面关于类概念的描述中,__ _是错误的。

    A.类是抽象数据类型的实现

    B.类是具有共同行为的若干对象的统一描述体

    C.类是创建对象的样板

    D.类是C语言中的结构体类型

    2.下列说法中正确的是___ _。

    A.类定义中只能说明函数成员的函数头,不能定义函数体

    B.类中的函数成员可以在类体中定义,也可以在类体之外定义

    C.类中的函数成员在类体之外定义时必须要与类声明在同一文件中

    D.在类体之外定义的函数成员不能操作该类的私有数据成员

    3.下列关于class 与struct差别说法中,正确的是 。

    A.class 成员缺省为私有的,而struct成员缺省为公有的;

    B.class 成员缺省为公有的,而struct成员缺省为私有的;

    C.class不能在内部定义函数,而struct可以在内部定义函数;

    D.class 可以在内部定义函数,而struct不能在内部定义函数;

    4. 对于类中定义的成员,其隐含访问权限为

    A. protected B. private C. public D. static

    5.在下列关键字中,用于说明类中公有成员的是 。

    A.public B.private C.protected D.friend

    6.在下列关键字中,用于说明类中私有成员的是 。

    A.private B.public C.protected D.friend

    7.作用域运算符的功能是 。

    A.标识作用域的级别的 B.指出作用域的范围的

    C.标识某个成员是属于哪个类的 D.给定作用域的大小的

    8. 在类的定义体外定义成员函数时,需要在函数名前加上 。

    A.类标记      B.类对象  C.类作用域标记   D.不用加标记

    更多相关问题

    [单选] 变容二极管电容增加是由于()引起的.

    [单选] ()二极管工作在正向偏置状态。

    [单选] 同步控制变压器的定子和转子绕组得相数分别为().

    [单选] ()整流电路要用四个二极管.

    [单选] 利用()二极管可以把光信号变为电信号.

    [单选] 当()后,就形成了PN结.

    [单选] 闭环控制中,输出量和输入量之间的关系是().

    [单选] 机载无线电接收机的主要性能指标是().

    [单选] 共射极放大器的输入极是().

    [单选] 金属大功率三极管的外壳是().

    [单选] N型半导体是指()的半导体.

    [单选] 变容二极管电容增加是由于()引起的.

    [单选] 在输出特性曲线上,满足IC=HFEIB关系的区域是:().

    [单选] 三极管符号中,带箭头的电极是().

    [单选] 机载无线电接收机的主要性能指标是().

    [单选] 所谓放大器工作在闭环状态,指的是().

    [单选] 共射极放大器的输入极是().

    [单选] 机载无线电接收机的主要性能指标是().

    [单选] 调频波中的被调制信号的哪一个参数不变().

    [单选] 发光二极管的亮度与()密切相关.

    [单选] 利用()二极管可以把光信号变为电信号.

    [单选] PIN二极管高频时的工作特性近似于一个().

    [单选] 共射极放大电路中,输出信号加在()和地之间.

    [单选] 光敏二极管的工作电流与()成正比.

    [单选] 所谓放大器工作在闭环状态,指的是().

    [单选] PIN二极管高频时的工作特性近似于一个().

    [单选] ()二极管工作在正向偏置状态。

    [单选] 从二极管伏安特性看,当()时,二极管的导通电阻小.

    [单选] 闭环控制中,输出量和输入量之间的关系是().

    [单选] 力矩式同步器得定子绕组是().

    [单选] 变容二极管电容增加是由于()引起的.

    [单选] ()二极管工作在正向偏置状态。

    [单选] 金属大功率三极管的外壳是().

    [单选] 金属大功率三极管的外壳是().

    [单选] 应用调频波的特点是().

    展开全文
  • [多选] CDMA2000-1X系统由哪四部分组成?()[多选] 基金代理销售网点在...[单选] 储蓄国债服务对象为()。[单选] UMTS系统中,差错检验,重传机制在()层实现[单选] 在蜂窝移动网络中,蜂窝是一种什么概念?()[多选]...

    [多选] CDMA2000-1X系统由哪四部分组成?()

    [多选] 基金代理销售网点在基金开放日可以受理的交易申请有()。

    [单选] 在3G蜂窝移动网络中常提到IMT,哪个组织提出的IMT的概念?()

    [单选] 基金账户资料类的会计档案保管年限是()年。

    [单选] 储蓄国债的服务对象为()。

    [单选] UMTS系统中,差错检验,重传机制在()层实现

    [单选] 在蜂窝移动网络中,蜂窝是一种什么概念?()

    [多选] TD室内覆盖主要以公共控制信道PCCPCH的RSCP和C/I为设计准则,其原因是:()

    [单选] “汇利丰”理财产品在扣划前的冻结期间,按()计付利息。

    [单选] “本利丰”人民币理财产品收益由()根据市场运作统一定价。

    [多选] 下列那种路由算法不适合大中型网络:()

    [单选] 客户办理网上记账式国债交易业务须事先开立()。

    [单选] 闭环功率控制的内环功控由()控制

    [单选] 以下ATM哪句话正确?()

    [填空题] 在TD-SCDMA优化中通常针对覆盖情况进行考核的KPI指标有两点,分别是(),()。

    [单选] 扩展频谱系统,其传输带宽()被传送的原始信息的带宽

    [单选] 储蓄国债以()元为发行单位。

    [单选] “本利丰”由()根据当期市场条件评估确定发售总规模;并根据发售总规模确定每期发售计划,制定方案并发布。

    [单选] 连续()年余额为零的储蓄国债账户将自行注销。

    [单选] 书发售凭证式国债,交易成功,打印()。

    [单选] 申购汇利丰理财产品之前,客户应在我行开立有相应币种的现汇或现钞()账户,余额不低于申购金额。

    [单选] 记账式国债转托管是指对债券()进行转移。

    [单选] UMTS系统中,差错检验,重传机制在()层实现

    [单选] UMTS系统中,差错检验,重传机制在()层实现

    [单选] 在CDMA2000-1X系统中,引入R-PICH的概念,R-PICH的功能是什么?()

    [单选] CDMA2000-1X系统的反向信道使用了哪种调制方式?()

    [单选] 连续()年余额为零的储蓄国债账户将自行注销。

    [单选] 凭证式国债提前兑付时,必须()兑付。

    [单选] 当使用QPSK编码时,一个码元能承载几个比特的信息?()

    [单选] 储蓄国债为()债券。

    [单选] 投资人办理开放式基金业务,必须开立()资金账户,并通过我行在注册登记中心开立基金账户,资金账户与基金账户为一一对应。

    [单选] 申购汇利丰理财产品之前,客户应在我行开立有相应币种的现汇或现钞()账户,余额不低于申购金额。

    [多选] TD室内覆盖主要以公共控制信道PCCPCH的RSCP和C/I为设计准则,其原因是:()

    [多选] 下列那种路由算法不适合大中型网络:()

    [单选] 个人投资者办理第三方存管业务须提供()、有效证件等资料。

    展开全文
  • 编写思路: 1.  问题: 2.  ...对前面复习 ...面向对象 ...语言。那什么是面向对象呢 ...之前我们已经谈到了面向对象中两个最基本也是最重要的概念:类 , 对象。 我们之前谈到:...

     

    编写思路:

    1.  问题:

    2.  解决办法:

    3.  总结:

    对前面的复习

    一说到 Java 就不能不说到 Java  “纯” 面向对象 (OO-Oriented-Object) 的语言。那什么是面向对象呢 ? 之前我们已经谈到了面向对象中两个最基本也是最重要的概念:类 , 对象。

    我们之前谈到:

    类是抽象的概念,是对具有共同特征 (静态的) ,共同功能或行为的事物的抽象 | 归纳 | 总结

    对象是具体的 , 是某种类型的一个实例。一个对象属于某个类 , 也就具有了这个类的特征和行为。你还能举出现实生活中关于类和对象的例子吗 ?

    万物皆对象.

    java 的世界中要使用类和对象的步骤有哪些呢 ?

    1.  定义类 public class Person{}

    a)  在这个过程中需要给一个类名 ,类中在大部分情况下有两个信息( 属性和方法 --- 都是指的属性的定义和方法的定义 )

    i.  类名的命名规则 首字符 是字母 ,_ $   ;其他字符是  前面几种 + 数字

    ii.  命名规范:每个单词的首字母大写

    b)  为了描述类型的信息需要有   属性 :类似于变量的定义

    c)  及方法

    i.  方法又如何使用呢 ?

    2.  定义好了类   我们就可以实例化对象了,实例化 ( 或称创建一个对象的 ) 语法是什么呢? (将  ( 引用 ) 类型 à 对象的过程)

    a)  基本类型:int,char,double,float,b oolean

    b)  引用类型:String,Math,Scanner,Person  数组

    3.  有了对象,如何方法其属性或方法呢 ?

    a)  对属性的赋值 称为写

    b)  从属性中读取信息 称为 读

    c)  属性可以不赋值,而直接使用 与变量不同的

    有了前面的基础,让我们一起对面向对象加深一下理解, 请记住 : 面向对象就是模拟现实世界 ,现实是什么样子,有什么问题,我们都可以用面向对象的思想以及指令对其进行描述。

     

    private 和封装

    问题:

    在现实生活中有这样一种情况 , 通常一个女孩不能随便说出自己的年龄 , 比如你张的不高,不富又不帅 , 她是不会告诉你年龄的 .

    首先,用我们之前的知识, 为了表达女孩这种类型并且她有年龄的这个属性我们可以用代码

    public class Girl { int age;}

    此时, 对于其他人来说 , 可以随便的访问她的年龄

    public class Client {

    public static void main(String[] args) {

    Girl g=new Girl();

    g.age=10;

    System.out.println(" 女孩的年龄为 :"+g.age); //  访问她的年龄

    }

    }

    或者比如对于一个员工来说,他的工资也有保密的要求( 比如只有他的上级才能知道 )

    那如何做到这一点呢?

    public   class  Employee {

    String  name ;

    double   salary ; //在外部都可以随便访问

    }

    解决办法:

    为了达到保密的目的

    这就需要关键字private( 私有的 ); 如果我们给 Girl age 添加 private , 代码如下:

    public   class  Girl {

    private   int   age ;

    }

    则对于其他人来说( 在客户端 ):

    通过上面的代码,我们可以看到private 就是私有的,当类的成员 ( 想想类的成员有哪些 : 属性和方法 ) 增加这个修饰符 (modifier) 将只能在本类的 内部 被访问.

    注意: 不是永远不能访问是在类的外部不能访问 . 就好比说你有个 private garden( 私家花园 ). 不是说谁都不能用,而是在家庭内部的成员是可以使用的 .

    问题:

    通过上面的private  我们已经成功的保护了 girl age  不被其他人随便询问。但如果有一个高富帅想访问呢 ?

    解决办法:

    所以为了解决这个问题, 我们的代码如下 :

    public   class  Girl {

    private   int   age ;

    public   int  getAge() {

    return   age ;

    }

    public   void  setAge( int  age) {

    this . age  = age;

    }

    }

    我们通过添加public 的方法让外部可以访问 . 所谓 public 就是公共的 . 可以让任何人访问 . 就像 public washroom

    此处的getAge setAge 都是两个方法 , 跟我们之前学的方法结构上都是一样的 . 请想想他们的结构为什么是一个有返回值一个没有返回值一个有参数一个没参数呢 ?

     

    注意:

    1.  getAge方法是用来读的 ,setAge 是用来写的 . 如果想让这个属性是只读的 , 那只需要使用 get 方法。如果想要这个方法是可写的 . 那只需要使用 set 。并不是说两个方法必须得同时存在。

    2.  尽管他们就是普通的方法,但是方法的名字必须是getXXX setXXX 。这个的原因将在 反射 的概念中进行讲解.

    有了以上的代码有的人可能会问: 现在添加了 getter( 对读取方法的统称 ) setter( 对设置方法的统称 ) ,这不是又让 age 属性不安全了吗 ? 而且多写了这么多代码 . 是不是没有必要呢 ?

    看看一下代码:

    public   int  getAge() {

    System. out .println( "你是高富帅吗 ?" );

    Scanner input =  new  Scanner(System. in );

    String word = input.next();

    if  ( "y" .equalsIgnoreCase(word))

    return   age ;

    return  -1;

    }

    从以上的代码,就显示了让属性直接可以访问,可通过getter/ setter 让其属性可以被访问的方式是不同的. 因为方法中可以控制逻辑,而属性本身不能。

    我们也可以写如下的代码

    public   int   getFangLing () {

    System. out .println( "你是高富帅吗 ?" );

    --- 此处省略若干字

    }

    我将方法的名字改为了getFangLing. 则这个属性的名字我们不在叫 age ,而是叫 FangLing 了。切记这一点 !!!

    如果 私有的成员变量是boolean 类型,而其 getter  isXXX();

     

    以上就是我们通过对属性私有化,然后提供公有的方法对属性进行的 封装 .

    封装是面向对象的语言的三大特征之一.

    当然, 封装本身不只包含将属性封装。从语法上讲 , 我们也可以对任意段代码块进行封装 , 使其成为方法。而我们将属性和方法再进行汇总 , 可就成了我们封装的类。

    封装可以让我们程序中的数据更加安全,( 就像我们前面说的女孩的年龄 , 员工的工资 ) 。封装可以让提高我们代码的复用性。 ( 如将某段代码封装在一起变成方法,随处进行调用,且方法是个“黑匣子”我们在调用时完全不需要知道具体的实现细节 )

    封装也是面向对象其他特征的实现基础。没有封装也就没有其他的特征.

    好了, 如果你对前面的概念理解没有问题 , 请你也举个例子,表达一下封装的概念,加深一下理解吧 !

    构造方法

    问题:

    现在, 再回头看看我们的代码 . 我们现在想没个女孩一定要有自己的年龄 , 且我们要的不是默认值 0 则你会考虑到的代码应该是 :

    public   class  Client {

    public   static   void  main(String[] args) {

    Girl g =  new  Girl();

    g.setAge(1 9 );

    int  fangLing = g. getAge ();

    System. out .println(fangLing);

    }

    }

    但是,如果我们在g.setAge() 之前就访问她的年龄呢 ? 得到的将还是 0

    另外,如果为表达女孩的特征,我们可能有更多的属性,

    import  java.util.Scanner;

     

    public   class  Girl {

    private  String  name ;

    private  String  address ;

    private  String  email ;

    private  String  phoneNo ;

    ---此处省略属性若干

    }

    我们想要设置女孩的每个属性需要做的是不断的调用setter

    public   class  Client {

    public   static   void  main(String[] args) {

    Girl g =  new  Girl();

    g.setAge(10);

    g.setAddress( 山东烟台 );

    g.setEmail( “buGaoSu@ni.com” );

    }

    }

    解决办法

    为了解决这个问题, 我们可以设置一个方法 , 一次给所有的变量赋值并且我们要保证在实例化对象的时候就进行调用 。这个方法就是 构造方法

    形如:

    public  Girl(String name, String address, String email, String phoneNo,

    int  age) {

    this . name  = name;

    this . address  = address;

    this . email  = email;

    this . phoneNo  = phoneNo;

    this . age  = age;

    }

    public Girl(){}

    请注意观察这个方法的特征:

    1.  没有返回值类型声明 (注意!也不使用 void)

    2.  方法名与类名相同( 再次强调请遵守类名的命名规范 )

    符合了以上要求就是 构造方法  ç à 构造方法一定具有以上两个特征。请注意我没有再写其他特征,也就是说我们有再增加其他的构造方法的限定和描述。

    既然定义了构造方法,那我们如何调用呢?

    实际上我们之前已经调用过了

    Person p=new Person();

    构造方法在调用时,使用new  关键字

    构造方法的作用:

    1.  初始化对象

    2.  方便初始化

     

     

    再来回顾一下默认之前编写的代码,

    public class Person {}

    我们并未给这个类编写过构造方法, 但是我们依然可以调用构造方法

    这是因为: 如果我们不定义构造方法,系统会自动定义无参 ( 没有参数 ) 的构造方法 .

    换言之,无论你是否定义构造方法,java 类中一定有它的构造方法。

    但是,如果我们自定义了构造方法,则系统将不再提供无参的构造方法。

    注意: 以上说的自定义的构造方法,没有限制为是有参的 还是无参的

     

    有了上面的结论,有些人可能就认为: 既然一个类无论如何都有构造方法,假定这个类是 Person ,那是不是一定可以 Person p=new Person(); 了呢 ?

    答案是否定的, 原因有两点 :

    1.  构造方法的本质是方法, 你可以自定义有参方法 , 这样的话就不能调用无参构造了

    2.  构造方法既然是方法,因为方法的前面有修饰符(modifier) public ; 我们如果将构造方法前面增加 private ,则从类的外部也就不能访问构造方法了

     

    我们在之前的setter 中用了关键字 this ,让我们来总结一下 this 的含义 :

    this 代表当前类型的对象. 注意是对象。

    当我们在使用以下代码时

    Person xiaoHong=new Person();

    xiaoHong.setName( xiaoHong );

    public  class Person{

         private String name;
         public void setName(String name){
               this.name=name;
         }

    }

    因为是xiaoHong.setName();  所以在 Person 类中  this 就是指的 xiaoHong

    但是如果其他人调用的话, this 就是其他人了

     

    我们可以通过Eclipse 的快捷键 Alt+shift+s O  自动生成构造方法,而我们往往会给一个类两个构造方法 , 一个是全参的,另一个是无参的

     

    重载

    问题:

    在同一个类中,两个方法可不可以同名

    解决办法:

    既然是构造方法,那就跟类的名称相同,既然都跟类的名称相同。那这两个方法名就相同了。通过我们的观察可以发现,这样写是没有问题的。

    我们把这种方法名相同的情况叫做方法的重载.

    以下让我们更详细的描述重载的特征:

    1.  方法名相同

    2.  参数列表不同,它指的是对应位置上的形参的类型不同,如

    a)  参数的个数不同public void m()  public void m(int i)

    b)  参数的类型不同public void m(int i) public void m(double j)

    c)  参数的类型顺序不同public void m(int i,String j) public void m(String j,int i);

    d)  注意 形参变量名称的不同不算不同 ,public void m(int i) public void m(int j);

    3.  在同一类中( 这条规则是朴素的,自然的 ) 就像说方法一个在 A 类中 一个在 B 类中,即使他们有再符合以上的两条都不是重载

    注意 我没有对返回值进行限定。

    不只构造方法可以进行重载,在同一个类,任意的两个方法都可以叫做重载。

    再来想想我们现实中的例子:

    如果你家里有一台豆浆机,这台豆浆机可能磨豆浆, 可以榨果汁 , 那让你来用 Java 表达一下这个概念怎么表示呢 ?

    注意:我们下面的返回值和参数的类型都不是本示例的重点,所以我们就用简单的两种类型(Dou,ShuiGuo) 进行表述 :

    public   class  DouJiangJi {

    public  String  mo DouJiang( Dou dou ){

    return   "豆浆 " ;

    }

    public  String zhaGuoZhi( ShuiGuo shuiGuo ){

    return   "果汁 " ;

    }

    }

    OK,这样是可以实现以上说的两个功能的 , 这两个方法名,就像我们平时用的豆浆机上的两个按钮。要磨豆浆就点磨豆浆的按钮,要榨果汁就点榨果汁的按钮。

    如果你家里有一位上了年纪的老奶奶,他眼已经花了,已经分不清那两个按钮哪个是哪个了呢? 这就好比方法的调用者,如果有两个按钮,调用者需要记忆并区分两个方法的方法名。当然,方法的定义者要为方法起名也要多费周折。

    而我们为何不降豆浆机的两个按钮的名字用一个代替的,如果豆浆机能根据加入的内容直接判断如何去工作岂不是这样的豆浆机更容易使用。那我们也用代码来表达一下

    public   class  DouJiangJi {

    public  String  work ( Dou dou ){

    return   "豆浆 " ;

    }

    public  String  work ( ShuiGuo shuiGuo ){

    return   "果汁 " ;

    }

    }

    也许从定义者的角度,仅仅是一个方法名的不同而已。

    而对于调用者来说,我们不再需要记忆两个方法的名字,java 可以根据方法名和参数的不同自动的调用对应的方法。因为在“调用前”,是不清楚具体的返回值的。所以返回值的类型不能作为判断调用那个方法的依据这也正是,为什么返回类型不能作为区分是否重载的原因。

    System.out.println();就是一个方法重载的很好例子

    继承

    问题:

    上面我们编写了Girl 类型,现在让我们来描述一下女学生类型

    public   class  GirlStudent {

    private  String  name ;

    private   int   age ;

    private  String  grade ;

    private  String  homePhone ;

    --- --- 省略 getter setter

    }

    对比我们之前的对Girl 的对应我们会发现,现在的代码无非增加了年级 (Grade) 和家庭电话 (HomePhone) 这两个信息 . 而对于 name age  是在 Girl 中已经存在的。那这样而言, GirlStudent 岂不是重复做了已经在 Girl 中定义的很多信息呢 . 在现实中还有很多这样的事物 , 比如老虎类 和食肉动物 \ 笔记本电脑和电脑;前者都具有了后者的很多特征和功能 ( 属性和方法 ).

    解决方案:

    为了简化前者的定义,我们需要学习概念  -继承

    在现实中有句话叫做: 龙生龙,凤生凤;老鼠生来会打洞。 这就是继承。当一个类 A 的对象也是类 B 的对象的时候,我们就称类 A 继承了 B 。这是一种是一个的关系,我们也常常谓之 is-a 的关系

    前面提到的 女生 也是女孩。老虎也是食肉动物,笔记本电脑也是电脑一样。

    注意: 继承关系是 类与类之间的关系。

    比如:有 一台 笔记本电脑,它继承了电脑类型,这种说法在面向对象的描述中是不确切的( 可能在现实中可以这么说,但面向对象中不行 ) 。因为 一台 笔记本电脑是具体的,是对象而不是类。也就谈不上具有继承关系了。

    那在代码中如何表达继承呢?

    public   class  GirlStudent  extends  Girl {

    .--- ---

    }

    A继承了类 B, A 也就具有了类 B 的所有的非私有的属性和方法

    注意: 不是所有的属性和方法,是非私有的。

    就像在现实生活中,你继承了你父亲的东西,但是如果是他的私人物品那就不能被你继承了, 现在再让我们通过代码来表达一下:

    public   class  Girl { String  name ;}

    public class GirlStudent extends Girl {} //注意我只是 extends Girl 没有在类中写任何的代码

    public   class  GirlStudentTest {

    public   static   void  main(String[] args) {

    GirlStudent  girlStudent= new   GirlStudent ();

    girlStudent. name = "欣然 " ;

    }

    }

    girlStudent本身不具有 name 属性 , girlStudent 所属的类型 GirlStudent 继承自 Girl

    所以,girlStudent 也就具有了 Girl 的属性 name.

    还有就是一个类只能有一个直接父类 ( 就想说一个人只能有一个亲爹 , 当然这么说不是很准备,大家还有个亲妈呢 )

    以下的代码是同样的

    public   class  Carnivore {

    public   void  eat() {

    System. out .println( "爱吃肉 " );

    }

    }

    public class Tiger extends Carnivore {}

    public   class  TigerTest {

    public   static   void  main(String[] args) {

    Tiger t= new  Tiger();

    t.eat();

    }

    }

    请你也来分析一下以上的代码

     

    注意:

    public   class  Girl {

    private  String  name ;

    public  String getName() {

    return   name ;

    }

    public   void  setName(String name) {

    this . name  = name;

    }

    }

    以上的代码将Girl name 属性 private 私有化 , 而增加了 getter setter 来控制访问方式 . 从生活的角度 GirlStudent 是具有 name 属性的。但对于代码而言 , 她紧紧是将 getter setter 方法被继承了, name 属性本身并没有,所以

    public   class  GirlStudentTest {

    public   static   void  main(String[] args) {

    GirlStudent girlStudent= new  GirlStudent();

    girlStudent. name = "欣然 " ;

    }

    }

    而要访问的话需要通过getter setter 方法 .

     

    在刚刚开始讲继承的时候,我们谈到继承是一种  - 一个 的关系. 就想老虎是食肉动物。女学生也是女生。数学老师是老师一样。

    也就是说一位数学老师( 对象 ) 是一位老师 ( 类型 ) ,此结论先放在这 *********

    我们再来想一下,我们之前如何来保存一位数学老师

    数学老师 张老师=new  数学老师 (); 

    ç 等价于 è  

    MathTeacher msZhang=new MathTeacher();

     

    现在我们来表示一下上面加********* 的那句话,用代码表示就是

    Teacher msZhang=new MathTeacher();

    翻译一下上面的代码就是

    老师 张老师=new  数学老师 ();

    前面********* 那一行已经说了数学老师也是一个老师,所以我们能用老师类型来保存数学老师类型。那反之呢 老师一定是数学老师吗 ? 当然不是 , 所以我们不能用数学老师来保存老师对象。如果我们 MathTeacher msZhang=new Teacher(); 编译器就会报错了。

     

    结论也就是:

    在面向对象的语言中,可以用父类的变量保存子类的对象;但,不能用子类的变量保存父类的对象。

    注意: 要理解我们上面的结论,你要先搞清楚什么是变量什么是对象。

    现实

    代码

    你这个人是对象,你无论叫小刚还是小红,你这个对象是不变的。而小刚或者小红就是变量名

    Person xiaoGang=new Person();

    Person xiaoHong=xiaoGang;

    在大部分情况下,我们说的小刚或小红这个人名,就代表了你这个人,但有的时候,比方说我们将你的名字小刚改成小小刚。这个小刚就仅仅是个人名而已了

    xiaoGang xiaoHong 在大部分情况下代表一个人类的对象。

    但在我们分析代码的时候,xiaoGang xiaoHong 紧紧是个人名而已

     

    我们上一节在讲述构造方法的时候,可以通过快捷键自定生成构造方法,其中会自动产生形如一下的代码

    public   class  Girl  extends   Person  {

    public  Girl() {

    super ();

    }

    }

    那这里的super 代表什么呢 ?

    super()代表的是父类的构造方法 . 即使我们把它删除,会被自动调用的。

    也就是说: 如果你没有调用父类的构造方法,系统会为子类的构造方法首先调用父类的无参的构造方法。

    1.  所谓 你没有调用构造方法. .. 也就是说,一旦你自己调用了构造方法,系统也就不调用父类的构造方法了

    2.  ...  子类的构造方法 ... 如果不是构造方法,不会自动调用父类的构造方法的

    注意: 我没有限定是子类的有参的构造还是无参的构造

    3.  ... “首先” ...  指的是 super() 必须是构造方法的第一条语句,如

    public  Girl() {

    super ();

    other Code 

    }

    4.  ... 父类的无参的构造方法 ... , 系统只会自动调用父类的无参的构造方法而不会自动调用父类的有参的构造方法

    如果父类没有无参的构造,则子类找不到无参的构造方法就会报语法错误

    重写和多态 ( Polymorphism )

    按字面的意思 多态 就是 多种状态 .再扩展一点来讲,是指的“方法的”多种状态。完整的来说 , 就是父类的变量调用其被重写的方法而表现出来的多种状态。

    在上面对多态的解释中,我们有一个概念是全新的--" 重写 "

    重写是子类的方法签名与父类的方法签名相同。

    方法签名包括:

    方法名,

    参数列表

    返回值

    观察以下代码

    public   class  AnimalTest {

    public   static   void  main(String[] args) {

    Animal  animal0 =  new  Rabbit();

    animal0.eat();

    Animal  animal1 =  new  Tiger();

    animal1.eat();

    }

    }

    public   class  Animal {

    public   void  eat() {

    System. out .println( "动物的吃的动作 " );

    }

    }

    public   class  Rabbit  extends  Animal {

    public   void  eat() {

    System. out .println( "兔子吃草 " );

    }

    }

    public   class  Tiger  extends  Animal {

    public   void  eat() {

    System. out .println( "老虎吃肉 " );

    }

    }

    结果:

    兔子吃草

    老虎吃肉

     

    同种类型的变量( 都是 Animal 类型 ) ,调用了相同的方法( eat 方法) , 但表现出的动作不同,这就是 多态

     

    多态的应用实例问题:

    有豆浆机可以磨豆浆,可以榨果汁。在磨豆浆的过程中,豆浆和果汁都会散发出他们各自的味道。请用代码表述以上概念。运行结果如下

    +++++豆浆机开始运转 ++++++

    豆子的味道

    ========结束 ===========

     

    $$$$$$$豆浆机开始运转 $$$$$$

    水果的香甜

    ========结束 ===========

     

    A bstract

    问题:

    观察我们之前写的Teacher 类型

    public   class  Teacher {

    public   void  jieShao() {

    System. out .println( "介绍姓名年龄等信息 " );

    }

    public   void  jiangKe() {

    }

    }

    我们写了jiangKe 的方法,而没有写方法体,因为 jiangKe 的具体实现对于不同的老师也是不同。这个方法本身就是不能实现的。那是不是我们就可以删除这个方法了呢。

    public   class  School {

    public   void  pingBi(Teacher  t ) {

    t .jieShao(); //能不能看变量

    t .jiangKe(); //报错

    }

    }

    因为Teacher 类型没有了 jiangKe 方法的定义,即使所有类型的老师都实现了 jiangKe 的方法也是不行的,因为“能不能看变量的类型”。

    解决办法:

    我们既要保留方法的签名又不需要方法体,我们就需要一个关键字abstract

    public   class  Teacher {

    public   void  jieShao() {

    System. out .println( "介绍姓名年龄等信息 " );

    }

    public   abstract   void  jiangKe();

    }

    我们删除了jiangKe() 后的 { 方法体 } , 同时我们也发现了一个错误。因为如果一个方法是 abstract 的,则它所属的类也一定是 abstract 的,所以

    public   abstract   class  Teacher {

    public   void  jieShao() {

    System. out .println( "介绍姓名年龄等信息 " );

    }

    public   abstract   void  jiangKe();

    }

    现在再来让再来新建一个HTMLTeacher ,我们发现当 HTMLTeacher extends Teacher 时, HTMLTeacher  必须要实现 Teacher 的抽象方法

    public   class  HTMLTeacher  extends  Teacher {

    public   void  jiangKe() {

    }

    }

    哪怕仅仅是给这个方法加一个{}

    现在来总结一下,abstract 的特征吧

    1.  当不知道如何实现一个方法的时候,需要给这个方法增加abstract 修饰符

    2.  当一个方法是abstract ,则它所属的类也一定是 abstract ,反之,不成立 ( 如果一个类是 abstract ,则其中一定存在 abstract 方法 )

    3.  一个类继承一个抽象类,也必须重写其中的所有的抽象方法

    4.  抽象类不能被实例化

    接口

    问题:

    炎炎夏日,我们现在最缺的就是风扇和空调,他们都可以降温,有共同的功能,那是不是我们该用一个父类来让他们继承呢。我们姑且把这个类叫做降温设备。

    public   class  LowerTemMachiner {}

    public class FengShan extends LowerTemMachiner {}

    public class KongTiao extends LowerTemMachiner{}

    而在寒冷的冬天,暖气和空调又都是升温设备。那还能表示吗?

    当然不能,因为KongTiao 已经继承了降温设备。如果他在继承升温设备。除非降温设备和升温设备之间有继承关系,这是不可能的。

    这就是java 中的单根继承造成的。

    解决办法:

    上面的空调和风扇,我们更多的强调的是他们的降温作用。更强调的是功能,我们可以用接口的概念表达以上信息,因为允许一个类同时实现多个接口

    public class KongTiao implements owerTemMachiner,HigherTemMachiner{}

    我们先来看看接口的特征:

    一个类可以实现(implements) 多个接口 interface

    接口是一个规范, 实现了接口也就必须要时间接口中的所有的方法 ( 抽象类除外 )

    接口中只能有常量( 稍后解释什么是常量 ) 不能有变量

    接口不可以实例化

    接口中只能包含抽象方法, 且所有的方法都是 public

    从上面的特征可以看出:interfac abstract class  的最大区别在于是否支持多继承。

    在当前的开发中,我们有一种思想叫做面向接口的编程。在此,先不阐述什么是面向接口的编程,但当一个概念作为一种思想的时候,我们可以想象接口的重要性。

    通过下面的代码,我们来“感受”一下面接口的威力

    问题:

    首先我们对整数进行排序。

    其他修饰符

    问题:如果想在子类中可访问,非子类中不可访问用什么修饰符

    解决办法:protected

    问题:如果想在同包中访问,我使用什么修饰符

    解决办法:default( 默认的 ) :此关键字不需要(也不能)写,同包可以访问

    常量

    问题:

    我们现在要保存一周的天数. 采用的办法为

    int days OfWeek =7;

    但是,如果在使用的过程中,程序员不小心改变了它的值呢? 从逻辑上,这是不合理的。一周的天数不可能被改变。

    解决办法:

    我们使用常量来解决这个问题

    static final int daysOfWeek=7;

    final本身就是不可变的意思 , 既然不可变 , 也便不随着对象的改变而改变,如果是属性,也就自然是 static 的了。

    在使用常量时,我们往往为了与变量区分开,采用所有字母都大写的方式进行。如果多个单词在一起,我们如何区分每个单词呢,答案是用 _( 下划线 )

    所以,上面的常量定义为

    static final int DAYS_OF_WEEK=7;

    回顾,我们在接口interface 中讲到的。

    在接口中是不允许生命变量的但可以声明常量

    枚举

    问题:

    常量只能保证自身的值不被改变。

    如果我们有学生类型,学生的性别只能是男或女怎么保证呢?

    public   class  Student {

    private  String  name ;

    private  String  gender ;

    }

    也许,你会想到通过代码setter 进行控制。但还有更好的解决办法

    解决办法:

    我们可以将gender 定义为 Genders 类型的变量,而 Genders 的取值只能是固定的几个值。我们可以将 Genders 定义为枚举类型

    public   enum  Genders {

    Male Female

    }

    现在你在创建了Student 对象后,只能为其 gender 属性,赋值为 Genders 类型的值。他们分别是 Male,Female. 并且编译工具可以对这些值进行提示。

     

    展开全文
  • 引子 在上一篇(原来JS是这样 (2))刚...另外上一篇实质上整篇都在描述 this 到底在什么情况下会绑定到哪个对象上,看上去 JavaScript 中的对象概念的确很容易让人困惑。再看下面一个例子: var strPrimitive = "...

    引子

    在上一篇(原来JS是这样的 (2))刚发布的时候就阅读了那篇文章的人可能会注意到那篇曾用过“JavaScript 中万物皆对象”的说法,而在随后我发现错误后立即更新改掉了这个错误的说法。另外上一篇实质上整篇都在描述 this 到底在什么情况下会绑定到哪个对象上,看上去 JavaScript 中的对象概念的确很容易让人困惑。再看下面一个例子:

    var strPrimitive = "I'm mamacat";
    typeof strPrimitive; // "string"
    strPrimitive instanceof String; // false
    
    var strObject = new String("I'm mamacat");
    typeof strObject; // "object"
    strObject instanceof String; // true
    
    strPrimitive.substr(8, 3); // "cat"

    同样的字符串赋值到对象,一会儿是字符串类型一会儿是对象,而明明不是对象类型的变量还是可以使用对象属性,为什么会这样呢?

    类型和内置对象

    JavaScript 中一共有六种主要(语言)类型,即 string, number, boolean, null, undefinedobject,其中前五个基本类型都不是对象(对 null 进行 typeof 得到的是 "object",这是语言本身的 BUG)。而在此之外,则有许多特殊的对象子类型,例如数组、函数和内置对象等。

    有些内置对象的名字看着和简单基本类型一样,就比如 StringBooleanObject 之类。这些内置对象从表现形式看就和别的面向对象语言中的“类”概念差不多,而正如上篇文章所属,它们实际使只是一些能被用来构造一个对应子类型的内置函数而已(不要困惑,函数也是对象,这里并不矛盾)。于是就可以回到最初的例子,strObject 是由内置函数/内置对象 String 所构造的变量,对应 String 子类型,所以它是一个对象,而 strPrimitive 则是一个原始字面值而已。

    当然,上面例子中最下面我们看上去对 strPrimitive 调用了 substr() 函数,这里则是因为,JavaScript 引擎会在需要时,把原始字面量转换成对应的对象,而转换之后我们自然就可以使用属性访问对应的方法了。

    对象属性

    那么,就上方的例子而言,String 对象实例就会有 substr() 函数可以用,但根据之前的文章可以知道,这些“函数”本身并不属于某个对象,而这些函数实质是对应对象的一个属性。当然,即便我们说某种类型的对象本身具备各种属性,实际上这些属性也多是各自独立存在的,只不过以引用的形式关联在了一起而已,这和之前了解的内容也并不矛盾。这些被关联起来的东西,被称为对象的 属性

    对象的复制

    插播一条快报,尽管之前的文章提到过,上方也又一次反复强调过属性只是以引用的形式关联起来的独立存在,我们有时仍然会“理所应当”的认为属性是对象的一部分,而最容易因此踩坑的地方之一就是对象的复制了。仔细思考即可知道,当我们复制对象时,由于其属性本身只是引用关联,故“复制”得到的对象所包含的属性引用指向的和原本对象的属性引用其实还是同一个位置:

    var ori = { a : 1};
    var ori_copy = ori;
    ori.a = 61;
    ori_copy.a; // 61

    显然这很可能和我们的期望不一样,而我们想要真正的拷贝对象则没有完美适用性的方案,很多时候的常规做法则是把对象序列化一下,然后再以此反序列化得到新的对象来实现对象的拷贝(比如使用 json)。ES6 中新增了 Object.assign() 来进行对象的浅拷贝,做法是把对象的所有可枚举属性等号赋值到新对象中。不过仍需注意的是,等号赋值并不会赋值属性的元信息(属性描述符,后述),在需要的情况下应当特别留意。

    属性访问和数组

    访问对象所关联的属性的方式即通过 . 或者 [] 操作符进行访问,obj.aobj["a"] 访问的属性实质上是一样的,而这两种访问形式的区别也只有访问的属性名称里能不能有奇怪的符号而已。[] 操作符内扔的是个字符串,实际上属性名也永远都是字符串。当然,这个概念可能比较意外的就是,数组的下标访问其实并不是例外,数字还是被转换成了字符串才被使用的。

    // 对象的属性访问:
    var tejilang = {1 : "Teji Wolf"};
    tejilang instanceof Array; // false
    tejilang["1"]; // "Teji Wolf"
    tejilang[1]; // "Teji Wolf"
    
    // 这回保证它是 Array
    var macat = ["codingcat"];
    macat instanceof Array; // true
    macat.length; // 1
    macat[0]; // "codingcat"
    macat["0"]; // "codingcat"
    macat.length = 20;
    macat; // (20) ["codingcat", empty × 19]

    数组下标既然不属例外情况,那数组对象必然有其它属性控制数组本身的行为,例如上例中,macat 数组的长度就是 length 属性所体现的,通过修改它的值也就改变了对象本身对外的表现形式。当然,由于数组本身就是对象,所以我们还是可以把数组当键值对来用,只是这种做法通常是没有意义且会让人感到困惑的。JavaScript 引擎通常都根据对象的类型做了不同程度的优化,故除了代码逻辑可读性外,合理的使用也是多少可以改善性能的。

    能够通过字符访问属性还是存在一些别的好处的,比如 ES6 的可计算属性名。当然 ES6 不在本文的关注范围内,所以这里就不再讨论了。

    属性描述符

    有时我们可能不希望某个属性被随意修改,有时候我们需要额外配置一些属性的信息,自 ES5 起,所有的属性就都具备了“属性描述符”(Property Descriptor)来控制属性本身的这些元信息。

    数据描述符

    来看这个例子:

    var chris = {};
    Object.defineProperty(chris, "IQ", {
        value: 228,
        writable: false,
        configurable: true,
        enumerable: true
    });
    chris.IQ = 61; // 静默失败了,如果是严格模式则会 TypeError
    chris.IQ; // 228

    通过 defineProperty 可以对一个对象的属性配置其对应的属性描述符(元信息),而属性描述符则包含访问描述符和数据描述符,上面的例子中,defineProperty 的第三个参数就定义了数据的若干数据描述符,其中 writable 表示可写,configurable 表示属性是否可配置(注意,修改成不可配置是单向操作),enumerable 则表示属性是否应当出现在枚举中,比如 for..in 中。

    显然我们可以通过属性描述符实现对属性的保护,而同时也存在一些方便函数来做近似的事。如 Object.preventExtensions() 会保留原有属性但禁止添加新属性,Object.seal() 会密封对象,在禁止添加新属性的基础上把原有属性标记为不可配置,Object.freeze() 会冻结对象,即在密封的基础上把数据访问属性标记为不可写。

    [[Get]], [[Put]] 和访问描述符

    在我们访问和赋值一个对象的属性时,实际上是通过 [[Get]][[Put]] 操作进行的,例如属性访问时,[[Get]] 会先找有没有这个属性,如果没有则会遍历对象的 [[Prototype]] 链(原型链,这次不谈这个概念)来找,实在找不到则返回 undefined 。而这个行为实际是允许我们通过设置 getter (get())和 setter (set())函数来改变的,它们被称为 访问描述符

    当我们提供访问描述符时,对应的访问操作就不再受到 value 和 writable 属性的影响了,另外需要注意的是,尽管它们也是属性描述符,但定义 getter 和 setter 并不要求一定要通过 defineProperty 设置:

    var obj = {
        get a() { // 给 a 属性定义 getter
            return this._a_;
        },
        set a(val) { // a 属性的 setter
            this._a_ = val * 2;
        }
    }
    
    obj.a = 2;
    obj.a; // 4

    属性存在性

    因为属性的值也可能是 undefined,不存在的属性直接访问得到的也是 undefined,所以直接通过简单的属性访问是无法区分是否存在的,这时我们即可通过 in 或者 hasOwnProperty() 检查属性是否存在对象中了:

    var obj = {a : 2};
    "a" in obj; // true
    obj.hasOwnProperty("a"); // true

    尽管仍没有讲到原型链的概念,这里仍然应注意,in 操作符会检查原型链中是否存在属性,而 hasOwnProperty 则不会。另外在一些情况下,有的对象会没有 hasOwnProperty 这个属性(此处不提原因),这时可以用过 Object.prototype.hasOwnProperty.call(objName, propertyName) 来实现检查。

    最后

    继上次 this 行为的研究后,这次进一步了解了 JavaScript 中对象属性的相关基本概念。和之前一样,如果你希望进一步了解这相关的内容,不妨去读一读《You don’t know JS - this & object prototypes》一书(这篇只覆盖了该书中 “对象” 一章的内容)。这是一本开源书,你可以在这里在线阅读这本书,或者购买这本书的电子版或实体版。这本书的中文译本涵盖在《你所不知道的 JavaScript 上卷》中,你也可以考虑看中文版。

    最后,尽管我会尽可能仔细的检查文章内容是否有问题,但也不保证这篇文章中一定不会有错误,如果您发现文章哪里有问题,请在下面留言指正,或通过任何你找得到的方式联系我指正。感激不尽~

    转载于:https://www.cnblogs.com/blumia/p/Thats-JavaScript-object-property.html

    展开全文
  • Hibernate简单讲就是ORM,对象关系映射一种技术,直接将POJO对象跟DB间关系进行配置,描述。目标是为了解决OO开发人员将对象映射成为RDB中实体过程,屏蔽其中差异性。 POJO状态说明: 在利用hibernate ...
  •  error是指程序中的非正常运行状态,在其他编程语言中称为“异常”或“错误”,解释器会为每个错误情形创建并抛出一个Error对象,其中包含错误的描述信息;  ECMAScript定义了六种类型的错误,除此之外,还可以...
  • 概念error是指程序中的非正常运行状态,在其他编程语言中称为“异常”或“错误”,解释器会为每个错误情形创建并抛出一个Error对象,其中包含错误的描述信息;ECMAScript定义了六种类型的错误,除此之外,还可以使用...
  • 接口描述了类行为和功能,而不需要完成类特定实现。C++ 接口是使用抽象类来实现,抽象类与数据抽象互不混淆,数据抽象是一个把实现细节与相关数据分离开的概念。如果类中至少有一个函数被声明为纯虚函数,则...
  • 解释器会为每个错误情形创建并跑车一个Error对象,其中包含错误的描述信息。 通过使用JavaScript提供的异常处理语句,可以用结构化的方式来捕捉发生的错误,让异常处理代码与核心业务代码实现分离。 错误 与异常处理...
  • 解释器会为每一个错误创建并抛出一个Error对象,其中包含错误描述信息。通过使用JavaScript提供异常处理语句,可以用结构化方式来捕捉发生的错误,让异常处理带啊与核心业务代码实现分离。错误与异常处理在...
  • 异常指程序运行过程中出现非正常现象,例如用户输入错误、除数为0、需要处理文件不存在、数组下标越界等。 在Java异常处理机制中,引进了很多用来描述和处理异常类,称为异常类。异常类定义中包含了该类...
  • 单元测试依据是详细设描述,单元测试应对模块内所有重要控制路径设计测试用例,以便发现模块内部的错误。单元测试多采用白盒测试技术,系统内多个模块可以并行地进行测试。  当考虑面向对象软件时,单元的概念...
  • 如果在阅读过程中发现有错误,望评论指正,希望大家一起学习,一起进步。...强大之处在于:描述生活中的对象—面向对象 #include <iostream> #include <string> using...
  • (25) 下面对对象概念描述错误的是(A) 注:P55 A. 任何对象都必须有继承性 B. 对象是属性和方法的封装体 C. 对象间的通讯靠消息传递 D. 操作是对象的动态性属性 (26) 下面不属于软件工程的3个要素的是(D) 注:P62 A. ...
  • 当异常情况发生,一个代表该异常的对象被创建并且在导致该错误的方法中被引发(throw,或称为抛出)。该方法可以选择自己处理异常或传递该异常。 可以认为异常是错误的一种,但是错误可能又语法或者逻辑导致程序不能...
  • 这使得和其他程序员交流也更简单,因为在针对通用问题通用解决方案中,模式是描述解决方案中彼此协作大量相关编程概念的快捷方式。一些更为通用方式,如工厂方法 则是普便存在,甚至存在于 Java 语言本身。...
  • python笔记11面向对象

    2020-10-08 12:56:05
    类:一种抽象概念,类别,由多个具有类似属性的对象定义对象:具体存在,属于类,属性是它的描述,方法是它行为 这样肯定解释肯定不清晰,举几个例子就好了, 类:游戏,汽车,鱼 对象:lol,保时捷帕拉梅拉...
  • 事件ID:10005 DCOM错误的解决办法

    千次阅读 2009-11-26 15:21:25
    而今天更是出现了蓝屏,重启后我打开eventvwr然后点系统,查看发现一大堆错误,细看发现错误均来源于DCOM,错误信息如下: 事件ID:10005 描述:DCOM(分布式组件对象模型)是一系列微软的概念和程序接口,利用这个...
  • JavaScript面向对象详解

    2020-11-26 21:18:15
    JavaScript中没有类的概念 我们可以把对象看作散列表,无非就是一组名值对,值可以是数据或函数 创建对象最简单方法就是创建一个Object对象,再为他添加属性和方法 属性类型 JavaScript中有两种属性,数据属性和...
  • jsp内置对象*exception

    2016-02-28 14:02:00
    是一个例外(错误或异常)对象,当一个页面在运行过程中发生了例外,就产生这个对象。如果一个JSP页面要应用此对象,就必须把isErrorPage设为true,否则无法编译。他实际上是java.lang.Throwable的对象 方法说明: ...
  • (25) 下面对对象概念描述错误的是______。(A) A. 任何对象都必须有继承性 B. 对象是属性和方法的封装体 C. 对象间的通讯*消息传递 D. *作是对象的动态性属性 (26) 下面不属于软件工程的3个要素的是______。(D) A. ...
  • 为了更加精准地对这种复合类型或对象进行描述,值语义(Value Semantic)和引用语义(Reference Semantic)被引入,定义如下。 <ul><li>值语义:复制(赋值操作&#...
  • 此外,本书还讨论了各种与面向对象概念密切相关应用主题,包括XML、UML建模语言、持久存储、分布式计算和客户/服务器技术等。  本书内容精炼,示例简单明了,适合各层次面向对象开发人员阅读,也是高校相关专业...
  • ORACLE基础概念

    2017-05-10 17:33:38
     用Oracle官方描述:实例是访问Oracle数据库所需一部分计算机内存和辅助处理后台进程,是由进程和这些进程所使用内存(SGA)所构成一个集合。其实就是用来访问和使用数据库一块进程,它只存在于内存中。就像...
  • 数据结构---概念初识

    2015-10-26 23:43:52
    申明:此为本人学习笔记,若有纰漏错误之...数据:描述客观事物符号,是计算机中可以操作的对象,是能被计算机识别,并输入给计算机处理符号集合。 数据对象:指性质相同数据元素集合,是数据子集。 数据元
  • 本书论述运用UML(统一建模语言)和模式进行对象建模方法和技巧,重点讨论了如何使用面向对象的分析和设计技术来建造一个健壮和易于维护系统。 全书叙述清晰、图文并茂、实例丰富,是一部来自于大量经验...
  • 虽然写这个博客主要目的是为了给我自己做一个思路记忆录,但是如果你恰好点了进来,那么先对你说一声欢迎。...类建模,描述系统内部对象的特征、对象之间相互关系以及对象所属每个类属性和操作,捕获系...
  • 解释器会为每个错误情形创建并抛出一个Error对象,其中包含错误的描述信息。 通过使用JavaScript提供的异常处理语句,可以用结构化的方式来捕捉发生的错误,让异常处理代码与核心业务代码实现分离。 错误与异常处理...
  • 十二、 通过异常处理错误 12.1 概念 把“描述在正常执行过程中做什么事”代码和“出了问题怎么办”代码相分离。捕获这些异常。 12.2 基本异常 ...错误信息可保存在异常对象内部或者用异常类
  • 8.5 变化的概念 8.6 父子关系 8.7 模式 8.7.1 用于生成对象的模式 8.7.2 用于组织对象和类模式 8.7.3 面向任务模式 8.7.4 企业模式 8.7.5 数据库模式 8.8 小结 第9章 生成对象 9.1 生成对象的问题和解决方法 ...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 316
精华内容 126
热门标签
关键字:

对象概念描述错误的是