面向对象的简单理解五

• Object类：重要的是所有类的父类，里面有两个方法 toString及equals,
• 所有的类否会覆写这两个方法

// Object类是所有类的父类，如果一个类没有明确声明继承自那个类
// 则肯定会继承Object类
class Person// extends Object
{
    public String toString()
    {
        return "Hello MLDN" ;
    }
};
public class OODemo01
{
    public static void main(String args[])
    {
        Person p = new Person() ;
        // 默认情况下打印对象，实际上就相当于调用对象中的toString方法
        System.out.println(p) ;//这个等价与System.out.println(p.toString)打印结果都是P的地址
//通过此我们可以覆写toString方法来完成，对各个类的打印不同
    }
};

• 看下equals方法的覆写：

class Person// extends Object
{
    private String name ;
    private int age ;
    public Person(String name,int age)
    {
        this.name = name ;
        this.age = age ;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
        {
            return false ;
        }
        Person per1 = this ;
        Person per2 = (Person)obj ;
        boolean flag = false ;
        if(per1==per2)
        {
            // 判断是否是同一个引用
            flag = true ;
        }
        else
        {
            if(per1.name.equals(per2.name)&&per1.age==per2.age)
            {
                flag = true ;
            }
        }
        return flag ;
    }
    public String toString()
    {
        return "姓名："+this.name+"，年龄："+this.age ;
    }
};
public class OODemo04
{
    public static void main(String args[])
    {
        Person p1 = new Person("AAAAA",30) ;
        // Person p2 = new Person("AAAAA",30) ;
        Person p2 = p1 ;//这样二者都是指的一个对象可以通过==来判断
        System.out.println(p1.equals("abc")) ;//防止不是传的person类可以进行instanceOf判断
    }
};

• 内部类，在图形化开发中用的比较多

 

class Outer
{
    private String info = "AAA --> BBBB" ;
    // 内部类
    class Inner
    {
        public void print()
        {
            System.out.println("INFO = "+info) ;
        }
    };
};
public class OODemo07
{
    public static void main(String args[])
    {
        Outer o = new Outer() ;
        Outer.Inner in = o.new Inner() ;
        in.print() ;
    }
};

class Outer
{
    private String info = "AAA --> BBBB" ;
    public void fun(final int len)//在方法中要是让内部类可以使用方法中的变量，则前面必须加上final，这个只是标记
    {
        class Inner
        {
            public void print()
            {
                System.out.println("len = "+len) ;
                System.out.println("INFO = "+info) ;
            }
        };
        new Inner().print() ;
    }
};
public class OODemo08
{
    public static void main(String args[])
    {
        new Outer().fun(10) ;
    }
};

 

• 匿名内部类：这个内部类只是用一次以后再也不会使用，匿名内部类实在抽象类和接口的基础上发展出来的

interface A
{
    public void fun() ;
}
class C
{
    public void fun2()
    {
        this.print(new A()
            {
                public void fun()
                {
                    System.out.println("AAA --> BBBB") ;
                }
            }
        ) ;
    }
    public void print(A a)
    {
        a.fun() ;
    }
};
public class OODemo10
{
    public static void main(String args[])
    {
        new C().fun2() ;
    }
};

• 异常：ArithmeticException,ArrayIndesOutBandsException,ArrayStoreException,IOException,FileNotFoundException，NullPointerException
• finally 不管程序是否出现异常，都要执行，一般用于释放资源