美文网首页Java学习
黑马程序员-面向对象2

黑马程序员-面向对象2

作者: 狼孩 | 来源:发表于2014-11-25 16:11 被阅读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
{}
    异常与覆盖
    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);
    }
}

    相关文章

      网友评论

        本文标题：黑马程序员-面向对象2

        本文链接：https://www.haomeiwen.com/subject/owxwtttx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        Java学习

        关于我们|服务条款|联系我们|黑马程序员-面向对象2|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！