黑马程序员学习日记--面向对象二

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一：多态，Object类

多态：某一类事物的多种存在形态

多态的体现：父类引用指向子类对象

多态的前提：必须是类与类之间有关系，要么继承，要么实现

多态的好处：大大提高程序的扩展性

多态的弊端：父类的引用只能访问父类中的成员

向上转型：类型提升

向下转型：强制将父类的引用，转成子类类型

（classcastException类型转换异常）

多态中函数的特点：

编译期间：参阅引用型变量所属类中是否有调用的方法

运行期间：参阅对象所属类中是否有调用的方法

多态中成员变量的特点：参照引用型所属类中的变量

多态中静态成员函数的特点：参阅引用型变量所属类

Object：所有对象的直接或间接父类

equals（Object obj）：指示其他某个对象是否与此对象相等

toString（）：返回该对象的字符串表示

hashCode（）：返回该对象的哈希码值

getClass（）：返回此Object的运行时类

主板运行例子：

class  J8_1
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
mb.usePCI(new NetCard());
mb.usePCI(new SoundCard());
}
}
class MainBoard
{
void run()
{
System.out.println("主板运行");
}
void usePCI(PCI p)
{
if(p!=null)
{
p.open();
p.close();
}
}
}
interface PCI
{
public abstract void open();
public abstract void close();
}
class NetCard implements PCI
{
public void open()
{
System.out.println("网卡运行");
}
public void close()
{
System.out.println("网卡关闭");
}
}
class SoundCard implements PCI
{
public void open()
{
System.out.println("声卡运行");
}
public void close()
{
System.out.println("声卡关闭");
}
}

二：内部类，异常

内部类：将一个类定义在另一个类里面（内置类，嵌套类）

访问特点：

内部类可以直接访问外部类中的成员，包括私有成员；

外部类要访问内部类中的成员必须要建立内部类的对象

访问格式：

当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象

外部类名.内部类名 变量名=外部类对象.内部类对象

静态内部类：只能直接访问外部类中的静态成员，出现了访问权限

（当内部类中定义了静态成员，该内部类必须是静态的）

内部类的应用：当描述事物时，事物的内部还有事物，该事物用内部类描述

内部类定义在局部时：

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

2.可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问final修饰的局部变量。

匿名内部类：内部类的简化形式

前提：匿名内部类必须继承一个类或者实现接口

格式： new 父类或者接口（） {定义子类内容}

（匿名内部类其实就是一个匿名子类对象；

匿名内部类中定义的方法最好不要超过三个）

练习：

class  J9_1
{
public static void main(String[] args)
{
Out.funtion().show();
}
}
interface In
{
public abstract void show();
}
class Out
{
static In funtion()
{
return new In()
{
public void show()
{
System.out.println("匿名内部类练习");
}
};
}
}

异常：

异常的体系：Throwable

Error：通常出现重大问题如：运行的类不存在或者内存溢出等，不编写针对代码对其处理

Exception：在运行时出现的异常情况，可以通过try，catch，finally

Exception和Error的子类名都是以父类名作为后缀

异常的由来：java对不正常情况进行描述后的对象体现

try

{需要被检测的代码}

catch（异常类 变量）

{处理异常的代码}

finally

{一定会执行的语句}

对捕捉到的异常对象进行常见方法操作：

String getMessage（）：获取异常信息

toString（）：返回此throwable的简短描述

printStackTrace（）：将此throwable及其追踪输出到标准错误流

在函数上声明异常：

便与提高安全性，让调用者进行处理，不处理编译失败。

对多异常的处理：

1，声明异常时，建议声明更为具体的异常，这样处理的可以更具体

2，对方声明几个异常，就应该有几个catch块

如果多个catch块中的异常出现继承关系，父类异常catch块放下面

（ 当在函数内部出现了throw抛出异常动作，那么就必须要给出相应的处理动作）

自定义异常：必须是自定义类继承Exception

原因：异常类和异常对象都被抛出。这个可抛性是Throwable这个体系中独有特点。

throws：使用在函数上，后接异常类，可以是多个，用逗号隔开。

throw：使用在函数内，后接异常对象。

（Exception中有一个特殊的子类异常RuntimeException运行时异常：

如果在函数内抛出该异常，函数上可以不用声明；

如果在函数上声明了该异常，调用者可以不用进行处理）

异常分两种：

1，编译时被检测的异常

2，编译时不被检测的异常，运行时异常（RuntimeException及其子类）

finally代码块：定义一定执行的代码，通常用于关闭资源

（finally只有一种情况不会执行：System.exit(0)；）

异常在字符类覆盖中的体现：

1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该子类的异常，或者不抛

2，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，不可以抛出异常

异常的好处：

1，将代码进行封装

2，将正常流程代码和问题处理代码分离，方便阅读

三：包（package）

给类文件进行分类管理；

非类提供多层命名空间；

写在程序文件的第一行；

类名的全称是：包名.类名

包也是一种封装格式

包与包之间进行访问，被访问的包中的类以及类中的成员，需要用public修饰；

不用包中的子类可以直接访问父类中被protected修饰的成员

import导入的是包中的类