黑马程序员——面向对象

<a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>  

面向对象

Everything isobject.

类：生活中事物的描述。

对象：这类事物的实实在在的个体。

找对象、建对象、使用对象、维护对象

匿名对象：

(1)   作为实参传递

(2)   对象只调用一次

对象特征：封装、继承、多态

1、 封装

隐藏对象属性和实现细节，只对外提供公共访问方式。

(1)   private：

1)     权限修饰符，私有

2)     只在本类有效

3)     修饰类中成员

a、 成员变量：事物的属性

实例变量：在堆中

类变量：在方法区中

b、 成员函数：事物的行为

4)     是封装的表现形式

(2)   构造函数

权限修饰符 类名(参数或无)  {    }

1)     对象已建立就会运行与之相关的构造函数

2)     用于给对象初始化

3)     只运行一次

4)     系统会默认构建空参构造函数，但自定义后，就不会构建了

比较:

     一般方法：对象调用才运行、添加功能

                        可被对象调用多次

(3)   构造代码块

{执行语句}

1)     给所有对象初始化

2)     优先于构造函数加载

(4)   this

代表对象，所在函数所属对象的引用

应用：

1)     本类功能内部使用本类对象  this.

        如区分成员变量和局部变量同名

2)     构造函数间相互调用  this()

        只能定义在构造函数第一行

(5)   static

1)     修饰符，用于修饰成员(变量和函数)

2)     除了被对象调用，可直接被类名调用；类名.静态成员

3)     随类加载，优先于对象存在

4)     数据被所有对象共享

注意：静态方法只能访问静态变量，方法中不可定义this，super

(6)   单例设计模式

保证一个类在内存中的对象是唯一的

1)     饿汉式：

class Single1{   private Single1(){}   private static Single1 s=newSingle1();   public static Single1getInstance(){           return s;   }}

2)     懒汉式：

class Single2{   private Single2(){}   private static Single2 s;   public static Single2getInstance(){           if(s==null)                    s=newSingle2();           return s;   }}

2、 继承

优点：

1)     提高代码复用性

2)     类之间产生关系”is a”，才有多态特性

特点：

(1)   单继承

(2)   成员变量

super：子类所属父类内存空间的引用

this：本类对象引用

(3)   成员函数

当子父类出现一模一样方法时，用覆盖(复写、重写)

1)     子类权限大于父类

2)     静态值覆盖静态

3)     super._

(4)   构造函数

子类所有构造函数第一行，隐藏语句 super()

1)     子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先           调用父类的构造函数，这就是子类的实例化过程。

2)     如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。 

(5)   final

1)     修饰符，修饰方法、变量、类

2)     被final修饰的类不能继承

3)     被final修饰的方法不可覆盖

4)     被final修饰的变量是常量，只能赋值一次

抽象类:abstract

特点：

1)     抽象方法是能定义在抽象类中，都用abstract修饰

2)     抽象方法只定义方法声明，不定义方法实现

3)     抽象类不能被实例化

4)     子类继承抽象类，并覆盖所有抽象方法，子类才能实例化

模板方法设计模式

abstract class GetTime{       public void getTime(){               long start=System.currentTimeMillis();               codes();               long end=System.currentTimeMillis();               System.out.println(end-start);       }       public abstract voidcodes();        } class A extends GetTime{       public void codes(){               for (int i = 0; i< 1000; i++) {               System.out.println(i);               }       }}

接口

抽象类中方法都是抽象的就是接口

成员变量：public staticfinal

成员方法：public abstract

注意：可省略

例：

interface Inter{

         public static finalint X=4;

         public abstract voidshow();

}

特点：

1)     一个类可实现多个接口implements

2)     接口可多继承接口

3)     关系是“like a”

4)     接口的成员修饰符是public

3、 多态

事物存在多种体现形态

体现：

1)     父类引用指向子类对象

2)     父类引用可接受子类对象

转型：始终是子类在做变化

   例：

     //向上转型

     Animal a=new cat();

     if(a instanceOf Animal)

     {  //向下转型(操作子类特有方法)

         Cat c=(Cat)a;

     }

成员特点：

(1)     成员函数

编译：参阅引用变量所属类有调用方法，否则编译失败

运行：参阅对象所属类有调用方法

总结：编译看左边，运行看右边

(2)     静态成员函数、成员变量

编译、运行看左边

Object类

所有对象都具备的功能

1)     boolean equals(Object obj)：用于比较两个对象是否相等，其实内部比较的就是两个对象地址。

2)     String toString()：将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName() + '@' + Integer.toHexString(hashCode())

3)     int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。

4)     Class getClass()：获取任意对象运行时的所属字节码文件对象。

内部类

如果A类需要直接访问B类中的成员，而B类又需要建立A类的对象。将A类定义在B类中，A类就称为内部类。

特点：内部类可以直接访问外部类中的成员。而外部类想要访问内部类，必须要建立内部类的对象。

(1)   定义在成员位置

class Outer{     class Inner     {         void function(){}     }}

访问格式：

1)  非私有，可以在外部其他类中，可以直接建立内部类对象

Outer.Inner in= new Outer().Inner()

in.function()

2)  被成员修饰符所修饰, 比如：private、static

a、 内部类被static修饰后，只能直接访问外部类中的static成员

b、 在外部其他类中，直接访问static内部类的非静态成员new Outer.Inner().function()

注意: 当内部类中定义了静态成员，该内部类必须是static的。

      当外部类中的静态方法访问内部类，该内部类必须是静态

(2)   定义在局部位置

class Outer{       int x=3;     void method()    {           int y=4;        class Inner        {             void function(){  }        }    }}

特点：

1)     不可以被成员修饰符修饰

2)     可以直接访问外部类中的成员，因为还持有外部类中的引用

3)     不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

匿名内部类

就是一个匿名子类对象

必须实现一个接口或继承一个类

格式：new 父类或接口() {定义子类内容}

异常

    程序运行出现不正常情况

    Throwable类

1)     Error类：不编写针对性代码进行处理，JVM处理不了

2)     使用针对性处理方式

       处理：

1)     声明：在函数上声明该异常

         throws Exception

         抛出异常，后续处理有两种：声明、捕获

2)     捕获：在函数内处理

try{ 异常语句 }

catch(异常类变量) { 处理方式 }

finally { 一定执行的语句}  //System.exit(0);除外

       区别：

           throws：使用在函数上

                          后跟多个异常类，用”,”隔开

            throw：使用在函数中

                          后跟对象

       当函数内部出现throw抛出对象，必须函数上声明或函数内捕获

        注意：RuntimeException除外

       特别提醒：子父类覆盖时

1)     子类抛出的异常是父类异常子类或子集

2)     父类或接口没有异常抛出时，子类覆盖出现异常，只能用try catch

总结：子类不能抛比父类多的异常