黑马程序员-面向对象2
2015-10-29 18:43
465 查看
——-android培训java培训期待与您交流!———-
Object类中的equals(Object obj)方法:JDK文档中的解释:
小例子:
Object类中的toString()方法:JDK文档中的解释:
小例子:
概念:将一个类定义在另一个类的里面,对里面那个类就称为内部类。
访问规则:
1. 内部类可以直接访问外部类中的成员,包括私有。(能访问外部成员是因为内部类中的持有了一个外部类的引用,格式:外部类名.this)
2. 外部类要访问内部类,必须建立内部类对象。
访问格式:
当内部类定义在外部类的成员变量上,而且非私有,可以在外部其他类中直接建立内部类对象。格式:
当内部类在成员位置上,就可以被成员修饰符修饰。
比如:private,将内部类在外部类中进行封装;
如下例子:
二. 静态内部类
访问格式:
A. 访问静态内部类非静态成员
B. 访问静态内部类的静态成员
注意:当内部类中定义了静态成员,该内部类必须是static的;当外部类中的静态方法访问内部类时,内部类也必须是static的。
三. 局部内部类
内部类定义在局部时:不可以被成员修饰符修饰;可以直接访问外部类中的成员,因为还持有外部类中的引用,但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量。
当内部类处在外部类方法中的时候,调用方式如下:
局部内部类访问局部变量,局部变量要声明成final。
四. 匿名内部类
概念:匿名内部类就是内部类的简写格式。
定义前提:内部类必须是继承一个类或者实现接口。
匿名内部类的格式:new 父类或者接口(){定义子类的内容}
匿名内部类等价于一个匿名子类对象。带内容的对象。
匿名内部类中定义的方法最好不要超过3个。
概述:程序在运行时出现的不正常情况。
异常由来:java对不正常情况进行描述后的对象体现。也就是对现实生活中的的问题具体事物用java的类的形式进行描述,并封装成对象。
异常体系:java中错误和异常对象都是派生于Throwable类的一个实例,用户也可以自定义自己的异常类。
![](http://upload-images.jianshu.io/upload_images/53424-64f14f4ba85b1996.png)
对于Error一般不编写针对性的代码对其进行处理
对于Exception可以使用针对性的处理方式进行处理
未检查异常:派生于Rrror类或RuntimeException类的所有异常称为未检查异常。
检查异常:除上面类外的所有异常称为检查异常。
异常处理
格式:
例子:
声明异常
方法名() throws EOFException, IOException…把需要抛出的多个异常用分号隔开即可,对应的catch也应该有这几个异常处理方式。在需要的地方使用声明异常,一般使用try…catch来扑获异常。
throws:关键字用来声明异常。
多异常的处理
声明异常时,建议声明具体的异常,后续处理也可以更具体。
对方声明几个异常,就对应有几个catch块,不要定义多余的catch块。如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。
在进行catch处理时,catch中一定要定义具体的处理方式,不要简单定义一句:printStackTrace();工作上当作日志来处理保存起来,供开发人员分析解决问题使用。
自定义异常
因为实际项目中会出现特有的问题,而这些问题并未被java所描述并封装对象,对于这些特有问题可以按照java对问题的封装的思想,将特有的问题,进行自定义异常封装。
自定义异常。需要继承Exceptioin类。父类已经把异常信息操作都完成了,子类只需要在构造时, 将异常信息传递给父类通过super语句,就可以获取自定义异常信息。
自定义异常:必须是自定义类继承Exception。
继承Exception原因:因为异常类和异常对象都将被抛出,也是Throwable这个体系中的独有特点可以抛性,也就是只有在这个体系中的类和对象才可以被throws和throw操作。
throw和throws区别
throws使用在函数上,也就是方法小括号后和大括号前。throw使用在函数内。
throws后面跟的异常类,可以跟多个,用逗号隔开。throw后跟的是异常对象。
RuntimeException
Exception中的特殊异常子类:RuntimeException(运行时异常)。编译时不被检测的异常,包括RuntimeException和其子类。
特点:
如果在函数内抛出该异常,函数上可以不用声明,编译一样通过。
如果在函数上声明了该异常,调用者可以不用进行处理,编译一样的通过。
注意:
运行时异常不用在函数上声明,因为不需要让调用者处理,当该异常发生,希望程序停止因为在运行时出现了无法继续运算的情况,希望停止程序后,对代码进行修正。
自定义异常:如果该异常发生,无法在继续运行运算,就让自定义异常继承RuntimeException。
异常分类:
finally
finally代码块:定义一定执行的代码。通常用于关闭资源,比如说SQL源关闭。
在执行到
异常书写格式
异常的书写三种格式形式
1.第一种
catch是用于处理异常,如果没有catch就代表异常没被处理过,如果该异常时检测时异常,必须被声明。
2.第二种
3.第三种
异常与覆盖
子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该父类的子异常。
如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。
如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法发生了异常,就必须要就行try处理,绝对不能抛。
练习总结
1. Object类
是所有对象的直接或者间接的父类,也就是根类。该类中定义了所有对象都具备的功。Object类中的equals(Object obj)方法:JDK文档中的解释:
public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。 equals 方法在非空对象引用上实现相等关系: 自反性:对于任何非空引用值 x,x.equals(x) 都应返回 true。 对称性:对于任何非空引用值 x 和 y,当且仅当 y.equals(x) 返回 true 时,x.equals(y) 才应返回 true。 传递性:对于任何非空引用值 x、y 和 z,如果 x.equals(y) 返回 true,并且 y.equals(z) 返回 true,那么 x.equals(z) 应返回 true。 一致性:对于任何非空引用值 x 和 y,多次调用 x.equals(y) 始终返回 true 或始终返回 false,前提是对象上 equals 比较中所用的信息没有被修改。 对于任何非空引用值 x,x.equals(null) 都应返回 false。 Object 类的 equals 方法实现对象上差别可能性最大的相等关系;即,对于任何非空引用值 x 和 y,当且仅当 x 和 y 引用同一个对象时,此方法才返回 true(x == y 具有值 true)。 注意:当此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。 参数: obj - 要与之比较的引用对象。 返回: 如果此对象与 obj 参数相同,则返回 true;否则返回 false。
小例子:
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/20. */ public class EqualsDemo { public static void main(String[] args) { Demo d1 = new Demo(4); Demo d2 = new Demo(5); Person p = new Person(); System.out.println(d2.equals(p)); } } class Demo{ private int num; Demo(int num) { this.num = num; } //覆盖object类中的equals方法比较两个对象。 public boolean equals(Object obj) { //判断obj对象是否是Demo类的实例 if(!(obj instanceof Demo)) { return false; }else { } //进行强制向下转换 Demo d = (Demo)obj; return this.num == d.num; } } class Person{ }
Object类中的toString()方法:JDK文档中的解释:
public String toString() 返回该对象的字符串表示。通常,toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。 Object 类的 toString 方法返回一个字符串,该字符串由类名(对象是该类的一个实例)、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说,该方法返回一个字符串,它的值等于: getClass().getName() + '@' + Integer.toHexString(hashCode()) 返回: 该对象的字符串表示形式。
小例子:
/** * Created by Sergio on 2014/11/24. */ public class ToStringDemo { public static void main(String[] args) { Demo2 d2 = new Demo2(4); System.out.println(d2.toString()); } } class Demo2{ public int num; Demo2(int num){ this.num = num; } //覆写toString()方法,返回自定义内容 public String toString() { return "Demo2:" + num; } }
2. 内部类
一. 概述概念:将一个类定义在另一个类的里面,对里面那个类就称为内部类。
访问规则:
1. 内部类可以直接访问外部类中的成员,包括私有。(能访问外部成员是因为内部类中的持有了一个外部类的引用,格式:外部类名.this)
2. 外部类要访问内部类,必须建立内部类对象。
访问格式:
当内部类定义在外部类的成员变量上,而且非私有,可以在外部其他类中直接建立内部类对象。格式:
外部类名.内部类名 对象名= 外部类对象.内部类对象 OuterClass.InnerClass in = new OuterClass().new InnerClass();
当内部类在成员位置上,就可以被成员修饰符修饰。
比如:private,将内部类在外部类中进行封装;
如下例子:
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/25. */ public class InnerClassDemo { public static void main(String[] args) { //访问内部类的方式 OuterClass.InnerClass in = new OuterClass().new InnerClass(); in.innerMethod(); } } class OuterClass{ private int x = 3; //定义内部类InnerClass。内部类可以被private修饰,因为处在类的成员位置上。 class InnerClass{ int x = 4; //定义内部类方法 void innerMethod() { int x =6; //此处x没有前置修饰,直接打印6,找最近的变量。 //此处x前置为this,打印为4,访问的是内部类的成员变量。 //此处x前置为OuterClass.this,打印为3,访问的是外部类的成员变量 System.out.println("x = " + x); System.out.println("x = " + this.x); System.out.println("x = " + OuterClass.this.x); } } //外部类访问内部类方法方式 public void outerMethod() { //创建内部类对象 InnerClass in = new InnerClass(); //引用内部类对象的方法 in.innerMethod(); } }
二. 静态内部类
访问格式:
当内部类在成员位置上,就可以被成员修饰符修饰。static修饰:内部类就具备static的特性,当内部类被static修饰后,只能直接访问外部类中的static成员,有访问权限。
A. 访问静态内部类非静态成员
new OuterClass2.InnerClass().innerMethod();
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/25. */ public class InnerClassDemo2 { public static void main(String[] args) { //静态内部类中的非静态成员访问方式 new OuterClass2.InnerClass().innerMethod(); } } class OuterClass2{ //定义静态变量 private static int x = 3; //定义内部类InnerClass。内部类可以被static修饰,因为处在类的成员位置上。 static class InnerClass{ void innerMethod() { System.out.println("x = " + x ); } } //外部类访问内部类方法方式 public void outerMethod() { //创建内部类对象 InnerClass in = new InnerClass(); //引用内部类对象的方法 in.innerMethod(); } }
B. 访问静态内部类的静态成员
OuterClass2.InnerClass.innerMethod();
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/25. */ public class InnerClassDemo2 { public static void main(String[] args) { //静态内部类中的静态成员访问方式 OuterClass2.InnerClass.innerMethod(); } } class OuterClass2{ //定义静态变量 private static int x = 3; //定义内部类InnerClass。内部类可以被static修饰,因为处在类的成员位置上。 static class InnerClass{ //静态成员方法 static void innerMethod() { System.out.println("x = " + x ); } } //外部类访问内部类方法方式 public void outerMethod() { //创建内部类对象 InnerClass in = new InnerClass(); //引用内部类对象的方法 in.innerMethod(); } }
注意:当内部类中定义了静态成员,该内部类必须是static的;当外部类中的静态方法访问内部类时,内部类也必须是static的。
三. 局部内部类
内部类定义在局部时:不可以被成员修饰符修饰;可以直接访问外部类中的成员,因为还持有外部类中的引用,但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量。
当内部类处在外部类方法中的时候,调用方式如下:
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/27. */ public class InnerClassDemo3 { public static void main(String[] args) { InnerClass3 i = new InnerClass3(); i.innerMethod(); } } class InnerClass3{ private int x = 3; void innerMethod() { //内部类处在局部变量上,并且不能被static所修饰 class Inner{ void innerMethod() { System.out.println("x = " + x); } } //局部内部类调用方式.注意,调用的顺序,必须是在内部类下方处调用,因为有了对象才能调用 new Inner().innerMethod(); } }
局部内部类访问局部变量,局部变量要声明成final。
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/27. */ public class InnerClassDemo3 { public static void main(String[] args) { InnerClass3 i = new InnerClass3(); i.innerMethod(2); i.innerMethod(7); } } class InnerClass3{ private int x = 3; void innerMethod(final int a) { //局部变量要被final所修饰 final int y = 6; //内部类处在局部变量上,并且不能被static所修饰 class Inner{ void innerMethod() { System.out.println(a); } } //局部内部类调用方式.注意,调用的顺序,必须是在内部类下方处调用,因为有了对象才能调用 new Inner().innerMethod(); } }
四. 匿名内部类
概念:匿名内部类就是内部类的简写格式。
定义前提:内部类必须是继承一个类或者实现接口。
匿名内部类的格式:new 父类或者接口(){定义子类的内容}
匿名内部类等价于一个匿名子类对象。带内容的对象。
匿名内部类中定义的方法最好不要超过3个。
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/29. */ public class AnonymousInnerClassDemo { public static void main(String[] args) { AnonymousInner a = new AnonymousInner(); a.function(); } } //匿名内部类前提被继承类 abstract class InnerClassTest{ //抽象方法 public abstract void demoMethod(); } //继承内部类接口也如此 class AnonymousInner{ int x = 3; public void function(){ //匿名内部类书写方式。用父类代替子类产生对象并覆写父类方法,最后调用子类覆写父类的方法和其自身类的其他函数内容 new InnerClassTest(){ public void demoMethod(){ System.out.println("x==" + x); } }.demoMethod(); } }
3. 异常
概述概述:程序在运行时出现的不正常情况。
异常由来:java对不正常情况进行描述后的对象体现。也就是对现实生活中的的问题具体事物用java的类的形式进行描述,并封装成对象。
异常体系:java中错误和异常对象都是派生于Throwable类的一个实例,用户也可以自定义自己的异常类。
![](http://upload-images.jianshu.io/upload_images/53424-64f14f4ba85b1996.png)
对于Error一般不编写针对性的代码对其进行处理
对于Exception可以使用针对性的处理方式进行处理
未检查异常:派生于Rrror类或RuntimeException类的所有异常称为未检查异常。
检查异常:除上面类外的所有异常称为检查异常。
异常处理
格式:
try { 需要被检测的代码 } catch (异常类 变量) { 处理异常的代码(处理方式) } finally { 一定会被执行的语句 }
例子:
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/29. */ public class ExceptionDemo { public static void main(String[] args) { ExceptionDemo ed = new ExceptionDemo(); //扑获异常 try { int x = ed.div(3, 0); System.out.println(" x = " + x); }catch (Exception e)//处理异常。Exception e = new ArithmeticException();多态。 { //异常信息 System.out.println("出错了"); System.out.println(e.getMessage());//异常信息 System.out.println(e.toString());//异常名称:异常信息 e.printStackTrace();//异常名称,异常信息,异常出现的位置。JVM默认的异常处理机制,就是在调用此方法,打印异常的堆栈跟踪信息 } } //定义方法 int div(int a, int b) { return a / b; } }
声明异常
方法名() throws EOFException, IOException…把需要抛出的多个异常用分号隔开即可,对应的catch也应该有这几个异常处理方式。在需要的地方使用声明异常,一般使用try…catch来扑获异常。
throws:关键字用来声明异常。
多异常的处理
声明异常时,建议声明具体的异常,后续处理也可以更具体。
对方声明几个异常,就对应有几个catch块,不要定义多余的catch块。如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。
在进行catch处理时,catch中一定要定义具体的处理方式,不要简单定义一句:printStackTrace();工作上当作日志来处理保存起来,供开发人员分析解决问题使用。
自定义异常
因为实际项目中会出现特有的问题,而这些问题并未被java所描述并封装对象,对于这些特有问题可以按照java对问题的封装的思想,将特有的问题,进行自定义异常封装。
自定义异常。需要继承Exceptioin类。父类已经把异常信息操作都完成了,子类只需要在构造时, 将异常信息传递给父类通过super语句,就可以获取自定义异常信息。
package com.sergio.lianxi; /** * Created by Sergio on 2014/11/30. */ public class ExceptionDemo2 { public static void main(String[] args) { DivDemo d = new DivDemo(); try { int x = d.div(4,-6); } catch (FuShuException e) { e.printStackTrace(); System.out.println("e.getValue(); = " + e.getValue()); } } } //自定义异常。需要继承Exceptioin类。父类已经把异常信息操作都完成了,子类只需要在构造时, // 将异常信息传递给父类通过super语句,就可以获取自定义异常信息 class FuShuException extends Exception{ //自定义属性来获取负数值 private int value; FuShuException(String message, int value) { super(message); this.value = value; } public int getValue(){ return value; } } class DivDemo{ //挡在函数内部出现了throws抛出异常对象,那么就必须要给对应的处理动作,在内部try。。。catch处理或者在函数上声明让调用者处理。 int div(int a, int b) throws FuShuException { if(b < 0){ throw new FuShuException("除数出现了负数", b); } return a / b; } }
自定义异常:必须是自定义类继承Exception。
继承Exception原因:因为异常类和异常对象都将被抛出,也是Throwable这个体系中的独有特点可以抛性,也就是只有在这个体系中的类和对象才可以被throws和throw操作。
throw和throws区别
throws使用在函数上,也就是方法小括号后和大括号前。throw使用在函数内。
throws后面跟的异常类,可以跟多个,用逗号隔开。throw后跟的是异常对象。
RuntimeException
Exception中的特殊异常子类:RuntimeException(运行时异常)。编译时不被检测的异常,包括RuntimeException和其子类。
特点:
如果在函数内抛出该异常,函数上可以不用声明,编译一样通过。
如果在函数上声明了该异常,调用者可以不用进行处理,编译一样的通过。
注意:
运行时异常不用在函数上声明,因为不需要让调用者处理,当该异常发生,希望程序停止因为在运行时出现了无法继续运算的情况,希望停止程序后,对代码进行修正。
自定义异常:如果该异常发生,无法在继续运行运算,就让自定义异常继承RuntimeException。
异常分类:
编译时被检测的异常、
编译时不被检测的异常。
package com.sergio.lianxi; /** * 需求:老师上课 * Created by Sergio on 2014/12/3. */ public class ExceptionDemo3 { public static void main(String[] args) { Teacher t = new Teacher("t"); try { t.lecture(); } catch (NoPlanException e) { System.out.println(e.toString()); System.out.println("换老师或者放假"); } } } //定义电脑类,定义电脑的部分功能 class Computer{ //定义电脑运行时的状态值,根据状态值判断出的问题 private int state = 2; //定义电脑运行类,继承自蓝屏和冒烟异常 public void run() throws BlueScreenException,SmokeException { if(state == 2) throw new BlueScreenException("蓝屏"); if(state == 3) throw new SmokeException("冒烟"); System.out.println("电脑运行"); } //电脑重启功能 public void reset() { state = 1; System.out.println("电脑重启"); } } //定义老师类 class Teacher{ private String name; private Computer cmp; Teacher(String name) { this.name = name; cmp = new Computer(); } //定义教学方法,并抛出当电脑出现问题老师无法处理时的异常 public void lecture()throws NoPlanException { try { cmp.run(); } catch (BlueScreenException e) { cmp.reset(); e.printStackTrace(); } catch (SmokeException e) { //throw语句后面别写运行语句。return亦同 test(); throw new NoPlanException("课程无法继续" + e.getMessage()); } } //定义练习方法 public void test() { System.out.println("练习"); } } //定义蓝屏异常 class BlueScreenException extends Exception{ BlueScreenException(String message) { super(message); } } //定义电脑冒烟异常 class SmokeException extends Exception{ //复写父类的构造方法 SmokeException(String message) { super((message)); } } //定义电脑冒烟抛出异常怎么处理 class NoPlanException extends Exception{ //覆写父类的构造方法 NoPlanException(String message){ super(message); } }
finally
finally代码块:定义一定执行的代码。通常用于关闭资源,比如说SQL源关闭。
在执行到
System.exit(0);finally不会被执行到。
异常书写格式
异常的书写三种格式形式
1.第一种
try {} catch() {}
catch是用于处理异常,如果没有catch就代表异常没被处理过,如果该异常时检测时异常,必须被声明。
2.第二种
try {} catch() {}
finally{}
3.第三种
try {} finally {}
异常与覆盖
子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该父类的子异常。
如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。
如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法发生了异常,就必须要就行try处理,绝对不能抛。
练习总结
package com.sergio.lianxi; /** * Created by Sergio on 2014/12/4. */ public class ExceptionDemoTest { public static void main(String[] args) { //实例化对象 Rec c= new Rec(-3,4); c.getArea(); System.out.println("完毕"); } } //用接口来抽象面积计算,实现类返回计算公式及值即可 interface Shape{ //定义求面积方法 public void getArea(); } class Rec implements Shape { //定义正方形的边长 private int len,wid; //构造函数 Rec(int len, int wid) { //判断非法之并在有异常的时候抛出异常 if(len <= 0 || wid <=0) throw new IllegalException("出现非法值"); this.len = len; this.wid = wid; } //覆盖接口中的方法 public void getArea() { System.out.println(len * wid); } } //定义非法值的抛出异常 class IllegalException extends RuntimeException { //定义构造方法返回信息 IllegalException(String message) { super(message); } }
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树
- [原创]java局域网聊天系统