黑马程序员——java基础知识之面向对象（三）
2015-04-30 10:28
411 查看
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
（一）、接口
1、什么是接口？
接口：初期理解，可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。用interface关键字来定义接口。
2、接口的格式特点
接口定义时，格式特点：
①接口中常见定义：常量，抽象方法。
②接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
注意：
①接口是不可以创建对象的，因为有抽象方法。
②需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
③接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
④实现多个接口时，接口中不可以有返回不同类型的同名抽象函数。这样子类实现时将不能复写。
接口特点举例：
（二）、多态
1、什么是多态？
可以理解为事物存在的多种体现形态。
2、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
3、多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。
4、多态的好处
多态的出现大大的提高程序的扩展性。
5、多态的弊端：
虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。
6、多态的应用
7、多态的出现代码中的特点(多态使用的注意事项)
注意：
①如果此时父类的引用想要调用Cat中特有的方法，就需要强制将父类的引用，转成子类类型，向下转型。如：Cat c = (Cat)a;
②如果父类可以创建对象，如：Animal a = new Animal(); 此时，就不能向下转型了，Cat c = (Cat)a; 这样的代码就变得不容许，编译时会报错。所以千万不能出现这样的操作，就是将父类对象转成子类类型
注意：instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)
8、在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。
在多态中，静态成员函数的特点：
无论编译和运行，都参考做左边。
9、 多态的应用
在接口中的应用,例子程序
10、Object类的equals方法
Object类中已经提供了对对象是否相同的比较方法。（比较的是对象的地址是否相等）
如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。
11、Object类中的toString方法
父类定义的是地址，子类一般是要复写父类的toString方法，把自己的内容转换成字符串。
（三）、内部类
1、什么是内部类？
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test1.class。编译器将会把内部类翻译成用1.class。编译器将会把内部类翻译成用（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。
2、内部类的规则和特点
①内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式： 外部类名.this。
②外部类要访问内部类，必须建立内部类对象。
3、内部类的调用格式
①当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：
外部类名.内部类名 变量名 =外部类对象.内部类对象；
如： Outer.Inner in =new Outer().new Inner();
②当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：private：将内部类在外部类中进行封装。
比如：static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
③在外部其他类中，直接访问static内部类的非静态成员的格式为：
new 外部类名.内部类名（）.方法名（）；
④在外部其他类中，直接访问static内部类的静态成员格式为：
外部类名.内部类名.方法名（）；
如：Outer.Inner.function();
3/1注意：
内部类定义在局部时，
不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
3/2 匿名内部类
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
例子程序：
（四）、异常
1、什么是异常？
就是程序在运行时出现不正常情况，问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。
2、异常问题的划分
两种：一种是严重的问题，一种非严重的问题。
①对于严重的，java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
②对与非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
异常有两种：
①编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。
②运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。如：RuntimeException以及其子类。
3、异常的处理（格式）
java 提供了特有的语句进行处理。
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}
注意：对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。
4、在函数上声明异常。
便于提高安全性，让调用出进行处理。不处理编译失败。
5、对多异常的处理。
①声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
②对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
6、自定义异常
1、如果项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题。进行自定义的异常封装。
2、如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。
3、注意
自定义异常：
必须是自定义类继承Exception。
继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
4、throw和throws的区别
throws使用在函数上。
throw使用在函数内。
throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。
5、Exceptoin中有一个特殊的子类异常RuntimeException
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；
之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，
对代码进行修正。
自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。
对于异常分两种：
1，编译时被检测的异常。
2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
练习：
例子
6、异常声明中的finally代码块：定义一定执行的代码。
通常用于关闭资源。
7、总结
异常的三种格式
第一个格式：
try
{
}
catch ()
{
}
第二个格式：
try
{
}
catch ()
{
}
finally
{
}
第三个格式：
try
{
}
finally
{
}
注意：记住一点：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。
8、异常在子父类覆盖中的体现；
①子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
②如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
③如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
练习：
注意：
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
增加知识点:java中的包机制
1、什么是java中的package？
在java中，管叫包，相当于文件夹。包里通常存放的是类文件，因为我们在编写程序的时候，难免会有类名相同的情况，就如我们人名一样。为了对类进行分类管理，java就有了包的出现，在不同包中可以有相同的类名，调用的时候连同包名一起就行。
包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。
2、package有什么作用？
①为避免多个类重名的情况，如果出现两个相同名字的类，可通过包将两者区分，从而避免冲突。
②对类文件进行分类管理，可以将相关的一些类放在同一个包中。
③给类提供多层命名空间，如a包中的Demo.class文件，如果要创建Demo对象，就要在使用时加上a.如：a.Demo demo=new a.Demo（）；
④包的出现可以将java的类文件和源文件相分离。
3、package的相关规则
①包必须写在程序的第一行。因为要先有包，才知道类文件的存放地方。
②类的全称：包名.类名。
③编译定义了包的程序文件时，在编译时要指定包的存储目录。
如：javac –d c:\mypack类名.java
4、包与包之间的相互访问
总结：
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种，public protected。
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok
5、包的导入
可以简化类名。在调用其他包中的类时，需要写类的全称，也就是连同包名一起书写。当类存在多层包中时，如：haha.hehe.pack.Demo，使用import导入后，使用其类时，就可以不加包名了。导入格式如：import haha.hehe.pack.Demo;
注意：
①在导入包时，如果包中有很多类，可以使用通配符 来替代包中的所有类。但是，建议不要使用通配符 ，因为将不需要使用的类导入后，会占用内存空间。所有在编写程序时，要使用包中的哪些类，就导入哪些类。
②定义包名不要重复，可以使用url来完成定义，url是唯一的。如：package cn.itheima.Demo。
③导入的不同包中有相同类时，必须写类的全名以区分，否则将会报错。
6、jar包
类越来越多，我们可以用包来装，当包越来越多时，我们可以将包进行压缩。而java中用jar这个工具来对包进行压缩。压缩后的后缀名为jar。
注意：
jar.exe工具的一些命令：
①创建jar包
jar -cvf mypack.jar packa packb
②查看jar包
jar -tvf mypack.jar [>定向文件]
③解压缩
jar -xvf mypack.jar
④自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
（一）、接口
1、什么是接口？
接口：初期理解，可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。用interface关键字来定义接口。
2、接口的格式特点
接口定义时，格式特点：
①接口中常见定义：常量，抽象方法。
②接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
注意：
①接口是不可以创建对象的，因为有抽象方法。
②需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
③接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
④实现多个接口时，接口中不可以有返回不同类型的同名抽象函数。这样子类实现时将不能复写。
接口特点举例：
//定义抽象的学生类
abstract class Student
{
//都有学习的功能而且学的东西不一样
abstract void study();
//都有相同的睡觉功能
void sleep()
{
System.out.println("sleep");
}
}
//扩展的抽烟功能
interface Smoking
{
void smoke();
}
//ZhangSan具有学生的功能，而且扩展了抽烟的功能
class ZhangSan extends Student implements Smoking
{
void study(){}
public void smoke(){}
}（二）、多态
1、什么是多态？
可以理解为事物存在的多种体现形态。
2、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
3、多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。
4、多态的好处
多态的出现大大的提高程序的扩展性。
5、多态的弊端：
虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。
6、多态的应用
7、多态的出现代码中的特点(多态使用的注意事项)
注意：
①如果此时父类的引用想要调用Cat中特有的方法，就需要强制将父类的引用，转成子类类型，向下转型。如：Cat c = (Cat)a;
②如果父类可以创建对象，如：Animal a = new Animal(); 此时，就不能向下转型了，Cat c = (Cat)a; 这样的代码就变得不容许，编译时会报错。所以千万不能出现这样的操作，就是将父类对象转成子类类型
例子：
bstract class Animal
{
abstract void eat();
}
//猫继承动物，重写了eat的方法，并定义了自己的catchMouse方法
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
//狗继承动物，重写了eat的方法，并定义了自己的kanJia方法
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
public void kanJia()
{
System.out.println("看家");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Dog());
function(new Pig());
}
//多态的利用
public static void function(Animal a)
{
a.eat();
}注意：instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)
8、在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。
在多态中，静态成员函数的特点：
无论编译和运行，都参考做左边。
9、 多态的应用
在接口中的应用,例子程序
需求：数据库的操作。
数据是：用户信息。
1，连接数据库。JDBC Hibernate
2，操作数据库。
c create r read u update d delete
3，关闭数据库连接。
*/
interface UserInfoDao
{
public void add(User user);
public void delete(User user);
}
class UserInfoByJDBC implements UserInofDao
{
public void add(User user)
{
1,JDBC连接数据库。;
2，使用sql添加语句添加数据。;
3，关闭连接。
}
public void delete(User user)
{
1,JDBC连接数据库。;
2，使用sql添加语句删除数据。;
3，关闭连接。
}
}
class UserInfoByHibernate implements UserInfoDao
{
public void add(User user)
{
1,Hibernate连接数据库。;
2，使用sql添加语句添加数据。;
3，关闭连接。
}
public void delete(User user)
{
1,Hibernate连接数据库。;
2，使用sql添加语句删除数据。;
3，关闭连接。
}
}
//定义主程序
class DBOperate
{
public static void main(String[] args)
{
//UserInfoByJDBC ui = new UserInfoByJDBC();
// UserInfoByHibernate ui = new UserInfoByHibernate();
UserInfoDao ui = new UserInfoByHibernate();
ui.add(user);
ui.delete(user);
}
}10、Object类的equals方法
Object类中已经提供了对对象是否相同的比较方法。（比较的是对象的地址是否相等）
如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。
class Demo //extends Object
{
private int num;
Demo(int num)
{
this.num = num;
}
//覆盖父类的equals方法，比较的对象的内容是否相同
public boolean equals(Object obj)//Object obj = new Demo();
{
if(!(obj instanceof Demo))
return false;
Demo d = (Demo)obj;
return this.num == d.num;
}11、Object类中的toString方法
父类定义的是地址，子类一般是要复写父类的toString方法，把自己的内容转换成字符串。
（三）、内部类
1、什么是内部类？
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test1.class。编译器将会把内部类翻译成用1.class。编译器将会把内部类翻译成用（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。
2、内部类的规则和特点
①内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式： 外部类名.this。
②外部类要访问内部类，必须建立内部类对象。
3、内部类的调用格式
①当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：
外部类名.内部类名 变量名 =外部类对象.内部类对象；
如： Outer.Inner in =new Outer().new Inner();
②当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：private：将内部类在外部类中进行封装。
比如：static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
③在外部其他类中，直接访问static内部类的非静态成员的格式为：
new 外部类名.内部类名（）.方法名（）；
④在外部其他类中，直接访问static内部类的静态成员格式为：
外部类名.内部类名.方法名（）；
如：Outer.Inner.function();
3/1注意：
内部类定义在局部时，
不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
3/2 匿名内部类
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
例子程序：
interface Inter
{
void method();
}
class Test
{
//补足代码。通过匿名内部类。
/*
static class Inner implements Inter
{
public void method()
{
System.out.println("method run");
}
}
*/
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("method run");
}
};
}
}（四）、异常
1、什么是异常？
就是程序在运行时出现不正常情况，问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。
2、异常问题的划分
两种：一种是严重的问题，一种非严重的问题。
①对于严重的，java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
②对与非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
异常有两种：
①编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。
②运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。如：RuntimeException以及其子类。
3、异常的处理（格式）
java 提供了特有的语句进行处理。
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}
注意：对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。
4、在函数上声明异常。
便于提高安全性，让调用出进行处理。不处理编译失败。
5、对多异常的处理。
①声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
②对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
6、自定义异常
1、如果项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题。进行自定义的异常封装。
2、如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。
3、注意
自定义异常：
必须是自定义类继承Exception。
继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
4、throw和throws的区别
throws使用在函数上。
throw使用在函数内。
throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。
5、Exceptoin中有一个特殊的子类异常RuntimeException
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；
之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，
对代码进行修正。
自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。
对于异常分两种：
1，编译时被检测的异常。
2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
练习：
例子
/*
毕老师用电脑上课。
开始思考上课中出现的问题。
比如问题是
电脑蓝屏。
电脑冒烟。
要对问题进行描述，封装成对象。
可是当冒烟发生后，出现讲课进度无法继续。
出现了讲师的问题：课时计划无法完成。
*/
//自定义蓝屏异常
class LanPingException extends Exception
{
LanPingException(String message)
{
super(message);
}
}
//自定义冒烟异常
class MaoYanException extends Exception
{
MaoYanException(String message)
{
super(message);
}
}
class NoPlanException extends Exception
{
NoPlanException(String msg)
{
super(msg);
}
}
//电脑类
class Computer
{
private int state = 3;
public void run()throws LanPingException,MaoYanException
{
if(state==2)
throw new LanPingException("蓝屏了");
if(state==3)
throw new MaoYanException("冒烟了");
System.out.println("电脑运行");
}
public void reset()
{
state = 1;
System.out.println("电脑重启");
}
}
//老师类
class Teacher
{
private String name;
private Computer cmpt;
Teacher(String name)
{
this.name = name;
cmpt = new Computer();
}
public void prelect()throws NoPlanException
{
try
{
cmpt.run();
}
catch (LanPingException e)
{
cmpt.reset();
}
catch (MaoYanException e)
{
test();
//把冒烟异常转换为老师的异常
throw new NoPlanException("课时无法继续"+e.getMessage());
}
System.out.println("讲课");
}
public void test()
{
System.out.println("练习");
}
}
class ExceptionTest
{
public static void main(String[] args)
{
Teacher t = new Teacher("毕老师");
//捕获异常并处理异常
try
{
t.prelect();
}
catch (NoPlanException e)
{
System.out.println(e.toString());
System.out.println("换老师或者放假");
}
}
}6、异常声明中的finally代码块：定义一定执行的代码。
通常用于关闭资源。
7、总结
异常的三种格式
第一个格式：
try
{
}
catch ()
{
}
第二个格式：
try
{
}
catch ()
{
}
finally
{
}
第三个格式：
try
{
}
finally
{
}
注意：记住一点：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。
8、异常在子父类覆盖中的体现；
①子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
②如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
③如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
练习：
package cn.dhjYuju;
/*
有一个圆形和长方形。
都可以获取面积。对于面积如果出现非法的数值，视为是获取面积出现问题。
问题通过异常来表示。
现有对这个程序进行基本设计。
*/
//调用者不用处理异常，运行时异常是要再出现时，让程序停止
public class Test001 {
public static void main(String[] args){
Rec a = new Rec(-3,4);
a.getArea();
}
}
//定义一个运行时的异常
class NoValueException extends RuntimeException{
NoValueException(String message){
super(message);
}
}
//抽取圆和长方形的共性
interface Sheap{
void getArea();
}
//定义圆的类，内部抛出异常
class Circle implements Sheap{
private double radius;
public static final double PI = 3.14;
Circle(double radius){
if(radius <=0)
throw new NoValueException("不能为负数");
this.radius = radius;
}
public void getArea(){
System.out.println(radius*radius*PI);
}
}
//定义长方形类，并局部抛出异常
class Rec implements Sheap{
private double len,wid;
Rec(double len,double wid){
if(len<=0 || wid <=0)
throw new NoValueException("不能为负数");
this.len = len;
this.wid=wid;
}
public void getArea(){
System.out.println(len*wid);
}
}注意：
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
增加知识点:java中的包机制
1、什么是java中的package？
在java中，管叫包，相当于文件夹。包里通常存放的是类文件，因为我们在编写程序的时候，难免会有类名相同的情况，就如我们人名一样。为了对类进行分类管理，java就有了包的出现，在不同包中可以有相同的类名，调用的时候连同包名一起就行。
包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。
2、package有什么作用？
①为避免多个类重名的情况，如果出现两个相同名字的类，可通过包将两者区分，从而避免冲突。
②对类文件进行分类管理，可以将相关的一些类放在同一个包中。
③给类提供多层命名空间，如a包中的Demo.class文件，如果要创建Demo对象，就要在使用时加上a.如：a.Demo demo=new a.Demo（）；
④包的出现可以将java的类文件和源文件相分离。
3、package的相关规则
①包必须写在程序的第一行。因为要先有包，才知道类文件的存放地方。
②类的全称：包名.类名。
③编译定义了包的程序文件时，在编译时要指定包的存储目录。
如：javac –d c:\mypack类名.java
4、包与包之间的相互访问
总结：
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种，public protected。
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok
5、包的导入
可以简化类名。在调用其他包中的类时，需要写类的全称，也就是连同包名一起书写。当类存在多层包中时，如：haha.hehe.pack.Demo，使用import导入后，使用其类时，就可以不加包名了。导入格式如：import haha.hehe.pack.Demo;
注意：
①在导入包时，如果包中有很多类，可以使用通配符 来替代包中的所有类。但是，建议不要使用通配符 ，因为将不需要使用的类导入后，会占用内存空间。所有在编写程序时，要使用包中的哪些类，就导入哪些类。
②定义包名不要重复，可以使用url来完成定义，url是唯一的。如：package cn.itheima.Demo。
③导入的不同包中有相同类时，必须写类的全名以区分，否则将会报错。
6、jar包
类越来越多，我们可以用包来装，当包越来越多时，我们可以将包进行压缩。而java中用jar这个工具来对包进行压缩。压缩后的后缀名为jar。
注意：
jar.exe工具的一些命令：
①创建jar包
jar -cvf mypack.jar packa packb
②查看jar包
jar -tvf mypack.jar [>定向文件]
③解压缩
jar -xvf mypack.jar
④自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员——Java基础知识——面向对象(二)
- 黑马程序员——Java基础知识——面向对象(一)
- 黑马程序员---java基础知识之面向对象（二）
- 黑马程序员——java基础知识之面向对象（一）
- 黑马程序员——java基础知识之面向对象（二）
- 黑马程序员-Java基础知识预备之Java面向对象的理解（part1）
- 黑马程序员，Java基础知识三：面向对象
- 黑马程序员_JAVA基础知识总结——面向对象三大特征
- 黑马程序员 Java基础知识总结-面向对象三大特征
- 黑马程序员-Java基础知识预备之Java面向对象的理解（part2）
- 黑马程序员——Java基础知识——面向对象(三)
- 黑马程序员———java基础知识———面向对象
- 黑马程序员——Java基础语法 之面向对象(概念，特征，this，static关键字，代码块)
- 黑马程序员—4、JAVA基础&面向对象
- 黑马程序员——Java基础---面向对象
- 黑马程序员_java基础知识三
- 黑马程序员_java基础_面向对象
- 黑马程序员——Java基础面向对象
- 黑马程序员——Java集合基础知识之Map
- 黑马程序员------Java基础学习------面向对象(上)