黑马程序员-面向对象2

-------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
{}
异常与覆盖
  1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该父类的子异常。
  1. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
  1. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须要就行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);
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,602评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,442评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,878评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,306评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,330评论 5赞 373
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,071评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,382评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,006评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,512评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,965评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,094评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,732评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,283评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,286评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,512评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,536评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,828评论 2赞 345

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,587评论 18赞 399
  • Java基础知识总结
    一：java概述：1，JDK：Java Development Kit，java的开发和运行环境，java的开发工...
    ZaneInTheSun阅读 2,629评论 0赞 11
  • Java
    1.import static是Java 5增加的功能,就是将Import类中的静态方法，可以作为本类的静态方法来...
    XLsn0w阅读 1,213评论 0赞 2
  • MATLAB面向对象编程模式上
    写在之前 因为简书字数限制，完整版地址：https://www.zybuluo.com/hainingwyx/no...
    hainingwyx阅读 13,867评论 0赞 41
  • 冬日私语(突然就想说些啥)
    立冬以后天气一日低过一日，小雪过后更甚，室内和室外的温差让人觉得不是一个世界。供暖的室内暖煦煦的，再配上窗外温暖的...
    辞桉阅读 213评论 0赞 0