精华内容
下载资源
问答
  • 2017-08-14 11:29:48

    事件指的是鼠标点击,键盘输入等用户操作。其本身就是一个对象。

    事件对象:事件发生后,在flex中就称为事件对象,事件对象有针对其的侦听器,事件对象有其属性,比如:target。

    事件发生的对象:指事件源。

    事件源:发生事件的对象,一般指某一具体的组件,比如:用户点击某Button,则此Button即为事件源。

    侦听器:是一个方法,用以响应事件。

    更多相关内容
  • 文章目录一、DOM的概念二、DHTML与HTML DOM三、Document对象获取元素方法四、Element对象与属性相关方法五、对DOM对象的操作1、DOM对象的属性2、创建元素3、挂载元素4、删除元素5、克隆元素六、调整元素样式的方式七...
  • 面向对象基本概念

    万次阅读 多人点赞 2019-02-06 21:56:15
    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体...对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。 面向对象编程(OOP:object-orie...

    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。

    面向对象编程(OOP: object-oriented programming)

    面向对象

     

    面向对象与面向过程的区别

    项目名称面向对象程序设计面向过程程序设计(也叫结构化编程)
    定义面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”,其基本思想是一切皆对象,是一种“自下而上”的设计语言,先设计组件,再完成拼装。面向过程是“自上而下”的设计语言,先定好框架,再增砖添瓦。通俗点,就是先定好main()函数,然后再逐步实现mian()函数中所要用到的其他方法。
    特点封装、继承、多态算法+数据结构
    优势适用于大型复杂系统,方便复用、适用于简单系统,容易理解
    劣势比较抽象、性能比面向过程低难以应对复杂系统,难以复用,不易维护、不易扩展
    对比易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统 更加灵活、更加易于维护 性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发,性能是最重要的因素。 
    设计语言Java、Smalltalk、EIFFEL、C++、Objective-、C#、Python等C、Fortran
    使用场景

    30种编程语言的比较选择问题https://blog.csdn.net/ljy1988123/article/details/7782700

    类与对象的主要区别

    对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。 

    :类是一个模板,它描述一类对象的行为和状态。

    1、面向对象三大主要特征(理解)

    ①封装

    两层含义:一层含义是把对象的属性和行为看成一个密不可分的整体,将这两者“封装”在一个不可分割的独立单元(即对象)中;另一层含义指“信息隐藏”,把不需要让外界知道的信息隐藏起来,有些对象的属性及行为允许外界用户知道或使用,但不允许更改,而另一些属性或行为,则不允许外界知晓,或只允许使用对象的功能,而尽可能隐藏对象的功能实现细节。

    封装的优点

    • 良好的封装能够减少耦合,符合程序设计追求“高内聚,低耦合”。

    • 类内部的结构可以自由修改。

    • 可以对成员变量进行更精确的控制。

    • 隐藏信息实现细节。

    实现Java封装的步骤

    1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:

    public class Person { 
        private String name; 
        private int age; 
    }

    这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。

    2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:

    public class Person{ 
        private String name;
        private int age; ​ 
        private boolean alive;
    
        public int getAge(){
            return age; 
        } 
    
        public void setAge(int age){ 
            this.age = age; 
        } ​
    
        public String getName(){ 
            return name; 
        } ​
     
        public void setName(String name){ 
            this.name = name; 
        }
    
        public boolean isAlive() {
    		return alive;
    	}
    
    	public void setAlive(boolean alive) {
    		this.alive = alive;
    	}
    
    }

    采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。

    封装同时可以提高代码的安全性,例如普通的类属性不是private修饰就直接可以通过“对象名.属性 = xxx”对其赋值,但当我们用private修饰该属性后就不能这样对其做任意的修改了,而且我们还可以在其对外的访问方法中进行合法值校验。比如上例中的setAge()就可以更改为:

    public void setAge(int age){
        if(age > 120)
            System.out.println("Age setting error");
        else
            this.age = age;
    }

     封装的使用细节:

    1. 一般使用private访问权限
    2. 提供相应的get、set方法来访问相关属性,这些方法通常是public修饰的。以提供对属性的赋值与读取操作。(注意!boolean变量的get方法是is开头。)
    3. 一些只用于本类的辅助性方法,可以使用private修饰,希望其他类调用的方法用public修饰。

    this与super关键字:

    1、this关键字代表当前对象

    2、super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。  

     this与super对比

    • this.属性 操作当前对象的属性
    • this.方法 调用当前对象的方法 
    • 引用构造函数:调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。
    • 普通的直接引用:与this类似,super相当于是指向当前对象的父类,这样就可以用super.xxx来引用父类的成员。
    • 子类中的成员变量或方法与父类中的成员变量或方法名同名时,表示调用父类的成员
    • 引用构造函数:调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。默认在构造函数第一条语句是“super();”,无论写与否。
    • super(参数):调用基类中的某一个构造函数(应该为构造函数中的第一条语句)
    • this(参数):调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
    • 调用super()必须写在子类构造方法的第一行,否则编译不通过。每个子类构造方法的第一条语句,都是隐含地调用 super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。
    • super() 和 this() 类似,区别是,super() 从子类中调用父类的构造方法,this() 在同一类内调用其它方法。
    • super() 和 this() 均需放在构造方法内第一行。
    • 尽管可以用this调用一个构造器,但却不能调用两个。
    • this 和 super 不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有 super 语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。
    • this() 和 super() 都指的是对象,所以,均不可以在 static 环境中使用。包括:static 变量,static 方法,static 语句块。
    • 从本质上讲,this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。

    ②继承

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    类的继承格式:

    class 父类 { }

    class 子类 extends 父类 { }

    继承的类型:需要注意的是 Java 不支持多继承,但支持多重继承。

     继承的好处:

    (1)提高类代码的复用性

    (2)提高了代码的维护性

    (3)使得类和类产生了关系,是多态的前提(它也是继承的一个弊端,类的耦合性提高了)

    继承的特性

    • 子类拥有父类非 private 的属性、方法。

    • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

    • 子类可以用自己的方式实现父类的方法,即重写父类方法。

    • Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 A 类继承 B 类,B 类继承 C 类,所以按照关系就是 C 类是 B 类的父类,B 类是 A 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

    • 继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

    • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

     final关键字:

    表示最终的意思,可以修饰类、成员变量、成员方法

    • 修饰类:类不可以被继承
    • 修饰成员变量:变量为常量,值不可以改变
    • 修饰成员方法:方法不能被重写
    • final还可以修饰局部变量:①修饰基本数据类型,值不能改变;②修饰引用数据类型,地址值不能改变

     static关键字(静态):

    static表示静态的意思,既可以修饰成员变量,又可以修饰成员方法,还有一种特殊用法修饰类

    (1)、修饰成员变量表示静态变量:static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。static不能修饰局部变量。

    (2)、修饰成员方法:static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

    (3)static代码块:static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。

    特点:
        1)随着类的加载而加载
        2)优先于对象存在
        3)被所有的对象所共享
            该特点是我们使用static的条件

    注意事项:
        1)在静态方法中,不能出现this/super
        2)静态方法只能访问静态成员;非静态方法既可以访问静态成员,也可以访问非静态成员
        3)工具类里面的成员一般来说是静态成员(目的:节约内存空间)

    静态变量和成员变量的区别
    1)所属不同
          静态变量属于类,也称为类变量
          成员变量属于对象,也称为实例变量
    2)内存中位置不同
          静态变量存在方法区
          成员变量存在堆中
    3)出现的时间不同
          静态变量随着类的加载而加载,随着类的消亡而消亡
          成员变量随着对象的创建而创建,随着对象的消失而消失
    4)调用方式不同
          静态变量通过类名调用,也可以通过对象名调用(不建议)
          成员变量只能通过对象名调用
    所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据

    成员变量与局部变量的区别
    1)在类中的位置不同
           成员变量:在类中方法外面
           局部变量:在方法或者代码块中,或者方法的声明上(即在参数列表中)
    2)在内存中的位置不同,可以看看Java程序内存的简单分析
           成员变量:在堆中(方法区中的静态区)
           局部变量:在栈中
    3)生命周期不同
          成员变量:随着对象的创建而存在,随着对象的消失而消失
          局部变量:随着方法的调用或者代码块的执行而存在,随着方法的调用完毕或者代码块的执行完毕而消失
    4)初始值
          成员变量:有默认初始值
          局部变量:没有默认初始值,使用之前需要赋值,否则编译器会报错(The local variable xxx may not have been initialized)

    package se01.day02;
    
    //子父类静态代码块、构造代码块、构造方法
    class Fu{
    	String name;
    	int age;
    	
    	{
    		System.out.println("构造代码块Fu");
    	}
    	
    	static{
    		System.out.println("静态代码块Fu");
    	}
    	
    	public Fu() {
    		System.out.println("无参构造方法Fu");
    	}
    
    	public Fu(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Fu");
    	}
    
    }
    public class Zi extends Fu{
    	int id;
    	{
    		System.out.println("构造代码块Zi");
    	}
    	static{
    		System.out.println("静态代码块Zi");
    	}
    	public Zi() {
    		System.out.println("无参构造方法Zi");
    	}
    
    	public Zi(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Zi");
    	}
    	public static void main(String[] args) {
    		new Zi("小明",13);
    	}
    }
    
    ==========================执行结果为====================================
    静态代码块Fu
    静态代码块Zi
    构造代码块Fu
    无参构造方法Fu
    构造代码块Zi
    有参构造Zi

    static特殊用法(static修饰类):  如果一个类要被声明为static的,只有一种情况,就是静态内部类。如果在外部类声明为static,程序会编译都不会过。(在内部类中详细讲解)

    Question:在什么情况下需对属性和方法加上static关键字?

    在编写的代码中,static定义的属性出现几率不是特别高,一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用static定义属性,而大部分情况下依然都使用非static属性。

    产生实例化对象是因为在堆内存中可以保存属性信息,所以如果一个类中没有属性产生,就自然也没有必要去开辟堆内存保存属性内容了,所以这个时候就可以考虑类中的方法全部使用static声明。

    NOTICE:在JDK1.7之前,Java一直存在一个Bug,可以先执行静态代码块来代替主方法。按照标准来说,所有的程序应该都是从主方法开始执行,但是下例却先执行静态代码块

    	public static void main(String[] args) {
    		System.out.println("你好,世界");
    	}
    	
    	static{
    		System.out.println("Hello World");
    	}
    
    ===========输出结果为==============
    Hello World
    你好,世界

    ③多态

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态的体现

    Java语言中含有方法重载与对象多态两种形式的多态:

    方法重载:在一个类中,允许多个方法使用同一个名字,但方法的参数不同,完成的功能也不同。

    对象多态:子类对象可以与父类对象进行转换,而且根据其使用的子类不同完成的功能也不同(重写父类的方法)。

    面试题:什么是多态?实现多态的方法有哪些?

    多态是面向对象的最后一个主要特征,它本身主要分为两个方面:
           ·方法的多态性:重载与覆写
                |-重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能。
                |-覆写:同一个方法,根据操作的子类不同,所完成的功能也不同。
           ·对象的多态:父子类对象的转换。
                |-向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动;
                |-向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类)父类实例,强制。

    多态的优点

    • 1. 消除类型之间的耦合关系
    • 2. 可替换性
    • 3. 可扩充性
    • 4. 接口性
    • 5. 灵活性
    • 6. 简化性

    多态存在的三个必要条件

    • 继承
    • 重写
    • 父类引用指向子类对象

    比如:Parent p = new Child();

    多态的访问方式:
    (1)成员变量
        编译看左边,运行看左边
    (2)成员方法
        编译看左边,运行看右边
    (3)静态方法
        编译看左边,运行看左边

    多态的实现方式

    方式一:重载与重写:

    这个内容已经详细讲过,就不再阐述,详细请见上文。

    方式二:抽象类和抽象方法

    在Java中,一个没有方法体的方法称为抽象方法。而一个类中如果有抽象方法,那么这个类就称之为抽象类。

    格式:
        抽象类:abstract class 类名{}
        抽象方法:修饰符 abstract 返回值类型 方法名(参数列表){方法体;}

    特点:
        1)抽象类不一定有抽象方法,但是有抽象方法的类一定是抽象类
        2)抽象类不可以实例化(不能用new关键字创建抽象类实例)
        3)抽象类的子类,可以是抽象类,也可以是具体类。如果子类是具体类,需要重写抽象类里面所有抽象方法

    组成:
        1)成员变量
            可以是变量,可以是常量
        2)构造方法
            有构造方法
            抽象类不可以实例化,存在构造方法,有什么用?
            子类会调用父类的构造方法,对属性进行初始化赋值
        3)成员方法
            可以是抽象方法,也可以是具体方法

    抽象(abstract)不能与那些关键字共存?
    1).private :因为一个abstract方法需要被重写,所以不能修饰为private;
    2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的,所以不能同final共存;
    3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间,所以不能同static共存;(abstract是没有实现  的,不能产生对象,而是static是属于类的,类本身是已经存在的对象)
    4).synchronized: 是同步的,然而同步需要具体的操作才能同步,但, abstract是只有声明没有实现的(即,使用synchronized关键字的是需要有具体的实现同步的操作的,但是使用abstract是只有声明而没有实现的,这样就产生了冲突)
    5).native:他们本身的定义就是冲突的,native声明的方法是移交本地操作系统实现的,而abstract是移交子类对象实现的,同时修饰的话,导致不知道谁实现声明的方法

    方式三:接口

    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。实际上是一个规范,它会要求你做什么,但不会要求你去怎么做。接口里面定义的是额外功能,但是不给出具体的实现。

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。

    接口与类相似点:

    • 一个接口可以有多个方法。
    • 接口文件保存在 .java 结尾的文件中,文件名使用接口名。
    • 接口的字节码文件保存在 .class 结尾的文件中。
    • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

    接口与类的区别:

    • 接口不能用于实例化对象。
    • 接口没有构造方法。
    • 接口中所有的方法必须是抽象方法。
    • 接口不能包含成员变量,除了 static 和 final 变量。
    • 接口不是被类继承了,而是要被类实现。
    • 接口支持多继承。

    接口特性:

    • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
    • 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
    • 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

    抽象类和接口的区别:

    • 1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
    • 2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
    • 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
    • 4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    接口的多继承

    接口和接口继承关系,可以单继承,多继承,多级继承

    标记接口

    标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

    Java中的标记接口有:

    1. java.io.Serializable这个接口是用来标记类是否支持序列化的,所谓的序列化就是将对象的各种信息转换成可以存储或者传输的一种形式。如果一个类没有实现该接口,却被拿去序列化的了,那么虚拟机就会抛出不支持序列化的异常
    2. Cloneable接口在深度拷贝的时候经常被用到,在调用java.lang.Object类中clone方法的过程中,如果对象没有实现Cloneable接口,那么虚拟机就会抛出一个CloneNotSupportedException异常。
    3. java.util.RandomAccess这个接口的作用是判断集合是否能快速访问,也就是通过索引下标能否快速的移动到对应的元素上。我们在使用某个集合类中,集合中的元素可以通过索引index下标快速的访问到,那么在该类的定义处,一般会有一个RandomAccess接口的实现标签。

      比如:java.util.ArrayList<E>有这个接口,java.util.LinkedList<E>就没有

      1 public class ArrayList<E> extends AbstractList<E>
      2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
      3 {
      4 //...
      5 }
      1 public class LinkedList<E>
      2     extends AbstractSequentialList<E>
      3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
      4 {
      5     ...
      6 }

    2、数组的使用以及初始化操作

    数组是用来存储多个相同数据类型值的容器。

    数组初始化
    1)动态初始化
        只指定数组的长度,由系统分配默认值
        格式:
        数据类型[] 数组名 = new 数据类型[长度];     或者      数据类型 数组名[] = new 数据类型[长度]
        默认值:
        byte、short、int、long,默认0
        float、double,默认0.0
        boolean,默认false
        char,默认'\u0000'
        String,默认null(所有引用数据类型默认都是null)
    2)静态初始化
        指定数组里面每个元素的初始值,不指定数组的长度
        格式:
            数据类型[] 数组名 = new 数据类型[]{元素1,元素2...};
        简写:
            数据类型[] 数组名 = {元素1,元素2...};

    简单实例:

    public static void main(String[] args) {
    		  double[] myList = {1.9, 2.9, 3.4, 3.5};
    		  
    	      // 打印所有数组元素
    	      for (int i = 0; i < myList.length; i++) {
    	         System.out.print(myList[i] + " ");
    	      }
    	      System.out.println("\n=================");
    	      for (double d : myList) {
    			System.out.print(d + " ");
    		}
    	      System.out.println("\n=================");
    	      // 计算所有元素的总和
    	      double total = 0;
    	      for (int i = 0; i < myList.length; i++) {
    	         total += myList[i];
    	      }
    	      System.out.println("Total is " + total);
    	      // 查找最大元素
    	      double max = myList[0];
    	      for (int i = 1; i < myList.length; i++) {
    	         if (myList[i] > max) max = myList[i];
    	      }
    	      System.out.println("Max is " + max);
    	}
    
    
    运行结果:
    1.9 2.9 3.4 3.5 
    =================
    1.9 2.9 3.4 3.5 
    =================
    Total is 11.7
    Max is 3.5
    

     冒泡排序(相邻的元素进行比较,大值往后排):

    	public static void bubbleSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = 0; j < arr.length-1-i; j++) {
    				if(arr[j]>arr[j+1]){
    					temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    			}
    		}
    	}

     选择排序(前面元素与后面的元素诸葛逐个进行比较,小值往前排):

    	public static void selectSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = i+1; j < arr.length; j++) {
    				if(arr[i]>arr[j]){
    					temp = arr[i];
    					arr[i] = arr[j];
    					arr[j] = temp;
    				}
    			}
    		}
    		System.out.println(Arrays.toString(arr));
    	}

     多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:

    String str[][] = new String[3][4];

    多维数组初始化的方式与一维数组初始化方式类似,也分动态和静态两种方式。

    不规则数组

    “ 不规则 ” 数组 , 即数组的每一行有不同的长度。典型的案例是杨辉三角

    //不规则数组,杨辉三角
    public class LotteryArray {
    	public static void main(String[] args) {
    		final int NMAX = 10; //最大行数
    		int[][] odds = new int[NMAX][];
    		for (int n = 0; n < NMAX; n++)
    			odds[n] = new int[n + 1]; //初始化,开辟空间
    		for (int n = 0; n < odds.length; n++) {
    			for (int k = 0; k < odds[n].length; k++) {
    				/*
    				 * int lotteryOdds = 1;
    				 * for (int i = 1; i <= k; i++) 
                                     *     lotteryOdds = lotteryOdds * (n - i + 1) / i;
    				 * odds[n][k] = lotteryOdds;
    				 */
    				// 第一个和最有一个都是1,其余的都是它的上一个和它的上一个的前一个的和
    				if (k == 0 || k == odds[n].length - 1) {
    					odds[n][k] = 1;
    				} else {
    					odds[n][k] = odds[n - 1][k - 1] + odds[n - 1][k];
    				}
    
    			}
    		}
    		for (int[] row : odds) {
    			for (int odd : row)
    				System.out.printf("%4d", odd);
    			System.out.println();
    		}
    
    	}
    }
    
    
    =======================结果显示============================
       1
       1   1
       1   2   1
       1   3   3   1
       1   4   6   4   1
       1   5  10  10   5   1
       1   6  15  20  15   6   1
       1   7  21  35  35  21   7   1
       1   8  28  56  70  56  28   8   1
       1   9  36  84 126 126  84  36   9   1

    数组工具类Arrays

    修饰符和类型方法和描述
    static <T> List<T>

    asList(T... a)

    返回由指定数组支持的固定大小的列表。

    static int

    binarySearch(byte[] a, byte key)

    使用二进制搜索算法在指定的字节数组中搜索指定的值。

    static int

    binarySearch(byte[] a, int fromIndex, int toIndex, byte key)

    使用二进制搜索算法搜索指定值的指定字节数组的范围。

    char[]、double[]、float[]、int[]、long[]、Object[]、short[]...同样适用

    static boolean[]

    copyOf(boolean[] original, int newLength)

    使用false复制指定的数组,截断或填充(如果需要),以使副本具有指定的长度。

    static byte[]

    copyOf(byte[] original, int newLength)

    使用零复制指定的数组,截断或填充(如有必要),以使副本具有指定的长度。

    char[]、double[]、float[]、int[]、long[]...同样适用

    static char[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    static double[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    boolean[]、char[]、float[]、int[]、long[]同样

    static booleanequals(boolean[] a, boolean[] a2)

    如果两个指定的布尔数组彼此相等,则 返回true。

    byte[]、char[]、double[]...同样适用

    static voidfill(boolean[] a, boolean val)

    将指定的布尔值分配给指定的布尔数组的每个元素。

    byte[]、char[]、double[]...同样适用

    static voidparallelSort(byte[] a)

    将指定的数组按升序排序。java8新特性,并行排序。

    static voidsort(float[] a)

    将指定的数组按升序排序。串行排序。

    static voidsort(float[] a, int fromIndex, int toIndex)

    按升序对数组的指定范围进行排序。

    int[]、short[]、long[]、double[]...同样适用

    static StringtoString(boolean[] a)

    返回指定数组内容的字符串表示形式。

    3、java基本数据类型和引用传递区别

    简概: ①形参为基本数据类型形参改变,实参不会发生改变
     ②形参为引用数据类型形参改变,实参也会跟着改变(有特例)

    详述:https://blog.csdn.net/sugar_no1/article/details/86506510

     

    展开全文
  • 相关事件的几个概念:  事件类型(event type):用来说明发生什么类型事件的字符串;  事件目标(event target):发生事件对象;  事件处理程序(event handler):处理或响应事件的函数;  事件对象(event...
  • 第5章 面向对象的基本概念 本章学习目标 ?... 对象 对象是面向对象编程的基本元素每个对象都有自己的属性方法事件 2类 类是描述一系列实体共同特征的概念例如昆虫类共同特征是有翅膀会飞产卵等在面向
  • 面向对象——事件

    千次阅读 2020-04-14 09:42:54
    事件基于委托,为委托提供了一种发布/订阅机制。在架构内到处都能看到事件。 事例代码中,事件用于连接CarDealer类和Consumer类。CarDealer类提供了一个新车到达的事件。Consumer类订阅该事件,以获得新车到达的...

           事件基于委托,为委托提供了一种发布/订阅机制。在架构内到处都能看到事件。

          事例代码中,事件用于连接CarDealer类和Consumer类。CarDealer类提供了一个新车到达的事件。Consumer类订阅该事件,以获得新车到达的通知。

    1. 事件发布程序。

    从CarDealer类开始,它基于事件提供一个订阅。CarDealer类用event关键字定义了类型为EventHander<CarInfoEventArgs>的NewCarInfo事件。在NewCar()方法中,触发NewCarInfo事件。作为一个约定,事件一般使用带两个参数的方法,其中一个参数是一个对象,包含事件的发送者,第二个参数提供了事件的相关信息。第二个参数不同的事件类型而不同。.Net1.0位所有不同的数据类型的事件定义了几百个委托。有个泛型委托EventHander<T>后,这就不再需要委托了。EventHander<TEventArgs>定义了一个处理程序,它返回Void,接受两个参数。对于EventHander<TEventArgs>,第一个参数必须是object类型,第二个参数是T类型。EventHander<TEventArgs>的约束;它必须派生基类EventArgs,例:

    Public eventEventHander<CarInfoEventArgs> NewCarInfo;

    委托EventHander<TEventArgs>定义如下:

    Public delegate void EventHander<TEventArgs>(object sender,IEventArgs e) where TEventArgs:EventArgs

    注:CarDealer类在NewCar方法中触发事件。使用NewCarInfo和花括号可以调用事件订阅的所有处理程序。注意与多播委托一样,方法的执行顺序无法保证,为了控制处理程序的调用,可以使用Delegate类的GetInvocationList()方法,访问委托列表中的每一项,并独立地调用每个方法。

        在触发事件之前需要检查委托NewCarInfo是否不为空。如果没有订阅处理程序,委托就是空。

      public void NewCar(string car)

            {

                Console.WriteLine("CarDealer, new car {0}", car);

                if (NewCarInfo != null)

                {

                    NewCarInfo(this, new CarInfoEventArgs(car));

                }

            }

    1. 事件侦听器

    Consumer类用作事件侦听器。这个类订阅了CarDealer类的事件,并定义了NewCarIsHere方法,该方法满足EventHander<CarInfoEventArgs>委托的要求,其参数类型是object和CarInfoEventArgs,例:

    namespace Wrox.ProCSharp.Delegates

    {

        public class Consumer

        {

            private string name;

            public Consumer(string name)

            {

                this.name = name;

            }

            public void NewCarIsHere(object sender, CarInfoEventArgs e)

            {

                Console.WriteLine("{0}: car {1} is new", name, e.Car);

            }

        }

    }

    1. 连接事件发布程序和订阅器。通过”+=”创建一个订阅。通过“-=”取消订阅。

    程序源码如下:

    1. 发布程序:

    namespace Wrox.ProCSharp.Delegates

    {

        public class CarInfoEventArgs : EventArgs

        {

    public string Car { get; private set; }

            public CarInfoEventArgs(string car)

            {

                this.Car = car;

            }      

        }

        public class CarDealer

        {

            public event EventHandler<CarInfoEventArgs> NewCarInfo;

            public void NewCar(string car)

            {

                Console.WriteLine("CarDealer, new car {0}", car);

                if (NewCarInfo != null)

                {

                    NewCarInfo(this, new CarInfoEventArgs(car));

                }

            }

        }

    }

    1. 事件订阅者代码:

    namespace Wrox.ProCSharp.Delegates

    {

        public class Consumer

        {

            private string name;

            public Consumer(string name)

            {

                this.name = name;

            }

            public void NewCarIsHere(object sender, CarInfoEventArgs e)

            {

                Console.WriteLine("{0}: car {1} is new", name, e.Car);

            }

        }

    }

    1. Program类

    namespace Wrox.ProCSharp.Delegates

    {

        class Program

        {

            static void Main()

            {

                var dealer = new CarDealer();

                var michael = new Consumer("Michael");

                dealer.NewCarInfo += michael.NewCarIsHere;

                dealer.NewCar("Mercedes");

                var nick = new Consumer("Nick");

                dealer.NewCarInfo += nick.NewCarIsHere;

                dealer.NewCar("Ferrari");

                dealer.NewCarInfo -= michael.NewCarIsHere;

                dealer.NewCar("Toyota");

            }

        }

    }

    结果:

    CarDealer, new car Mercedes

    Michael: car Mercedes is new

    CarDealer, new car Ferrari

    Michael: car Ferrari is new

    Nick: car Ferrari is new

    CarDealer, new car Toyota

    Nick: car Toyota is new

    事件和委托的关系:事件本身就是一个委托类型。

     

     

     

     

     

     

     

     

     

     

     

     

    委托的妙文

    委托和事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里别(biè)得慌,混身不自在。本文中,我将通过两个范例由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.Net Framework中的委托和事件、委托和事件对Observer设计模式的意义,对它们的中间代码也做了讨论。 

    将方法作为方法的参数
    我们先不管这个标题如何的绕口,也不管委托究竟是个什么东西,来看下面这两个最简单的方法,它们不过是在屏幕上输出一句问候的话语: 

    以下为引用的内容:
           public void GreetPeople(string name) {
                  //
    做某些额外的事情,比如初始化之类,此处略
                  EnglishGreeting(name);
           }
           public void EnglishGreeting(string name) {
                  Console.WriteLine(”Morning, ” + name);
           }       

    暂且不管这两个方法有没有什么实际意义。GreetPeople用于向某人问好,当我们传递代表某人姓名的name参数,比如说“Jimmy”,进去的时候,在这个方法中,将调用EnglishGreeting方法,再次传递name参数,EnglishGreeting则用于向屏幕输出 “Morning, Jimmy” 

    现在假设这个程序需要进行全球化,哎呀,不好了,我是人,我不明白“Morning”是什么意思,怎么办呢?好吧,我们再加个中文版的问候方法:

    以下为引用的内容:
    public void ChineseGreeting(string name){
           Console.WriteLine(”
    早上好, ” + name);
    }
     

    这时候,GreetPeople也需要改一改了,不然如何判断到底用哪个版本的Greeting问候方法合适呢?在进行这个之前,我们最好再定义一个枚举作为判断的依据: 
    以下为引用的内容:
    public enum Language{
           English, Chinese
    }
    public void GreetPeople(string name, Language lang){
        
       //做某些额外的事情,比如初始化之类,此处略
           swith(lang){
                  case Language.English:
                         EnglishGreeting(name);
                         break; 
                  case Language.Chinese:
                         ChineseGreeting(name);
                         break;
                  }
    }
     

    OK,尽管这样解决了问题,但我不说大家也很容易想到,这个解决方案的可扩展性很差,如果日后我们需要再添加韩文版、日文版,就不得不反复修改枚举和GreetPeople()方法,以适应新的需求。

    在考虑新的解决方案之前,我们先看看 GreetPeople的方法签名:
    public void GreetPeople(string name, Language lang) 

    我们仅看 string name,在这里,string 是参数类型,name 是参数变量,当我们赋给name字符串“jimmy”时,它就代表“jimmy”这个值;当我们赋给它张子阳时,它又代表着张子阳这个值。然后,我们可以在方法体内对这个name进行其他操作。哎,这简直是废话么,刚学程序就知道了。 Www~

    如果你再仔细想想,假如GreetPeople()方法可以接受一个参数变量,这个变量可以代表另一个方法,当我们给这个变量赋值 EnglishGreeting的时候,它代表着 EnglsihGreeting() 这个方法;当我们给它赋值ChineseGreeting 的时候,它又代表着ChineseGreeting()方法。我们将这个参数变量命名为 MakeGreeting,那么不是可以如同给name赋值时一样,在调用 GreetPeople()方法的时候,给这个MakeGreeting 参数也赋上值么(ChineseGreeting或者EnglsihGreeting)?然后,我们在方法体内,也可以像使用别的参数一样使用MakeGreeting。但是,由于MakeGreeting代表着一个方法,它的使用方式应该和它被赋的方法(比如ChineseGreeting)是一样的,比如: 

    MakeGreeting(name);

    好了,有了思路了,我们现在就来改改GreetPeople()方法,那么它应该是这个样子了:
    以下为引用的内容:
    public void GreetPeople(string name, *** MakeGreeting){
           MakeGreeting(name);
    }

    注意到 *** ,这个位置通常放置的应该是参数的类型,但到目前为止,我们仅仅是想到应该有个可以代表方法的参数,并按这个思路去改写GreetPeople方法,现在就出现了一个大问题:这个代表着方法的MakeGreeting参数应该是什么类型的? 

    NOTE:这里已不再需要枚举了,因为在给MakeGreeting赋值的时候动态地决定使用哪个方法,是ChineseGreeting还是 EnglishGreeting,而在这个两个方法内部,已经对使用“morning”还是早上好作了区分。 

    聪明的你应该已经想到了,现在是委托该出场的时候了,但讲述委托之前,我们再看看MakeGreeting参数所能代表的 ChineseGreeting()EnglishGreeting()方法的签名:
    public void EnglishGreeting(string name)
    public void ChineseGreeting(string name)

    如同name可以接受String类型的“true”“1”,但不能接受bool类型的trueint类型的1一样。MakeGreeting 参数类型定义 应该能够确定 MakeGreeting可以代表的 方法种类,再进一步讲,就是MakeGreeting可以代表的方法 参数类型和祷乩嘈汀?br /> 于是,委托出现了:它定义了MakeGreeting参数所能代表的方法的种类,也就是MakeGreeting参数的类型。
    NOTE:如果上面这句话比较绕口,我把它翻译成这样:string 定义了name参数所能代表的值的种类,也就是name参数的类型。 

    本例中委托的定义:

    public delegate void GreetingDelegate(string name);
    可以与上面EnglishGreeting()方法的签名对比一下,除了加入了delegate关键字以外,其余的是不是完全一样? 

    现在,让我们再次改动GreetPeople()方法,如下所示:

    以下为引用的内容:
    public void GreetPeople(string name, GreetingDelegate MakeGreeting){
           MakeGreeting(name);
    }

    如你所见,委托GreetingDelegate出现的位置与 string相同,string是一个类型,那么GreetingDelegate应该也是一个类型,或者叫类(Class)。但是委托的声明方式和类却完全不同,这是怎么一回事?实际上,委托在编译的时候确实会编译成类。因为Delegate是一个类,所以在任何可以声明类的地方都可以声明委托。更多的内容将在下面讲述,现在,请看看这个范例的完整代码:

    以下为引用的内容:
    using System;
    using System.Collections.Generic;
    using System.Text;
    namespace Delegate {
          
    //定义委托,它定义了可以代表的方法的类型
           public delegate void GreetingDelegate(string name);

           class Program {
                  private static void EnglishGreeting(string name) {
                         Console.WriteLine(”Morning, ” + name);
                  }

                  private static void ChineseGreeting(string name) {
                         Console.WriteLine(”
    早上好, ” + name);
                  } 

                  //注意此方法,它接受一个GreetingDelegate类型的方法作为参数
                  private static void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                         MakeGreeting(name);
                  }

                  static void Main(string[] args) {
                         GreetPeople(”Jimmy Zhang”, EnglishGreeting);
                         GreetPeople(”
    张子阳”, ChineseGreeting);
                         Console.ReadKey();

                  }
           }
    }

    输出如下:

    Morning, Jimmy Zhang 

    早上好, 张子阳

    我们现在对委托做一个总结: 

    委托是一个类,它定义了方法的类型,使得可以将方法当作另一个方法的参数来进行传递,这种将方法动态地赋给参数的做法,可以避免在程序中大量使用If-Else(Switch)语句,同时使得程序具有更好的可扩展性,将方法绑定到委托 看到这里,是不是有那么点如梦初醒的感觉?于是,你是不是在想:在上面的例子中,我不一定要直接在GreetPeople()方法中给 name参数赋值,我可以像这样使用变量: 

    以下为引用的内容:
    static void Main(string[] args) {
           string name1, name2;
           name1 = “Jimmy Zhang”;
           name2 = “
    张子阳”;

           GreetPeople(name1, EnglishGreeting);
           GreetPeople(name2, ChineseGreeting);
           Console.ReadKey();
    }

    而既然委托GreetingDelegate 类型 string 的地位一样,都是定义了一种参数类型,那么,我是不是也可以这么使用委托?
    以下为引用的内容:
    static void Main(string[] args) {
           GreetingDelegate delegate1, delegate2;
           delegate1 = EnglishGreeting;
           delegate2 = ChineseGreeting;
           GreetPeople(”Jimmy Zhang”, delegate1);
           GreetPeople(”
    张子阳”, delegate2);
           Console.ReadKey();
    }

    如你所料,这样是没有问题的,程序一如预料的那样输出。这里,我想说的是委托不同于string的一个特性:可以将多个方法赋给同一个委托,或者叫将多个方法绑定到同一个委托,当调用这个委托的时候,将依次调用其所绑定的方法。在这个例子中,语法如下: 

    以下为引用的内容:
    static void Main(string[] args) {
           GreetingDelegate delegate1;
           delegate1 = EnglishGreeting;     //
    先给委托类型的变量赋值
           delegate1 += ChineseGreeting;     // 给此委托变量再绑定一个方法 

           // 将先后调用 EnglishGreeting ChineseGreeting 方法
           GreetPeople(”Jimmy Zhang”, delegate1);      
           Console.ReadKey();
    }

    输出为:
    Morning, Jimmy Zhang 

    早上好, Jimmy Zhang

    实际上,我们可以也可以绕过GreetPeople方法,通过委托来直接调用EnglishGreetingChineseGreeting

    以下为引用的内容:
    static void Main(string[] args) {
           GreetingDelegate delegate1;
           delegate1 = EnglishGreeting;     //
    先给委托类型的变量赋值
           delegate1 += ChineseGreeting;     // 给此委托变量再绑定一个方法 

           // 将先后调用 EnglishGreeting ChineseGreeting 方法
           delegate1 (”Jimmy Zhang”);      
           Console.ReadKey();
    }
    NOTE
    :这在本例中是没有问题的,但回头看下上面GreetPeople()的定义,在它之中可以做一些对于EnglshihGreetingChineseGreeting来说都需要进行的工作,为了简便我做了省略。

    Www~
    注意这里,第一次用的“=”,是赋值的语法;第二次,用的是“+=”,是绑定的语法。如果第一次就使用“+=”,将出现使用了未赋值的局部变量的编译错误。
    我们也可以使用下面的代码来这样简化这一过程: 

    GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);

    delegate1 += ChineseGreeting;       // 给此委托变量再绑定一个方法 @com

    看到这里,应该注意到,这段代码第一条语句与实例化一个类是何其的相似,你不禁想到:上面第一次绑定委托时不可以使用“+=”的编译错误,或许可以用这样的方法来避免:

    GreetingDelegate delegate1 = new GreetingDelegate(); 

    delegate1 += EnglishGreeting;       // 这次用的是 “+=”,绑定语法。

    delegate1 += ChineseGreeting;       // 给此委托变量再绑定一个方法 

    但实际上,这样会出现编译错误: “GreetingDelegate”方法没有采用“0”个参数的重载。尽管这样的结果让我们觉得有点沮丧,但是编译的提示:没有0个参数的重载再次让我们联想到了类的构造函数。我知道你一定按捺不住想探个究竟,但再此之前,我们需要先把基础知识和应用介绍完。 

    既然给委托可以绑定一个方法,那么也应该有办法取消对方法的绑定,很容易想到,这个语法是“-=”

    以下为引用的内容:
    static void Main(string[] args) {
           GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
           delegate1 += ChineseGreeting;    //
    给此委托变量再绑定一个方法
           // 将先后调用 EnglishGreeting ChineseGreeting 方法
           GreetPeople(”Jimmy Zhang”, delegate1);      
           Console.WriteLine(); 

           delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
           // 将仅调用 ChineseGreeting
           GreetPeople(”
    张子阳”, delegate1);      
           Console.ReadKey();
    }

    输出为:

    Morning, Jimmy Zhang 

    早上好, Jimmy Zhang Www_

    早上好, 张子阳 

    让我们再次对委托作个总结: 

    使用委托可以将多个方法绑定到同一个委托变量,当调用此变量时(这里用调用这个词,是因为此变量代表一个方法),可以依次调用所有绑定的方法。 

    事件的由来 

    我们继续思考上面的程序:上面的三个方法都定义在Programe类中,这样做是为了理解的方便,实际应用中,通常都是 GreetPeople 在一个类中,ChineseGreeting EnglishGreeting 在另外的类中。现在你已经对委托有了初步了解,是时候对上面的例子做个改进了。假设我们将GreetingPeople()放在一个叫GreetingManager的类中,那么新程序应该是这个样子的:

    以下为引用的内容:
    namespace Delegate {
           //
    定义委托,它定义了可以代表的方法的类型
           public delegate void GreetingDelegate(string name);
          
           //
    新建的GreetingManager
           public class GreetingManager{
                  public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                         MakeGreeting(name); .
                  }
                  }
           class Program {
                  private static void EnglishGreeting(string name) {
                         Console.WriteLine(”Morning, ” + name);
                  } 

                  private static void ChineseGreeting(string name) {
                         Console.WriteLine(”
    早上好, ” + name);
                  } @com

                  static void Main(string[] args) {
                         // … …
                  }
           }
    }

    这个时候,如果要实现前面演示的输出效果,Main方法我想应该是这样的:

    以下为引用的内容:
    static void Main(string[] args) {
           GreetingManager gm = new  GreetingManager();
           gm.GreetPeople(”Jimmy Zhang”, EnglishGreeting);
           gm.GreetPeople(”
    张子阳”, ChineseGreeting);
    }

    我们运行这段代码,嗯,没有任何问题。程序一如预料地那样输出了:
    Morning, Jimmy Zhang
    早上好, 张子阳

    现在,假设我们需要使用上一节学到的知识,将多个方法绑定到同一个委托变量,该如何做呢?让我们再次改写代码: 

    以下为引用的内容:

    static void Main(string[] args) {
           GreetingManager gm = new  GreetingManager();
           GreetingDelegate delegate1;
           delegate1 = EnglishGreeting;
           delegate1 += ChineseGreeting; 

           gm.GreetPeople(”Jimmy Zhang”, delegate1);
    }

    输出:

    Morning, Jimmy Zhang

    早上好, Jimmy Zhang
    到了这里,我们不禁想到:面向对象设计,讲究的是对象的封装,既然可以声明委托类型的变量(在上例中是delegate1),我们何不将这个变量封装到 GreetManager类中?在这个类的客户端中使用不是更方便么?于是,我们改写GreetManager类,像这样:

    以下为引用的内容:
    public class GreetingManager{
    //
    GreetingManager类的内部声明delegate1变量
           public GreetingDelegate delegate1;      
    public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                         MakeGreeting(name);
           }
    }

    现在,我们可以这样使用这个委托变量: 
    以下为引用的内容:
    static void Main(string[] args) {
           GreetingManager gm = new  GreetingManager();
           gm.delegate1 = EnglishGreeting;
           gm.delegate1 += ChineseGreeting;
           gm.GreetPeople(”Jimmy Zhang”, gm.delegate1);

    尽管这样达到了我们要的效果,但是似乎并不美气,光是第一个方法注册用“=”,第二个用“+=”就让人觉得别扭。此时,轮到Event出场了,C# 中可以使用事件来专门完成这项工作,我们改写GreetingManager类,它变成了这个样子: 
    以下为引用的内容:
    public class GreetingManager{
           //
    这一次我们在这里声明一个事件
           public event GreetingDelegate MakeGreet;
    public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                  MakeGreeting(name);
           }

    很容易注意到:MakeGreet 事件的声明与之前委托变量delegate1的声明唯一的区别是多了一个event关键字。看到这里,你差不多明白到:事件其实没什么不好理解的,声明一个事件不过类似于声明一个委托类型的变量而已。 

    我们想当然地改写Main方法: 
    以下为引用的内容:
    static void Main(string[] args) {
           GreetingManager gm = new  GreetingManager();
           gm.MakeGreet = EnglishGreeting; //
    编译错误1
           gm.MakeGreet += ChineseGreeting;
           gm.GreetPeople(”Jimmy Zhang”, gm.MakeGreet); //
    编译错误2
    }

    这次,你会得到编译错误:事件“Delegate.GreetingManager.MakeGreet”只能出现在 += -= 的左边(从类型“Delegate.GreetingManager”中使用时除外) 

    事件和委托的编译代码

    这时候,我们不得不注释掉编译错误的行,然后重新进行编译,再借助Reflactor来对 event的声明语句做一探究,看看为什么会发生这样的错误:
    public event GreetingDelegate MakeGreet; 
    可以看到,实际上尽管我们在GreetingManager里将 MakeGreet 声明为public,但是,实际上MakeGreet会被编译成 私有字段,难怪会发生上面的编译错误了,因为它根本就不允许在GreetingManager类的外面以赋值的方式访问。
    我们进一步看下MakeGreet所产生的代码: 

    以下为引用的内容:

    private GreetingDelegate MakeGreet;       //对事件的声明 实际是 声明一个私有的委托变量

    [MethodImpl(MethodImplOptions.Synchronized)]
    public void add_MakeGreet(GreetingDelegate value){
        this.MakeGreet = (GreetingDelegate) Delegate.Combine(this.MakeGreet, value);

    [MethodImpl(MethodImplOptions.Synchronized)]
    public void remove_MakeGreet(GreetingDelegate value){
        this.MakeGreet = (GreetingDelegate) Delegate.Remove(this.MakeGreet, value);

    现在已经很明确了:MakeGreet 事件确实是一个GreetingDelegate类型的委托,只不过不管是不是声明为public,它总是被声明为private。另外,它还有两个方法,分别是add_MakeGreetremove_MakeGreet,这两个方法分别用于注册委托类型的方法和取消注册,实际上也就是: “+= ”对应 add_MakeGreet“-=”对应remove_MakeGreet。而这两个方法的访问限制取决于声明事件时的访问限制符。 

    add_MakeGreet()方法内部,实际上调用了System.DelegateCombine()静态方法,这个方法用于将当前的变量添加到委托链表中。我们前面提到过两次,说委托实际上是一个类,在我们定义委托的时候:
    public delegate void GreetingDelegate(string name); 

    当编译器遇到这段代码的时候,会生成下面这样一个完整的类:

    以下为引用的内容:

    public class GreetingDelegate:System.MulticastDelegate{

           public GreetingDelegate(object @object, IntPtr method);
           public virtual IAsyncResult BeginInvoke(string name, AsyncCallback callback, object @object);
           public virtual void EndInvoke(IAsyncResult result);
           public virtual void Invoke(string name);
    }

    关于这个类的更深入内容,可以参阅《CLR Via C#》等相关书籍,这里就不再讨论了。

    委托、事件与Observer设计模式
    范例说明
    上面的例子已不足以再进行下面的讲解了,我们来看一个新的范例,因为之前已经介绍了很多的内容,所以本节的进度会稍微快一些:
    假设我们有个高档的热水器,我们给它通上电,当水温超过95度的时候:1、扬声器会开始发出语音,告诉你水的温度;2、液晶屏也会改变水温的显示,来提示水已经快烧开了。

    现在我们需要写个程序来模拟这个烧水的过程,我们将定义一个类来代表热水器,我们管它叫:Heater,它有代表水温的字段,叫做temperature;当然,还有必不可少的给水加热方法BoilWater(),一个发出语音警报的方法MakeAlert(),一个显示水温的方法,ShowMsg()
    以下为引用的内容:
    namespace Delegate {
           class Heater {
                  private int temperature;
    // 水温
                  // 烧水
                  public void BoilWater() {
                         for (int i = 0; i <= 100; i++) {
                                temperature = i;

                                if (temperature > 95) {
                                       MakeAlert(temperature);
                                       ShowMsg(temperature);
                                }
                         }
                  }
                 
    // 发出语音警报
                  private void MakeAlert(int param) {
                         Console.WriteLine(”Alarm
    :嘀嘀嘀,水已经 {0} 度了:” , param);
                  }
         
             // 显示水温
                  private void ShowMsg(int param) {
                         Console.WriteLine(”Display
    :水快开了,当前温度:{0}度。” , param);
                  }

           } 

           class Program {
                  static void Main() {
                         Heater ht = new Heater();
                         ht.BoilWater();
                  }
           }

    Observer设计模式简介

    上面的例子显然能完成我们之前描述的工作,但是却并不够好。现在假设热水器由三部分组成:热水器、警报器、显示器,它们来自于不同厂商并进行了组装。那么,应该是热水器仅仅负责烧水,它不能发出警报也不能显示水温;在水烧开时由警报器发出警报、显示器显示提示和水温。

    这时候,上面的例子就应该变成这个样子:

    以下为引用的内容:

    // 热水器
    public class Heater {      
                  private int temperature;
                  //
    烧水
                  private void BoilWater() {
                         for (int i = 0; i <= 100; i++) { 
                                temperature = i;
                         }
                  }
           } 

           // 警报器
           public class Alarm{
                  private void MakeAlert(int param) {
                         Console.WriteLine(”Alarm
    :嘀嘀嘀,水已经 {0} 度了:” , param);
                  }
           } 

           // 显示器
           public class Display{
                  private void ShowMsg(int param) {
                         Console.WriteLine(”Display
    :水已烧开,当前温度:{0}度。” , param);
                  }

     
    这里就出现了一个问题:如何在水烧开的时候通知报警器和显示器?在继续进行之前,我们先了解一下Observer设计模式,Observer设计模式中主要包括如下两类对象:
    Subject:监视对象,它往往包含着其他对象所感兴趣的内容。在本范例中,热水器就是一个监视对象,它包含的其他对象所感兴趣的内容,就是temprature字段,当这个字段的值快到100时,会不断把数据发给监视它的对象。 

    Observer:监视者,它监视Subject,当Subject中的某件事发生的时候,会告知Observer,而Observer则会采取相应的行动。在本范例中,Observer有警报器和显示器,它们采取的行动分别是发出警报和显示水温。
    在本例中,事情发生的顺序应该是这样的:

    警报器和显示器告诉热水器,它对它的温度比较感兴趣(注册)

    热水器知道后保留对警报器和显示器的引用。 

    热水器进行烧水这一动作,当水温超过95度时,通过对警报器和显示器的引用,自动调用警报器的MakeAlert()方法、显示器的ShowMsg()方法。
    类似这样的例子是很多的,GOF对它进行了抽象,称为Observer设计模式:Observer设计模式是为了定义对象间的一种一对多的依赖关系,以便于当一个对象的状态改变时,其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。

    实现范例的Observer设计模式 

    我们之前已经对委托和事件介绍很多了,现在写代码应该很容易了,现在在这里直接给出代码,并在注释中加以说明。
    以下为引用的内容:
    using System;
    using System.Collections.Generic;
    using System.Text;
    namespace Delegate {
         
      // 热水器
           public class Heater {
                  private int temperature;
                  public delegate void BoilHandler(int param);      
    //声明委托
                  public event BoilHandler BoilEvent;                     //声明事件 

                  // 烧水
                  public void BoilWater() {
                         for (int i = 0; i <= 100; i++) {
                                temperature = i;
                                if (temperature > 95) {
                                       if (BoilEvent != null) {    
       //如果有对象注册
                                              BoilEvent(temperature);       //调用所有注册对象的方法
                                       } 
                                }
                         }
                  }
           }
          
    // 警报器
           public class Alarm {
                  public void MakeAlert(int param) {
                         Console.WriteLine(”Alarm
    :嘀嘀嘀,水已经 {0} 度了:”, param);
                  }
           }

           // 显示器
           public class Display {
                  public static void ShowMsg(int param) {       //
    静态方法
                         Console.WriteLine(”Display:水快烧开了,当前温度:{0}度。”, param);
                  }
           }
          
           class Program {
                  static void Main() {
                         Heater heater = new Heater();
                         Alarm alarm = new Alarm();

                         heater.BoilEvent += alarm.MakeAlert;       //注册方法
                         heater.BoilEvent += (new Alarm()).MakeAlert;       //给匿名对象注册方法
                         heater.BoilEvent += Display.ShowMsg;              //注册静态方法 .

                         heater.BoilWater();       //烧水,会自动调用注册过对象的方法
                  }
           }
    }

    输出为: 

    Alarm:嘀嘀嘀,水已经 96 度了:

    Alarm:嘀嘀嘀,水已经 96 度了: 

    Display:水快烧开了,当前温度:96度。
    // 省略… @com

    .Net Framework中的委托与事件 

    尽管上面的范例很好地完成了我们想要完成的工作,但是我们不仅疑惑:为什么.Net Framework 中的事件模型和上面的不同?为什么有很多的EventArgs参数? 

    在回答上面的问题之前,我们先搞懂 .Net Framework的编码规范: 

    委托类型的名称都应该以EventHandler结束。
    委托的原型定义:有一个void返回值,并接受两个输入参数:一个Object 类型,一个 EventArgs类型(或继承自EventArgs) 

    事件的命名为 委托去掉 EventHandler之后剩余的部分。 

    继承自EventArgs的类型应该以EventArgs结尾。
    再做一下说明:
    委托声明原型中的Object类型的参数代表了Subject,也就是监视对象,在本例中是 Heater(热水器)。回调函数(比如AlarmMakeAlert)可以通过它访问触发事件的对象(Heater)

    EventArgs 对象包含了Observer所感兴趣的数据,在本例中是temperature
    上面这些其实不仅仅是为了编码规范而已,这样也使得程序有更大的灵活性。比如说,如果我们不光想获得热水器的温度,还想在Observer(警报器或者显示器)方法中获得它的生产日期、型号、价格,那么委托和方法的声明都会变得很麻烦,而如果我们将热水器的引用传给警报器的方法,就可以在方法中直接访问热水器了。 

    现在我们改写之前的范例,让它符合 .Net Framework 的规范: 

    以下为引用的内容:

    using System;
    using System.Collections.Generic;
    using System.Text;

    namespace Delegate {
       
        // 热水器
           public class Heater {
                  private int temperature;
                  public string type = “RealFire 001″;              //
    添加型号作为演示
                  public string area = “China Xian”;                     // 添加产地作为演示
                  //声明委托
                  public delegate void BoiledEventHandler(Object sender, BoliedEventArgs e);
                  public event BoiledEventHandler Boiled;    
       //声明事件 

                  // 定义BoliedEventArgs类,传递给Observer所感兴趣的信息
                  public class BoliedEventArgs : EventArgs {
                         public readonly int temperature;
                         public BoliedEventArgs(int temperature) {
                                this.temperature = temperature;
                         }
                  } 

                  // 可以供继承自 Heater 的类重写,以便继承类拒绝其他对象对它的监视
                  protected virtual void OnBolied(BoliedEventArgs e) {
                         if (Boiled != null) {      
    // 如果有对象注册
                                Boiled(this, e);       // 调用所有注册对象的方法
                         }
                  }
             
         // 烧水。
                  public void BoilWater() {
                         for (int i = 0; i <= 100; i++) {
                                temperature = i;
                                if (temperature > 95) {
                                    
       //建立BoliedEventArgs 对象。
                                       BoliedEventArgs e = new BoliedEventArgs(temperature); .
                                       OnBolied(e);     
      // 调用 OnBolied方法
                                }
                         }
                  }
           }

           // 警报器
           public class Alarm {
                  public void MakeAlert(Object sender, Heater.BoliedEventArgs e) {
                         Heater heater = (Heater)sender;             
    //这里是不是很熟悉呢?
                         //访问 sender 中的公共字段
                         Console.WriteLine(”Alarm{0} - {1}: “, heater.area, heater.type);
                         Console.WriteLine(”Alarm:
    嘀嘀嘀,水已经 {0} 度了:”, e.temperature); 
                         Console.WriteLine();
                  } 

           }
         
      // 显示器
           public class Display {
                  public static void ShowMsg(Object sender, Heater.BoliedEventArgs e) {       /
    /静态方法
                         Heater heater = (Heater)sender;
                         Console.WriteLine(”Display
    {0} - {1}: “, heater.area, heater.type);
                         Console.WriteLine(”Display
    :水快烧开了,当前温度:{0}度。”, e.temperature);
                         Console.WriteLine();
                  }
           }

           class Program {
                  static void Main() {
                         Heater heater = new Heater();
                         Alarm alarm = new Alarm();

                         heater.Boiled += alarm.MakeAlert;       //注册方法
                         heater.Boiled += (new Alarm()).MakeAlert;              //给匿名对象注册方法
                         heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert);       //也可以这么注册
                         heater.Boiled += Display.ShowMsg;              //注册静态方法 

                         heater.BoilWater();       //烧水,会自动调用注册过对象的方法
                  }
           }
    }

    输出为:

    以下为引用的内容:
    AlarmChina Xian - RealFire 001:
    Alarm:
    嘀嘀嘀,水已经 96 度了:
    AlarmChina Xian - RealFire 001:
    Alarm:
    嘀嘀嘀,水已经 96 度了:
    AlarmChina Xian - RealFire 001:
    Alarm:
    嘀嘀嘀,水已经 96 度了:
    DisplayChina Xian - RealFire 001:
    Display
    :水快烧开了,当前温度:96度。
    // 省略
    总结 

    在本文中我首先通过一个GreetingPeople的小程序向大家介绍了委托的概念、委托用来做什么,随后又引出了事件,接着对委托与事件所产生的中间代码做了粗略的讲述。 

    在第二个稍微复杂点的热水器的范例中,我向大家简要介绍了 Observer设计模式,并通过实现这个范例完成了该模式,随后讲述了.Net Framework中委托、事件的实现方式。

    展开全文
  • 在基于对象的编程中,经常会出现类、对象、属性、方法和事件概念,然后这么概念之间是有联系和区别的,弄清楚它们之间的不同是学好编程的第一步,但熟悉它们之后,这样我们更容易去理解基于对象的编程。...


    在基于对象的编程中,经常会出现类、对象、属性、方法和事件的概念,然后这么概念之间是有联系和区别的,弄清楚它们之间的不同是学好编程的第一步,但熟悉它们之后,这样我们更容易去理解基于对象的编程。

    类和对象

        类是将数据及数据上的操作封装在一起。

        对象是包含变量和函数的集合实例。

        它们的关系:类是对象的抽象,对象是类的具体实例。类是抽象的,不占有内存,而对象是具体的,占有存储空间。

    类类型的声明形式:

    Class student ——类名

    {

     Public:......;

     Private:....;

    }

    定义对象的方法:

    Class student

    {

     Public:......;

     Private:....;

    }stud1,stud2;——对象名

    对象的属性、方法和事件

    对象所含的变量就是对象的变量。

    对象对属性进行的操作的函数就是对象的方法。

    用户对网页上的对象的操作就是事件。

    三者关系:把属性看做对象的性质;把方法看成对象的动作;把事件看做对象的响应。

    其中方法和事件不易理解,个人理解就是:

    事件,是被外在条件激活的,是被动的;而方法,却是主动的。

    事件,中要写代码;方法,系统自己定义代码。

    事件是对象的响应,当要求响应时候,执行命令,可能包括属性和动作等。

     

    以上就是它们的基本含义了,可能还是有点模糊,可以举一个例子,大家都明白了。比如:气球它是一个类,街上卖的那种给小孩玩的那个气球叫氢气球,它就是一个对象。氢气球有自己的属性,它的直径和颜色和是否充气等。氢气球也有自己的方法,比如充气方法、放气方法和升空方法等;氢气球还有事件的响应,比如对用针刺破它的响应就是放气,对手松开的响应就是升空。

    展开全文
  • 在面向对象程序设计中,设计了对象、类、封装、继承、消息传递和多态等基本概念,下面就分别来谈谈这些概念对象(object):好比一个人,有多种属性:姓名、性别、年龄、体重等,都有多种行为:吃饭、走路等,...
  • 五JavaScript事件对象 目标: 应掌握以下内容 理解事件驱动机制 会使用常用的事件触发机制如ClickOnChange等事件 关键知识点 会使用常用的事件触发机制如ClickOnChange等事件 常用对象处理语句thisforinwith和new ...
  • 面向对象程序设计的基本概念

    千次阅读 多人点赞 2021-01-31 17:03:44
    (1) 对象对象类   对象是代码和数据的组合,可以作为一个单位来处理。对象可以是应用程序的一部分,比如可以是控件或窗体。整个应用程序也是一个对象。   VB中的每个对象都是用类定义的。用饼干模子和饼干之间...
  • Java程序设计(面向对象)- 基本概念

    万次阅读 多人点赞 2019-05-25 20:10:06
    所谓对象就是真实世界中的实体,对象与实体是一一对应的,也就是说现实世界中每一个实体都是一个对象,它是一种具体的概念。 定义:以基于对象的思维去分析和解决问题,万物皆对象 对象有以下特点: 对象具有...
  • js中事件对象event

    万次阅读 多人点赞 2018-03-06 16:40:10
    当一个事件发生的时候,和当前这个对象发生的这个事件有关的一些详细信息(包括导致事件的元素、事件的类型、以及其它与特定事件相关的信息等。这个对象是在执行事件时,浏览器通过函数传递过来的。)都会被临时保存...
  • web前端:vue事件获取当前对象

    千次阅读 2020-12-29 04:15:59
    对象,是编程术语,其广义指的是在内存上一段有意义的区域,称作为一个对象。在C中,具有特定长度的类型,可以称作为对象类型,函数不具有特定长度,所以不是对象类型。一.事件传参如点击事件.........methods:{...
  • C#委托和事件概念

    千次阅读 2018-10-10 14:26:41
    一、事件的本质 事件是软件系统里的两个子...两个对象之间发送的这种消息,对发送方来讲是产生一个事件,对接受方来讲是需要处理某个事件。这种消息可以是用户操作产生的或者软件系统里的某个对象产生的。  ...
  • UML(二)——面向对象的基本概念

    千次阅读 2015-08-31 10:52:59
    1、对象的基本特征 每个对象都有自己的唯一标识。对象之间通过消息进行通信。对象总是处于一定的状态。对象有若干种行为,分为三类:创建新对象,与其他对象通信,改变自身状态。对象的状态只能被自身的行为所...
  • VB对象及其属性、事件和方法

    千次阅读 2020-09-15 12:41:57
    在学习控件之前,我们有必要先来熟悉对象概念,以及对象的属性、事件和方法都需要有所了解。 对象: 不论是窗体还是控件,它们都属于对象对象,是基于对现实世界的描述,对象是类的实例化,类是抽象的概念,而...
  • 领域模型和领域对象概念

    万次阅读 2016-08-18 13:52:30
    又称概念模型、领域对象模型、分析对象模型。它专注于分析问题领域本身,发掘重要的业务领域概念,并建立业务领域概念之间的关系。    面向领域对象设计的原则简单的说就是起名字定职能,对象定领域,找关系做关联...
  • 面向对象程序设计(OOP)的基本概念

    千次阅读 热门讨论 2019-03-01 19:36:59
    面向对象程序设计(OOP)的基本概念 1.&nbsp;&nbsp; 面向对象程序设计 &nbsp; 是以对象为基础 以事件驱动对对象事件进行处理的程序设计技术 一个应用程序设计可以分为相互关联的多个对象,并建立与...
  • 面向对象设计与事件

    千次阅读 2014-02-26 17:02:52
    面向对象的设计给编程带来很大的便利和好处,在贯彻这种原则的语言中把类作为代码单元似乎也是自然的事情。但是实践中,剥夺了过程的独立生存权有时又会让代码失去过去的灵活和便捷。对事件的编程就是这样的场合。...
  • VB中的对象,属性,事件,方法

    千次阅读 2019-01-08 11:47:47
    对象: 将数据和处理该数据的过程(函数和子程序)打包在一起而生成的新...所有的对象都具有自己的特征,称为属性:外界对对象的刺激能引起对象的响应,这种刺激称为事件:各种对象具有特定的功能,称为方法。 ...
  • JavaScript中的Event事件对象详解

    万次阅读 多人点赞 2016-10-07 17:36:10
    在JavaScript中对于事件来讲,首先,我们需要了解这样几个概念事件事件类型、事件绑定、事件监听、事件处理程序(事件侦听器)、事件对象(事件源)、事件流、事件冒泡、事件捕获、事件性能优化(事件委托[事件代理]...
  • 互斥对象事件对象、关键代码段的应用和比较  线程同步的方式主要有三种:互斥对象事件对象和关键代码段。 一. 互斥对象  互斥对象(mutex)属于内核对象,它能够确保线程拥有对单个资源的互斥访问权...
  • js-面向对象概念

    千次阅读 2016-10-20 20:22:19
    什么是对象
  • 第四讲:面向对象程序设计方法及类、对象概念  掌握:面向对象程序设计的方法及特点;类的声明的对象的定义理解:对象的封装、抽象、继承与多态性四个特快性的概念;类和对象的作用;面向对象和面向过程的程序...
  • 对象:是一个自包含的实体,用一组可识别的特征和行为来标识。
  • JS事件事件对象事件

    万次阅读 2015-05-11 23:14:18
    要想搞明白js的事件机制,必须搞清楚几个概念事件对象事件源,还有事件事件对象: 当事件发生时会产生事件对象事件对象的作用是用来记录“事件发生是一些相关的信息。注意事件对象只有在事件发生时才会产生...
  • 事件抽取及方法 参考:读书笔记:关系抽取和事件抽取 关系抽取 定义:自动识别实体之间具有的某种语义关系。根据参与实体的多少可以分为二元关系抽取(两个实体)和多元关系抽取(三个及以上实体)。 通过关注两...
  • 要想搞明白js的事件机制,必须搞清楚几个概念事件对象事件源,还有事件事件对象: 当事件发生时会产生事件对象事件对象的作用是用来记录“事件发生是一些相关的信息。注意事件对象只有在事件发生时才会...
  • 软考(软件设计师)考点总结 -- 面向对象设计基础

    千次阅读 多人点赞 2021-05-21 17:31:21
    软考软件设计师考点总结 -- 面向对象基础:面向对象基本概念、面向对象的特性、分析、设计原则、设计模式:创建型模式、结构型模式、行为型模式、UML基本概念、UML模型。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 342,132
精华内容 136,852
关键字:

对象事件的概念