关闭

黑马程序员_面向对象

337人阅读 评论(0) 收藏 举报

------- android培训java培训、期待与您交流! ----------

一   面向对象的理解

1、面向对象:就是将功能封装起来,强调的是具备了功能的对象。

       面向过程:强调的是功能的行为。

       所以说:面向对象是基于面向过程的。

       面向对象的三大特征:封装性、继承、多态。

       开发其实就是找对象、建立对象、适用对象和维护对象。

2、类和对象的关系

      类:对现实生活中事物的描述;(类中有成员变量和成员函数)

      对象:现实生活中事物的具体个体。

3、成员变量和局部变量

   (1)作用域不同

      成员变量作用于整个类中;局部变量作用于函数中。

    (2)在内存中的位置不同

      成员变量存在于堆内存中,只有对象建立时才能在内存中存在;局部变量则是存在于栈内存中。

4、匿名对象

      (1)匿名对象是对象的简写形式

                 对象: Person p=new Person();

                           p.name=chy;                                         

                       匿名对象: new Person().name=chy;

        (2)匿名对象的使用

               当对象的方法只被调用一次时,可以使用匿名对象,这样写比较简单;

               可以将匿名对象作为实际参数进行传递;

5、封装

         (1)定义:隐藏对象的属性和实现细节,仅对外提供公共的访问方式。

         (2)好处:将变化隔离;便于使用;提高复用性;提高安全性。

          (3)private:私有,权限修饰符,用于修饰类中的成员,只有在本类中有效。

            注意:私有仅仅只是封装的一种表现形式。

6、构造函数

            (1)特点:函数名和类名相同;没有返回值;

            (2)作用:对象一建立就会调用构造函数,所以构造函数可以用来进行对对象初始化。

            (3)和一般函数的区别

                和一般函数的写法不同;

                和一般函数的运行不同,构造函数在对象建立时就会运行,一般函数则是被对象调用时才能运行;

                一个对象的建立构造函数只运行一次,而一般函数则可以被多次调用;

             注意:

            

            上段程序中的构造函数和设置函数的区别:它俩的功能不相同,虽然都可以给对象赋值,但构造函数所赋的值不能改变,而设置函数可以随时改变。

            (4)什么时候定义构造函数:事物一存在就具备一些属性。

            (5)构造代码块

              作用:给对象进行初始化,给所有对象一起进行初始化。(运行时比构造函数先运行)

7、this关键字

             (1)区别局部变量和成员变量。

             (2)特点:this代表的是所在函数所属对象的引用

             (3)应用:当定义类中的功能时,该函数内部要调用到该函数的对象时,这时用this表示这个功能。

             (4)this语句(this())用于构造函数之间的调用。(this语句只能放在构造函数的第一行)  

8、static关键字

             (1)用法:static是一个修饰符,用来修饰成员(成员函数和成员变量)。

             (2)static的特点:随着类的加载而加载,同时也会随着类的消失而消失(生命周期最长);静态成员比对象先存在于内存  中;静态成员可以被所有对象共享;静态成员可以被类名直接调用。(注意:静态成员变量也叫做类变量,非静态变量也称为实例变量)

             (3)静态变量和非静态变量的区别

                存放位置不同:静态变量存放在方法区;非静态变量存在于堆内存中。

                生命周期不同:静态变量随着类的消失而消失;非静态变量随着对象的消失而消失

             (4)静态使用的注意事项:静态方法只能调用静态成员,不能调用非静态成员;而非静态方法都可以调用。静态方法中不可以定义this,super关键字(因为静态是先于对象而存在的)。

             (5)Person p=new Person (haha ,45)运行的过程:

                   因为new用到了Person.class,所以会先调用此文件并加载到内存中;

                   执行该类中的静态代码块;(用来给类进行初始化)

                   在堆内存中开辟空间,分配内存地址;

                   在堆内存中建立对向特有的属性,并进行默认初始化;

                  对对象进行显示初始化;(成员变量上的赋值)

                  对对象进行构造代码块初始化;

                  对对象进行对应构造函数初始化;

                  将对内存中的地址值给内村中的p变量。

9、main

             (1)main是一个特殊的主函数,可以作为程序的入口,被jvm调用。

             (2)public static void main(String[] args)的意义

                  public:代表的是该函数的访问权限是最大的;

                  static: 代表着主函数随着类的加载就已经存在了;

                  void:   主函数没有具体的返回值;

               (String[] args):函数的参数,参数的类型是一个字符串类型的数组。相当于new String[]  

10、单例设计模式

            (1)定义:解决一个类中只有一个对象的方法。

            (2)怎样保证对象的唯一?

               为了避免其他程序多次建立该类的对象,禁止其他程序建立该类的对象;(私有化构造函数)

               同时为了让其他程序访问到该类的对象,可以在类中建立自己的对象;

               对外提供访问该对象的访问方法;

              下面是单例设计的两种方法饿汉式和懒汉式:

              饿汉式:

                  

                懒汉式;

             

             这两种设计的区别:饿汉式是类一加载就会建立对象,而懒汉式则是在调用getInstance()方法是才建立对象,因此懒汉式又叫作延迟加载。

二  类的继成

1、继承的概述

          (1) 简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法的方式,产生一个新的类。继承是面向对象的三个基本特征--封装、继承、多态的其中之一。  

             (2)   继承 的好处 :提高了代码的复用性;让类和类之间产生了关系,有了这个关系,才有了多态的特性 。

             注意:java只支持但继承,不支持多继承(存在安全隐患,继承多个父类时,若是父类中有相同的方法,子类就不知道该继承谁。)但是java支持多层继承和多实现。

 2、继承中的构造函数

          (1)子类的所有构造函数,默认都会访问父类中的空参数构造函数。(子类的构造函数第一行都有一个super语句,隐藏了)

          (2)当父类中没有空参数的构造函数时,子类必须通过super或者this语句来指定要访问的构造函数。

3、final关键字

          (1)final是一个修饰符,表示最终的意思;就可以修饰类、函数和变量。

          (2)final修饰过的类不可以再被继承。(避免此类中功能主体被破坏)

          (3)final修饰过的方法不可以再被复写。

          (4)final修饰过的变量是一个常量。

4、抽象类

          (1)定义:当多个类中出现功能相同,但主体不同的方法时,只抽取类中的功能定义,而不抽取功能主体

          (2)特点:抽象方法一定在抽象类中;抽象方法和抽象类必须用abstract关键字修饰;抽象类不可以建立对象(空方法被调用没有意义);抽象类想建立对象必须让其子类复写其全部抽象方法。

5、模板方法设计模式

           定义:定义功能时,功能的一部分是确定的,一部分是不确定的,确定的要使用不确定的,所以要将不确定的给暴露出去,由该类的子类去完成。

6、接口(interface)

           (1)接口;可以理解为一个特殊的抽象类(接口中的方法都是抽象的)(类是用class表示;接口是用interface表示)

           (2)接口格式的特点:接口中常见的定义有方法和常量;

                     方法的格式:public abstract

                     常量的格式:public static final(记住:接口中的成员都是public,常量可以被对象,类名和接口名调用)

           (3)类extends类;类implements接口;接口extends接口

           (4)类可以多实现的原因在于接口中的方法都是抽象的(只有功能没有主体)。

三、多态性

1、多态的理解

          (1)定义:一种事物的多种表现形态(比如:一个对象既可以用它自己的类来引用,也可以用父类来引用)

          (2)多态的体现

            父类的引用指向子类的对象(例:原本: 子 z=new 子();现在:父 f=new 父();子是继承父的)

          (3)多态的前提

            必须是类与类(接口)之间有关系(继承或是实现);另外还有一个前提是必须覆盖其父类的方法。

          (4)多态的优点

           多态提高了代码的扩展性(看下面的代码)                        

             (5)多态的弊端:只能使用父类的引用去访问父类的成员。

            相应的解决办法:其实:父 f=new 父()这是一种类型转化,向上转型;相应的我们可以进行向下的强制转化(强制将父类的引用转化成子类的引用。其格式是 子 z=(子)f;)

         (6)多态的注意事项(多态成员的应用)

             多态成员函数(非静态):在编译时期:参阅的是引用型变量的类中(父类中)是否有调用方法,如果有则编译通过,反之失败。在运行时期:参阅的是对象所属的类型是否有方法调用。(编译看左边,运行看右边)

            多态成员变量:在编译和运行时期都看左边。(静态函数也相同)

            总结:根据静态的特性可以知道,静态函数是随着类的加载而存在的(不需要对象),所以在父类引用指向子类对象之前,父类的静态函数值已经确定了.

            小知识点:1.基本数据类型赋值用=;应用数据类型赋值用instanceof。

                                2.多态的出现不但简化了代码,而且使对象的调用变简单了。以前是指挥每一个对象做事情,现在是指挥一批对象做事情(将这些对象所属的共同类型向上提取)。

2、内部类

           (1)内部类定义:将一个类定义在另一个类里面,称里面类为内部类(内置类或嵌套类)

           (2)内部类的特点:可以直接访问外部类的成员(包括私有);而外部类访问内部类则必须建立内部类的对象。

                     直接访问内部类的格式:外部类名.内部类名  名称=new 外部类名().new 内部类名();

           (3)功能内部要调用某一变量时(此同名变量可能同时存在于方法中,内部类中或外部类中),有局部变量就取局部变量,若想访问内部的变量,则用this.变量名来调用;想访问外部的变量,则用外部类名.this.变量名。

           (4)内部类可以被直接调用的原因:内部类持有一个外部类的引用,格式是:外部类名.this。

           (5)内部类可以被static修饰,被static修饰过的内部类只能访问外部类的静态成员。内部类成员有静态成员时此内部类也为静态内部类。

           (6)访问内部类非静态成员格式:new  Outer.Inner().function()。

                     访问内部类静态成员格式: Outer.Inner.function()。

           (7)内部类定义在局部时:不可以被静态修饰(局部变量不可以被静态修饰);可以直接访问外部类中的成员,但不可以访问它所在局部中的变量(只可以访问被fianl修饰的局部变变量)。

3、异常

          (1)定义:程序在运行时出现不正常的情况。

          (2)异常的由来:问题也是现实生活中的一个具体的事物,可以通过java形式进行描述,并封装成对象。

          (3)异常分为两类:一类是严重的,用Error类进行描述,对于这类类java一般不编写针对性的代码进行描述;另一类是非严重的,用Exception来描述,对于这类类可以使用针对性的方式进行处理。Error和Exception有个父类Throwable。

         (4)异常的处理:try处理的格式:try{可能发生异常的代码}catch(异常类 变量){处理方式}finally{一定会执行的代码}。 throws处理方式 :在函数名上将此函数可能出现的异常类的类名抛给调用者,格式:函数名()throws 异常类名.

         (5)throws处理的好处:提高了代码的安全性,让调用者处理,调用者不处理则编译失败。

         (6)多异常的处理:一个函数可能出现多个异常,可以同时将几个异常同时抛出,这几个异常用逗号隔开(注:几个异常就有几个相对应的catch语句。多个异常之间存在继承关系时父类的catch语句要放在子类下面)

         (7)自定义异常类:有些异常是开发中特有的,这些类必须继承Exception类(原因就在于不是所有的类和对象都是可抛的,这是异常体系特有的。)  

         (8)throw和throws的区别:throw使用在函数内,throws使用在函数上;throw后面跟的是类对象,throws后面跟的是类名。

         (9)RuntimeException类

              特点:是一个特殊的Exception类,如果在函数内处理了异常,可以不在函数上声明,编译一样可一同过;对应的在函数上声明了,在函数内可以不进行处理。原因就在于当RuntimeException异常发生时,需要的是程序停止,以便对代码进行修正,而处理了,程序就不会停止,问题就会被隐藏。

         (10)finally:最后一定会执行的代码(通常用于关闭资源)

         (11)try、catch和finally的组合方式有三种:try和catch;try和finally;try,catch和finally。

         (12)异常中的覆盖:子类只能抛父类的异常或是父类的子异常,其他的异常只能try。

         (13)异常的运行过程:建立具有异常的类的对象时:在类中jvm会建立一个此异常的对象,将这个异常对象抛给try语句,若是在try中发现此异常(正常语句不会再执行),继续抛给catch语句,让catch来处理。若是没有发现异常就会执行正常语句。

 ------- android培训java培训、期待与您交流! ----------

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:3078次
    • 积分:128
    • 等级:
    • 排名:千里之外
    • 原创:10篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条