黑马程序员_面向对象05
来源:互联网 发布:淘宝好的布料店 编辑:程序博客网 时间:2024/06/16 00:28
------- android培训、java培训、期待与您交流! ----------
面向对象的思想和先关练习前面已经提到了。
本篇博客写了关于异常和一些面向对象的知识点。
首先我们来看看内部类。
内部类:
将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
访问特点:
1、内部类可以直接访问外部类中的成员,包括私有。
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式外部类名.this
2、外部类要访问内部类,必须建立内部类对象。
而且内部类能被private修饰,而外部类不行。
那下面我们就举例看看:
class Outer{private int x = 3;class Inner //内部类{int x = 4;void function(){int x = 6;System.out.println("inner:" + x);//当为x的时候打印出来为局部变量6.当为this.x打印的为4,当为Outer.this.x打印的为3}}void method(){Inner in = new Inner();in.function();}}class InnerClassDemo {public static void main(String[] args) {/*通过外部类调用内部类里面的方法Outer out = new Outer();out.method();System.out.println("Hello World!");*//*能不能直接访问内部类中的成员。Outer.Inner in = new Outer().new Inner();in.function();*/}}
访问格式:
1、当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中直接建立内部类对象。
格式----外部类名.内部类名 变量名 = 外部类对象.内部类对象。
Outer.Inner in = new Outer().new Inner();
2、当内部类在成员位置上,就可以被成员修饰符所修饰,
比如:private:将内部类在外部类中进行封装。
static:内部类就具备了静态的特性。
当内部类被static修饰后,只能直接访问外部类中static成员,出现了访问局限。
在外部其他类中,如何直接访问静态内部类的非静态成员呢?
new Outer.Inner().function();
在外部其他类中,如何直接访问静态内部类的静态成员呢?
Outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是静态的。
当外部类的静态方法访问内部类时,
当描述事物时,事物的内部还有事物,该事物用内部类来描述。
因为内部事物在使用外部事物。
class Outer{private static int x = 3;static class Inner //静态内部类{static void function(){System.out.println("inner:" + x);}}}class InnerClassDemo {public static void main(String[] args) {/*Outer.Inner.function();new Outer.Inner().function();能不能直接访问内部类中的成员。Outer.Inner in = new Outer().new Inner();in.function();*/}}
匿名内部类:
1、匿名内部类其实就是内部类的简写格式。
2、定义匿名内部类的前提:
内部类必须是继承一个或者实现接口。
3、匿名内部类的格式:new 父类或者接口(){定义子类的内容}
4、其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。
5、匿名内部类中定义的方法最好不要超过3个。
匿名内部类的出现就是很大程度上简化了代码。
abstract class AbsDemo{abstract void show();}class Outer{int x = 3;/*class Inner extends AbsDemo{void show(){System.out.println("show :" + x);}}*/public void function(){//new Inner().show();new AbsDemo(){void show(){System.out.println("x=" + x);}}.show();}}class InnerClassDemo4 {public static void main(String[] args) {System.out.println("Hello World!");}}interface Ineter{void method();}class Test{/*public class Inner implements Inner{public void method(){System.out.println("methos run");}}static Inter function(){return new Inner();}*///通过匿名内部类调用。static Inter function(){return new Inter(){public void method(){System.out.println("methos run");}};}}class InnerClassTest {public static void main(String[] args) {//Test.function:代表Test类中有一个静态的方法function。//.method:function这个方法运算后的结果是一个对象,而且是一个Inner类型的对象。//因为只有是Inter类型的对象,才可以调用。Test.function().method();System.out.println("Hello World!");}}
我们来看看异常这个大体系,个人认为理解这个很重要。
异常:
异常的体系:
throwable
error
通常出现重大问题:运行的类不存在或者内存溢出等。
exception
在运行时运行出现的一些情况,可通过try catch finally
exception和error的子类名都是以父类名作为后缀。
异常就是程序在运行时,出现不正常情况。
异常由来:问题也是现实生活中一个具体的事物,也可以通过JAVA的类的形式进行描述,并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分,两种:一种是严重的问题,一种是非严重的问题。
对于严重的:java通过error类进行描述。
对于error一般不编写针对性的代码进行处理。
对于非严重的,java通过exception类进行描述。
对于Exception可以使用正对性的处理方式进行处理。
无论Error或者Exception都具有一些共性。
比如:不正常情况的信息,引发原因等。
自定义异常:
因为项目中会出现特有的问题,
而这些问题并未被java所描述封装,
所有对于这些特有的问题可以按照java对问题的封装思想,
将特有的问题,进行自定义的封装。
自定义异常
需求:在本程序中,对于除数是负数,也视为错误的,是无法进行运算的。
那么就需要对这个问题进行自定义的描述。
当函数内部出现了throw抛出异常对象,那么就必须给对应的处理动作,
要么在内部try catch处理,
要么在函数上声明让调用者处理。
如何定义异常信息呢?
以为父类张已经把异常信息的操作都完成了,
所以子类重要在构造函数时,将异常信息传递给父类通过super语句
那么就可以直接通过getMessage方法获取自定义的异常信息。
自定义异常:
必须是自定义类继承Exception
继承Exception的原因,因为异常类和异常对象都被抛出,
他们都具备可抛性,这个可抛性是Throwable这个体系中独有的特点,
只有这个体系中的类和对象才能被throw和throws操作。
class FuShuException extends Exception//定义的负数异常类。{private int value;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 //在功能上通过throws的关键字声明了该功能有可能会出现问题。{if(b<0)throw new FuShuException("出现了除以负数的情况/by FuShu" ,b);//手动通过throw关键字抛出一个自定义异常对象。return a/b;}}class ExceptionDemo2{public static void main(String[] args) {Demo d = new Demo();try{/*发现打印的结果自由异常的名称,却没有异常信息。因为自定义的异常并未定义信息。*/int x = d.div(4,-1);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");}}
上诉代码对异常的两种常见处理方式throws(throw) , 和 try(){}catch(){};进行了简单的叙述。
throws(throw)
加在方法大括号之前,将方法中没有 try catch 的异常抛出去,交给其他调用该方法的方法 处理,,如果其他方法还不处理,可以继续往外throws。
try catch
需要在内部自行处理的异常,通常会做一些相对应的处理。
throw和throws的区别:
throw使用在函数内。
throws使用在函数上。
throws后面跟的异常类可以跟多个,用“,”隔开。
throw后跟的是异常对象。
exception中有一个特殊的子类异常RuntimeException。
如果在函数内抛出该异常,函数上可以不用声明,编译一样通过。
如果在函数上声明了该异常,调用者可以不用处理。编译一样通过。
注意:之所以不用在函数上声明,是因为不需要让调用者处理,
当该异常发生,谢昂程序停止,因为在运行时,出现了无法运算的情况,希望停止程序后
由程序员对代码进行修改。
自定义异常时:如果发生该异常的发生,无法在继续进行运算。
就让自定义异常继承RuntimeException.
对于异常分两种:
1、编译时被检测的异常。
2、编译时不被检测的异常。(运行时异常,RuntimeException以及其子类)
class FuShuException extends RuntimeException{FuShuException(String msg){super(msg);}}class Demo{int div(int a,int b){if(b<0)throw new FuShuException("除数为负数了");if(b==0)throw new ArithmeticException("被零除了");return a/b;}}class ExceptionDemo3 {public static void main(String[] args) {Demo d = new Demo();int x = d.div(4,-8);System.out.println("x="+x);System.out.println("over");}}
这就是RuntimeException的有点之处。可以不用在函数头声明,也不需要进一步处理。
finally代码块:无论如何一定会执行的代码。
通常用于关闭资源,例如关闭数据库。
记住一点catch适用于处理异常的。如果没有catch就代表异常没有被处理过,如果该异常是检测时的异常,那么必须声明出去。
try catch finally组成了异常的一大体系。他们之间关系是,try和finally可以单独存在,而catch不能。
第一个格式:try{}catch (){}第二个格式:try{}catch (){}finally{}第三个格式:try{}finally{}
异常在子父类覆盖中的体现。
1、子累在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。
2、如果父类抛出多个异常,那么子类在覆盖方法时,只能抛出父类异常的子集。
3、如果父类或者接口中的方法没有抛出异常,那么子类在覆盖方法时,也不可以抛出异常,
如果子类方法发生了异常,就必须进行try处理,绝对不能抛出。
class AException extends Exception{}class BException extends AException{}class CException extends Exception{}/*Exception|--AException|--BException|--CException*/class Fu{void show() throws AException{}}class Zi extends Fu{void show() throws AException//或者BException{}}class Exception7 {public static void main(String[] args) {System.out.println("Hello World!");}}
异常的练习:
有一个圆形和长方形:
都可以获取面积,对于面积如果出现非法数值,视为获取面积出问题。
问题通过异常来表示。
现在对这个程序进行基本设计。
class NoValueException extends RuntimeException//定义一个自定义异常的类继承自RuntimelException{NoValueException(String msg){super(msg);}}interface Shape//定义一个图形接口{public abstract void getArea();//有一个活的面积的抽象方法}class Rec implements Shape//有一个矩形类继承自图形{private double length,width;Rec(int length,int width){if(length<=0 || width<=0)throw new NoValueException("出现非法");//抛出了我们的自定义异常。this.length = length;this.width = width;}public void getArea(){System.out.println(length*width);}}class Circle implements Shape//圆形类继承自图形{public static final double PI = 3.14;private double radius;Circle(double radius){if(radius<=0)throw new NoValueException("出现非法");this.radius = radius;}public void getArea(){System.out.println(radius*radius*PI);}}class ExceptionTest1{public static void main(String[] args) {Rec r = new Rec(3,-4);r.getArea();Circle c = new Circle(2);c.getArea();System.out.println("Hello World!");}}
异常:
是什么? 是对问题的描述,将问题进行对象的封装。
异常体系:
|--Throwable
|--Erroe
|--Exception
异常体系的特点:
异常中的所有类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字操作。
只有异常体系具备这个特点。
throw和throws的用法:
throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个异常用逗号隔开。
当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,否则编译失败。
注意:RuntimeException除外,也就是说,函数内如果抛出的RuntimeException异常,函数上可以不用声明。
如果函数声明了异常,调用者需要进行处理,处理方法可以try和throw。
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有try或者throw),编译失败。
该异常被标识,代表这可以处理。
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检测。
该异常的发生,建议不处理,让程序停止,需要对代码进行修正。
注意:
1、finally中定义的通常是关闭资源代码,因为资源必须释放。
2、finally只有一种情况不会执行,就是当执行到System.exit(0); finally不会执行。
自定义异常:
自定义类继承Exception或者RuntimeException
1、为了让该自定义异常具备可抛性。
2、让该类具备操作异常的共性方法。
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
异常信息传递给父类的构造函数。
class MyException extends Exception {MyException(String msg){super(msg);}}
自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。
异常的好处:
1、将问题进行封装。
2、将正常流程代码和问题代码相分离,方便与阅读。
异常的处理原则:
1、处理有两种方式:try或者throw。
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){//对AException处理throw new BException;}
异常的注意事项:
在子父类覆盖时:
1、子类抛出的异常必须是父类异常的子类或者子集。
2、如果父类或者继承后没有异常抛出时,子类覆盖出现异常,只能try不能抛。
包(package)
对类文件进行分类管理。
给类提供多层命名空间。
卸载程序文件的第一行。
类名的全称是 包名.类名。
包也是一种封装形式。
总结:
包与包之间进行访问,被访问的包中的类以及类中的成员,需要被public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间可以使用的权限只有两种,public ,protected。
这就是面向对象的基本知识希望对大家有帮助。
------- android培训、java培训、期待与您交流! ----------
详细请查看:www.itheima.com
0 0
- 黑马程序员_面向对象05
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- 黑马程序员_面向对象
- Android项目中无法生成R文件的问题解决办法
- uiscrollview autolayout contentsize 偏移错误
- Java系列-final、static、finally、finalize的比较
- LeetCode Reverse Linked List II
- 环境搭建(二)spark1.0.2 (ubuntu10.0.4)
- 黑马程序员_面向对象05
- 将python2.7 添加进64位系统 的注册表
- BZOJ 3993 Sdoi2015 星际战争 二分答案+最大流
- Java深度历险(六)——Java注解
- HTML AJAX 简单数据JS
- Code 相关
- mac电脑中Shell快捷命令大全
- 利用prim算法得到最小生成树MST
- 第五周项目 1 深复制体验(3)