黑马程序员——面向对象的学习与心得（二）

面向对象中的另外几个知识点的总结：多态，内部类，异常，单例设计模式

1，多态 Polymorphism

所谓多态,是指一个程序中同名的不同方法共存的情况。通过继承，一个类可以用作多种类型：可以用作它自己的类型、任何基类型，或者在实现接口时用作任何接口类型。这称为多态性。面向对象的程序中多态的情况有多种，可以通过子类对父类方法的覆盖实现多态，也可以利用重载在同一个类中定义多个同名的不同方法。自己的理解：多态是由继承中而演变出现的一个十分重要的特性，可以理解为事物存在的多种体现形态。

多态的存在的3个必要条件：

（1）要有继承

（2）要有重写
（3）父类引用指向子类对象(向上转型)

特点：

（1）多态的体现：父类直接指向自己的子类对象

例如：List  list = new ArrayList();

（3）多态的好处：大大提高了程序的扩展性

（4）多态的弊端，只能使用父类引用访问父类中的成员

例如以下代码

package cn.heima;
abstract class Person {
abstract void say();
}

class Student extends Person {
public void say() {
System.out.println("我是学生");
}
}

class Teacher extends Person {
public void say() {
System.out.println("我是老师");
}
}

class School {
public Student student = new Student();


public Teacher teacher = new Teacher();


public void foundPerson(Student st) {
student.say();
}

public void foundPerson(Teacher te) {
teacher.say();
}
}

public class TestPolymoph {
public static void main(String[] args) {
Student studnet = new Student();
Teacher teacher = new Teacher();
School school1 = new School();
School school2 = new School();
school1.foundPerson(studnet);
school2.foundPerson(teacher);
}
}

2,内部类，将一个类定义在另外一个类里面，对里面那个类就成为内部类（也叫嵌套类）。

访问规则：内部类可以直接访问外部类中的成员，包括私有成员而外部类要访问内部类成员必须要建立内部类的对象。

注意：

（1）当内部类定义了静态成员，该内部类必须也是static。

内部类使用情况：当描述事物的时候，事物的内部还有事物，该事物用内部类来描述。代码实例

（2）当内部类被定义在局部时候不可以被成员修饰符修饰，但是可以直接访问外部类中的成员，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量

package cn.heima;
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Outer out = new Outer();
out.medthod();
}

}
class Outer {
public void medthod() {
class Inner {
void fuction() {
System.out.println("我是内部类");
}
}
new Inner().fuction();
}
}

匿名内部类：其实是内部类的简写方式

定义的前提：内部类必须继承一个类或者实现接口

具体实例代码例如在使用JDK1.5新特性创建一个进程的时候：

ScheduledExecutorService time = Executors.newScheduledThreadPool(1);
time.scheduleAtFixedRate(new Runnable() {
public void run() {

currentLamp=currentLamp.blackOut();
}
},
10, 10, TimeUnit.SECONDS);

}

3，异常，是指程序在运行的时候出现不正常的情况

异常由来：是现实生活中一个具体的事物，也可以通过Java的类的形式进行描述并封装成一个对象。其实就是Java对不正常的情况进行描述后的对象体现。

异常分为两类：一种通过Error类进行描述，

对于Error一般不编写针对性代码对其进行处理；

另一种通过Exceotion类进行描述，对其可以使用针对性的处理方式进行处理

即为Thowable是所有错误和异常的超类。

着重的为异常处理：异常处理快特有语句代码

try(异常类 变量){

需要捕获异常的代码段

}cach{

对异常做出的处理

}finally{

一定会执行的代码

}

要在方式后面申明异常，表示该功能有可能会出现问题申明方式

例如：throws Exceotion

切记：

（1）在写异常的时候尽量申明具体化异常，这样可以更具体的处理。

（2）申明几个异常，就应该有几个catch块，如果多个catch块的异常出现继承关系，父类异常catch块放在最下面。

（3）在catch处理时，catch中一定要有具体处理方式，而不是简单的定义一句e.printStackTrace(),或者一句简单的输出语句。

自己的理解：我认为异常处理是为代码中由于误操作，或者其他原因而引起的运行不正常而需要我们预先做好对其出现误操作的处理方式。

自定义异常：自定义异常类必须继承Expection 

throws与throw的区别：

（1）位置，throws使用在函数上，而throw使用在函数内；

（2）throws后面跟的是异常类，可以跟多个，分别用逗号隔开。而throw后面跟的是异

常对象。

例如以下代码格式

  public Test() throws RepletException {
    try {
      System.out.println("Test this Project!")
    }
    catch (Exception e) {
      throw new Exception(e.toString());
    }
  }

异常分为：编译时异常，运行时异常（RuntimeExceotion）

需要特别注意的是：

Excepttion 中有一个特殊的子类异常RunntimeException ,是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。

可能在执行方法期间抛出但未被捕获的RuntimeException的任何子类都无需在 throws 子句中进行声明。 

其实RuntimeException是运行时异常，表示你的代码本身存在bug,不是编译错误,我们可以不做处理需要修正代码。

4,单例设计模式,是指通过保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。

为保证其对象唯一性：

（1）将构造函数私有化；

（2）在类中创造一个本类对象

（3）提供一个方法可以获取到该对象

单例设计模式可分为饿汉式和懒汉式

饿汉式代码实例

class Singleton {

//先初始化一个对象
  private static Singleton instance=new Singleton();
  private Singleton(){}

  static Singleton getInstance() {
      return instance;
  }
}

懒汉式代码实例
class Singleton {
  private static Singleton instance=null;
  private Singleton(){}
  static Singleton getInstance() {
      if(instance==null)
      instance=new Singleton();//在方法调用时候才开始初始化，也叫对象的延迟加载
      return instance;
  }
}

自我理解：单例模式就是为了保证代码中对象的唯一性且节约系统资源而采用的模式。

自我学习心得：在学习面向对象中对其中的多态，异常有了深刻认识，以前对异常这个方面也是模棱两可，现在通过学习，增加了巩固。多态我是对其理解会用，但是让我开口讲明白我也不知道从何说起，只有在多敲代码才能对其理解更加清晰透彻。