黑马程序员————学习日记【7】 【Java面向对象3】
2013-04-16 13:31
267 查看
------- android培训、java培训、期待与您交流! ----------
内部类:[b]将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)[/b]
访问特点:
(1)内部类可以直接访问外部类中的成员,包括私有成员。
(2)而外部类要访问内部类中的成员必须要建立内部类的对象。
记住:catch是用于处理异常,如果没有catch就代表异常没有被处理。
如果给异常是检测时异常,那么必须声明。
异常在子父类覆盖中的体现
1、子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,
只能抛出父类的异常或者该异常的子类。
2、如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出
父类异常的子集。
3、如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,
也不可以抛出异常。如果子类方法发生了异常,就必须进行try处理
,绝对不能抛。
异常:
是什么? 是对问题的描述,将问题进行对象的封装。
-------------------------------------------------
异常体系:
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性
即可以被throws和throw关键字所操作
只有异常体系具备这个特点
--------------------------------------------------------
throw和throws的用法:
throw定义在函数内,用于抛出异常对象
throws定义在函数上,用于抛出异常类,可抛出多个,用逗号隔开。
当函数内有throw抛出异常对象,并未进行try处理,必须在函数上声明,
否则编译失败。
注意:RuntimeException除外,即,函数内如果抛出的RuntimeException
异常,函数上可以不用声明。
-----------------------------------------------------------------
如果函数声明了异常,调用者需要进行处理,处理方式可throw也可try
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有抛也没有try),编译失败
该异常被标识,代表这可以被处理
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查。
该异常的发生,建议不处理,让程序停止,需要对代码进行修正
---------------------------------------------------------------
异常处理的语句:
try
{
需要被检测的代码
}
catch ()
{
处理异常的代码
}
finally
{
一定会执行的代码
}
有三种结合格式:
1、 try
{
}
catch ()
{
}
2、 try
{
}
finally
{
}
3、 try
{
}
catch ()
{
}
finally
{
}
注意:
1、finally中定义的通常是 关闭资源代码,因为资源必须释放
2、finally只有一种情况不会执行。当执行到System.exit(0);
finally不会执行。【详见day10中的ExceptionDemo5】
-----------------------------------------------------------------
自定义异常:
定义类继承Exception或者RuntimeException
1、为了让该自定义类具备可抛性
2、让该类具备操作异常的共性方法
当要定义自定义异常的信息时,可以使用父类已经定义好的功能
异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常:
按照java的面向对象思想,将程序中出现的特有问题进行封装
-----------------------------------------------------------------
异常的好处:
1、将问题进行封装
2、将正常流程代码和问题处理代码相分离,便于阅读
异常的处理原则:
1、处理方式两种:try或者throws
2、调用到抛出异常的功能时,对象抛出几个,就处理几个
一个try对应多个catch
3、多个catch,父类的catch放到最下面
4、catch内,需要定义针对性的处理方式。
千万不要简单的定义printStackTrace或者输出语句。
也不要不写,要有针对性的处理方式。
当捕获到的异常,本功能处理不了时,可以继续在catch中抛出
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常
可以将异常转换后,再抛出和该功能相关的异常。
或者异常可以处理,当需要将异常产生的和本功能相关的问题
提供出去让调用者知道,并处理。
try
{
throw new AException()
}
catch (AException e)
{
throw new BExcption();
}
也可将捕获异常处理后,转换新的异常
try
{
throw new AException()
}
catch (AException e)
{
//对AException处理
throw new BExcption();
}
比如,汇款的例子。
异常的注意事项:(非常重要)
在子父类覆盖时,
1、子类抛出的异常必须是父类的异常的子类或者子集
2、如果父类或者接口没有异常抛出时,子类覆盖出现异常,
只能try不能抛。
详情参阅: ExceptionTest.java 和 ExceptionTest1.java
【老师用电脑上课】 【求图形面积】
//类的修饰符在权限上只有两个,一个是默认权限,一个是公有权限。
jar包的功能,把类都封装完成后,还可以运行。
以后想使用老师定义的工具,老师只把jar包给我就行。
我只要做一件事就行:把jar包放到classpath路径下。
那么jar包里的数据或者对象就都能用了。
我们在进行开发的时候,总要去找一些对象来完成是比较方便的,如果
java网站没有提供现有的工具,一些互联网的资源有很多,比如阿巴西
网站,提供了一些对java对象又进行简单封装的常用的工具。如客户端
工具,这些工具不需要自己编写了,只要到网站上把它下载下来就行了
。下载完成,那是一个zip包,解压缩后,里面有一个jar包,还有一个
jar包所对应类的说明文档。把jar包放到classpath路径下并打开里面的
文档,查阅里面的工具就行了。
内部类:[b]将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)[/b]
访问特点:
(1)内部类可以直接访问外部类中的成员,包括私有成员。
(2)而外部类要访问内部类中的成员必须要建立内部类的对象。
/* 内部类的访问规则: 1、内部类可以直接访问外部类中的成员,包括私有 之所以可以直接访问外部类中的成员,是因为内部类中持有了一个 外部类的引用,格式:外部类类名.this.(B) 2、外部类要访问内部类,必须建立内部类对象 问:类能不能被私有修饰? 答:能,内部类可以被私有修饰,当内部类在外部类的 成员位置上的时候(A)。 访问格式: 1、当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中 可以直接建立内部类对象 格式:外部类名.内部类名 变量名 = 外部类对象.内部类对象; Outer.Inner in = new Outer().new Inner(); 2、当内部类在成员位置上,就可以被成员修饰符所修饰 比如:private,将内部类在外部类中进行封装 static:内部类就具备static的特性。 当内部类被static修饰后,只能直接访问外部类中的static成员。 出现了访问局限。 在外部其他类中,如何直接访问static内部类的非静态成员呢? new Outer.Inner().function(); 在外部其他类中,如何直接访问static内部类的静态成员呢? Outer.Inner.function(); 注意:当内部类中定义了静态成员,该内部类必须是static的。 当外部类中的静态方法访问内部类时,内部类也必须是static的。 */ //当描述事物时,事物的内部还有事物,该事物用内部类来描述。 //因为内部事物在使用外部事物的内容。 //内部类只有定义在成员位置上才能被私有或修饰 class Body { private class XinZang { } public void show() { new XinZang(). } } class Outer { private static int x = 3; static class Inner//静态内部类(A) { // int x = 4; static void function() { // int x = 6; System.out.println("inner:"+x);//(B) } } /* void method() { Inner in = new Inner(); in.function(); } */ static class Inner2 { void show() { System.out.println("inner2 show"); } } public static void method() { // Inner.function(); new Inner2().show(); } } class InnerClassDemo2 { public static void main(String[] args) { Outer.method(); // Outer.Inner.function(); // Outer out = new Outer(); // out.method(); // new Outer.Inner().function(); //直接访问内部类中的成员 // Outer.Inner in = new Outer().new Inner(); // in.function(); } }
/* 内部类定义在局部时, 1、不可以被成员修饰符修饰 2、可以直接访问外部类中的成员,因为还持有外部类中的引用。 但是不可以访问它所在的局部中的变量,只能访问被final修饰的 局部变量。 */ class Outer { int x = 3; void method(final int a) { final int y = 4; class Inner { void function() { System.out.println(y); } } new Inner().function(); } } class InnerClassDemo3 { public static void main(String[] args) { Outer out = new Outer(); out.method(7); out.method(8); } }
/* 匿名内部类 1、匿名内部类其实就是内部类的简写格式 2、定义匿名内部类的前提: 内部类必须是继承一个类或者实现接口 3、匿名内部类的格式:new父类或者接口(){定义子类的内容} 4、其实匿名内部类就是一个匿名子类对象,而且这个对象有点胖。 可以把它理解为带内容的对象。 5、匿名内部类中定义方法最好不要超过3个,1个或2个最好。 */ abstract class AbsDemo { abstract void show(); } class Outer { int x = 3; /* class Inner extends AbsDemo { void show() { System.out.println("show:"+x); } void abc() { System.out.println("hehe"); } } */ public void function() { // AbsDemo a = new Inner(); // Inner in = new Inner(); // in.show(); // in.abc(); AbsDemo d = new AbsDemo() { int num = 9; void show() { System.out.println("num==="+num); } void abc() { System.out.println("haha"); } }; d.show(); // d.abc();//编译失败 } } class InnerClassDemo4 { public static void main(String[] args) { new Outer().function(); } }
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"); } }; } } class InnerClassTest { public static void main(String[] args) { //Test.function():Test类中有一个静态的方法function。 //.method():function这个方法运算后的结果是一个对象,而且 //是一个Inter类型的对象。 //因为只有是Inter类型的对象,才可以调用method方法。 Test.function().method(); // Inter in = Test.function(); // in.method(); show(new Inner() { public void method() { System.out.println("method show run"); } }); } public static void show(Inter in) { in.method(); } } class InnerTest { public static void main(String[] args) { Object o = new Object() { public void function() { } }; o.function(); } }
/* 异常:就是程序在运行时出现的不正常情况 异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类 的形式进行描述。并封装成对象,其实就java对不正常情况 进行描述后的对象体现。 对应问题的划分,两种:一种是严重的问题,一种是非严重的问题 严重的,java通过Error类进行描述 对应Error一般不编写针对性的代码对其进行处理 非严重,java通过Exception类进行描述 对于Exception可以使用针对性的处理方式进行处理 无论Error或者Exception都具有一些共性内容。 比如:不正常情况的信息,引发原因等。 Thorwable |--Error |--Exception 2、异常的处理 java提供了特有的语句进行处理 try { 需要被检测的代码 } catch(异常类 变量) { 处理异常的代码(处理方式) } finally { 一定会执行的语句 } 3、对捕获到的异常对象进行常见方法操作 String getMessage();获取异常信息 在函数上声明异常 便于提高安全性,让调用处进行处理,不处理编译失败。 对多异常的处理 1、声明异常时,建议声明更为具体的异常,这样处理的可以更具体。 2、对方声明几个异常,就对应有几个catch块,不要定义多余的catch块。 如果多个catch块中的异常出现继承关系,父类异常catch块放在 最下面。 3、建议在进行catch处理时,catch中一定要定义具体处理方式。 不要简单定义一句e.printStackTrace(), 也不要简单的就书写一条输出语句。 */ class Demo { int div(int a,int b)throws Exception {//在功能上通过throws的关键字声明了该功能有可能会出现问题 return a/b; } } class ExceptionDemo { public static void main(String[] args) { Demo d = new Demo(); try { int x = d.div(4,1); System.out.println("x="+x); } catch (Exception e)//Exception e = new ArithmeticException(); { System.out.println("除零啦"); System.out.println(e.getMessage());// /by zero; System.out.println(e.toString());//异常名称:异常信息 e.printStackTrace();//异常名称,异常信息,异常出现的位置 //其实jvm默认的异常处理机制,就是在调用printStackTrace方法, //打印异常的堆栈的跟踪信息。 } System.out.println("over"); // byte[] arr = new by te[1024*1024*600]; } }
/* 因为项目中会出现特有的问题, 而这些问题并未被java所描述并封装对象。 所以对于这些特有的问题可以按照java的对问题封装的思想, 将特有的问题,进行自定义的异常封装。 自定义异常 需求:在本程序中,对于除数是-1,也视为是错误的是无法进行运算的。 那么就需要对这个问题进行自定义的描述。 当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作 要么在内部try catch处理 要么在函数上声明让调用者处理。 一般情况下,函数内出现异常,函数上需要声明。 发现打印的结果中只有异常的名称,却没有异常的信息。 因为自定义的异常并未定义信息。 如何定义异常信息呢? 因为父类中已经把异常信息的操作都完成了。 所以子类只要在构造时,将异常信息传递给父类通过super语句 那么就可以直接通过getMessage方法获取自定义的异常信息。 自定义异常: 必须是自定义类继承Exception 继承Exception原因: 异常体系有一个特点,因为异常类和异常对象都被抛出。 它们都具备可抛性,这个可抛性是Throwable这个体系中独有特点 只有这个体系中的类和对象才可以被throws和throw操作。 throws和throw区别: 1、throws使用在函数上【写在)和{之间】,throw使用在函数内 2、throws后面跟的异常类,可以跟多个,用逗号隔开 3、throw后跟的是异常对象 */ class FuShuException extends Exception { private cbf0 int value; FuShuException() { super(); } FuShuException(String msg,int value) { super(msg); this.value = value; } public int getValue() { return value; } } class Demo { int div(int a,int b)throws FuShuException { if(b<0) throw new FuShuException("出现了除数是负数的情况/---- by fushu",b);//手动通过throw关键字抛出一个 //自定义异常对象。 return a/b; } } class ExceptionDemo3 { public static void main(String[] args) { Demo d = new Demo(); try { int x = d.div(4,-9); System.out.println("x="+x); } catch (FuShuException e) { System.out.println(e.toString()); // System.out.println("除数出现负数了"); System.out.println("错误的负数是:"+e.getValue()); } System.out.println("over"); } } /* class Throwable { private String message; Throwable(String message) { this.message = message; } public String getMessage() { return message; } } class Exception extends Throwable { Exception(String message) { super(message); } } class Person { String name; Persong(String name) { this.name = name; } public String getName() { return name; } } class Student extends Person { Student(String name) { super(name); } } new Student("lisi").getName(); */
/* Exception中有一个特殊的子类异常RuntimeException运行时异常 如果在函数内容中抛出该异常,函数上可以不用声明,编译一样通过 如果在函数上声明了该异常,调用者可以不用进行处理,编译一样通过。 之所以不用在函数上声明,是因为不需要让调用者处理。 当该异常发生,希望程序停止。 因为在运行时,出现了无法继续运算的情况,希望停止程序后, 对代码进行修正。 自定义异常时:如果该异常的发生,无法再继续运算 就让自定义异常继承RuntimeException. 对于异常分两种: 1、编译时被检测的异常 2、编译时不被检测的异常(运行时异常,RuntimeException以及子类) */ class FuShuException extends RuntimeException { FuShuException(String msg) { super(msg); } } class Demo { int div(int a,int b)//throws ArithmeticException { if(b<0) throw new FuShuException("出现了除数为负数了"); if(b==0) throw new ArithmeticException("被零除啦"); return a/b; } } class ExceptionDemo4 { public static void main(String[] args) { Demo d = new Demo(); int x = d.div(4,-9); System.out.println("x="+x); System.out.println("over"); } } /* class Person { public void checkName(String name) { // if(name.equals("lisi"))//NullPointException if("lisi".equals(name))//if(name!=null && name.equals("lisi")) System.out.println("YES"); else System.out.println("NO"); } } main() { Person p = new Person(); p.checkName("null"); } */
/* 比老师用电脑上课 开始思考上课中出现的问题 比如问题是:电脑蓝屏 电脑冒烟 要对问题进行描述,封装成对象 可是当冒烟发生后,出现讲课进度无法继续。 就出现了讲师的问题,课时计划无法完成。 */ 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("换老师或者放假"); } } }
记住:catch是用于处理异常,如果没有catch就代表异常没有被处理。
如果给异常是检测时异常,那么必须声明。
异常在子父类覆盖中的体现
1、子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,
只能抛出父类的异常或者该异常的子类。
2、如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出
父类异常的子集。
3、如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,
也不可以抛出异常。如果子类方法发生了异常,就必须进行try处理
,绝对不能抛。
异常:
是什么? 是对问题的描述,将问题进行对象的封装。
-------------------------------------------------
异常体系:
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性
即可以被throws和throw关键字所操作
只有异常体系具备这个特点
--------------------------------------------------------
throw和throws的用法:
throw定义在函数内,用于抛出异常对象
throws定义在函数上,用于抛出异常类,可抛出多个,用逗号隔开。
当函数内有throw抛出异常对象,并未进行try处理,必须在函数上声明,
否则编译失败。
注意:RuntimeException除外,即,函数内如果抛出的RuntimeException
异常,函数上可以不用声明。
-----------------------------------------------------------------
如果函数声明了异常,调用者需要进行处理,处理方式可throw也可try
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有抛也没有try),编译失败
该异常被标识,代表这可以被处理
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查。
该异常的发生,建议不处理,让程序停止,需要对代码进行修正
---------------------------------------------------------------
异常处理的语句:
try
{
需要被检测的代码
}
catch ()
{
处理异常的代码
}
finally
{
一定会执行的代码
}
有三种结合格式:
1、 try
{
}
catch ()
{
}
2、 try
{
}
finally
{
}
3、 try
{
}
catch ()
{
}
finally
{
}
注意:
1、finally中定义的通常是 关闭资源代码,因为资源必须释放
2、finally只有一种情况不会执行。当执行到System.exit(0);
finally不会执行。【详见day10中的ExceptionDemo5】
-----------------------------------------------------------------
自定义异常:
定义类继承Exception或者RuntimeException
1、为了让该自定义类具备可抛性
2、让该类具备操作异常的共性方法
当要定义自定义异常的信息时,可以使用父类已经定义好的功能
异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常:
按照java的面向对象思想,将程序中出现的特有问题进行封装
-----------------------------------------------------------------
异常的好处:
1、将问题进行封装
2、将正常流程代码和问题处理代码相分离,便于阅读
异常的处理原则:
1、处理方式两种:try或者throws
2、调用到抛出异常的功能时,对象抛出几个,就处理几个
一个try对应多个catch
3、多个catch,父类的catch放到最下面
4、catch内,需要定义针对性的处理方式。
千万不要简单的定义printStackTrace或者输出语句。
也不要不写,要有针对性的处理方式。
当捕获到的异常,本功能处理不了时,可以继续在catch中抛出
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常
可以将异常转换后,再抛出和该功能相关的异常。
或者异常可以处理,当需要将异常产生的和本功能相关的问题
提供出去让调用者知道,并处理。
try
{
throw new AException()
}
catch (AException e)
{
throw new BExcption();
}
也可将捕获异常处理后,转换新的异常
try
{
throw new AException()
}
catch (AException e)
{
//对AException处理
throw new BExcption();
}
比如,汇款的例子。
异常的注意事项:(非常重要)
在子父类覆盖时,
1、子类抛出的异常必须是父类的异常的子类或者子集
2、如果父类或者接口没有异常抛出时,子类覆盖出现异常,
只能try不能抛。
详情参阅: ExceptionTest.java 和 ExceptionTest1.java
【老师用电脑上课】 【求图形面积】
//类的修饰符在权限上只有两个,一个是默认权限,一个是公有权限。
jar包的功能,把类都封装完成后,还可以运行。
以后想使用老师定义的工具,老师只把jar包给我就行。
我只要做一件事就行:把jar包放到classpath路径下。
那么jar包里的数据或者对象就都能用了。
我们在进行开发的时候,总要去找一些对象来完成是比较方便的,如果
java网站没有提供现有的工具,一些互联网的资源有很多,比如阿巴西
网站,提供了一些对java对象又进行简单封装的常用的工具。如客户端
工具,这些工具不需要自己编写了,只要到网站上把它下载下来就行了
。下载完成,那是一个zip包,解压缩后,里面有一个jar包,还有一个
jar包所对应类的说明文档。把jar包放到classpath路径下并打开里面的
文档,查阅里面的工具就行了。
相关文章推荐
- 黑马程序员--面向对象的设计原则--java学习日记5(扩展知识)
- 黑马程序员--Java学习日记之面向对象(多态,接口和其他关键字)
- 黑马程序员--Java学习日记之面向对象(封装,this和static,继承)
- 黑马程序员java学习日记九 面向对象的理解
- 黑马程序员_JAVA学习日记_面向对象2
- 黑马程序员_java学习日记_面向对象
- 黑马程序员Java学习日记(2)面向对象
- 黑马程序员[andriod]java基础学习日记四——面向对象的总结
- 黑马程序员--【学习日记三】——java面向对象(一)
- 黑马程序员--Java学习日记之面向对象(封装,继承和构造方法)
- 黑马程序员-JAVA学习日记-面向对象1
- 黑马程序员_Java学习日记第二天--面向对象
- 黑马程序员--Java学习日记之面向对象(多态和匿名内部类)
- 黑马程序员Java学习日记(7)GUI
- 黑马程序员_Java学习日记num13
- 黑马程序员——java高新技术学习日记(3)
- 黑马程序员--Java学习日记之集合(map集合和collections类)
- 黑马程序员 java学习笔记——面向对象1:封装
- 黑马程序员_java学习日记_Java高新技术_反射(二)
- 黑马程序员_java学习日记_Java基础小知识学习整理