黑马程序员-面向对象2
2014-11-25 本文已影响85人
狼孩
-------android培训java培训期待与您交流!----------
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. 外部类要访问内部类，必须建立内部类对象。 -
访问格式：
1. 当内部类定义在外部类的成员变量上，而且非私有，可以在外部其他类中直接建立内部类对象。格式:外部类名.内部类名 对象名= 外部类对象.内部类对象 OuterClass.InnerClass in = new OuterClass().new InnerClass();
2. 当内部类在成员位置上，就可以被成员修饰符修饰。
比如：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();
}
}
五. 异常
概述
- 概述：程序在运行时出现的不正常情况。
- 异常由来：java对不正常情况进行描述后的对象体现。也就是对现实生活中的的问题具体事物用java的类的形式进行描述，并封装成对象。
-
异常体系：java中错误和异常对象都是派生于Throwable类的一个实例，用户也可以自定义自己的异常类。
Exception.png
1. 对于Error一般不编写针对性的代码对其进行处理
2. 对于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);
}
}
