Java基础---Object类、内部类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Object类

概述：

Object是所有对象的直接后者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。

boolean equals（Object obj）

相比较的是引用对象的地址值，而不是对象的值！

例：

class Demo	//extends Object
{
     private int num;
     Demo(int num)
     {
          this.num = num;
     }
     /*
     public boolean compare(Demo d)
     {
          return this.num == d.num;
     }*/

     public boolean equals(Object obj)	//Object obj = new Demo();
     {
          if(!(obj instanceof Demo))
           return false;

          Demo d = (Demo)obj;
          return this.num == d.num;
     }

}

class Person
{
}


class ObjectDemo
{
     public static void main(String[] args)
     {
          Demo d1 = new Demo(4);
          Demo d2 = new Demo(5);
          Person p = new Person();

          System.out.println(d1.equals(p));
     }
}

Oject类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同功能，没有必要重新定义。

只要演示父类中的功能，建立自己特有的比较内容即可。

Object类toString()

 Demo d1 = new Demo(4);
  //Demo d2 = new Demo(5);

  System.out.println(Integer.toHexString(d1.hashCode()));
  System.out.println(d1.toString());

运行结果:

toString())  == getClass().getName()+'@’+Integer.toHexString（hashCode()）

总结：Obejct类toString() 等于输出了    类名+@+哈希值的10进制形式。

内部类

概述：

将一个类定义在另一个类的里面，对面里面那个类就称为内部类（内置类，嵌套类）。

访问特点：

    内部类可以直接访问外部类中的成员，包括私有成员。

    而外部类要访问内部类中的成员必须要建立内部的对象。

例：

内部类的访问规则：

1、内部类可以直接访问外部类中的成员，包括私有。

    之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

2、外部类要访问内部类，必须建立内部类对象。

class Outer
{
     private int x= 3;

     static class Inner	//内部类
     {
          void function()
          {
               System.out.println("inner:"+x);
          }
     }

}

class InnerClassDemo
{
     public static void main(String[] args)
     {
      //Outer out = new Outer();
      //out.method();

      //直接访问内部类中的成员。
      //	 Outer.Inner in = new Outer().new Inner();
      //in.function();
     }
}

静态内部类

例：

class Outer
{
     private static int x= 3;

     static class Inner	//静态内部类
     {
          static void function()
          {
               System.out.println("inner:"+x);
          }
     }
 
     class Inner2
     {
          void show()
          {
               System.out.println("inner2 show");
          }
     }

     public static void method()
     {
          //Inner.function();
          new Inner2().show();
     }
}



class InnerClassDemo
{
     public static void main(String[] args)
     {
          Outer.method();

          //Outer.Inner.function();
          //new Outer.Inner().function();

          //Outer out = new Outer();
          //out.method();

          //直接访问内部类中的成员。
          //	 Outer.Inner in = new Outer().new Inner();
          //in.function();
     }
}

访问格式：

1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，

     可以直接建立内部类对象。

     格式：外部类名.内部类名     变量名 = 外部类对象.内部类对象;

     Outer.Inner in = new Outer().new Inner();

2、当内部类在成员位置上，就可以被成员修饰符所修饰。

        比如，private：将内部类在外部类中进行封装。

                static：内部类就具备static的特性。

      当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限

        在外部其他类中，如何直接访问静态内部类的非静态成员呢？

        new Outer.Inner().function();

        在外部其他类中，如何直接访问静态内部类的静态成员呢？   

        Outer.Inner.function();

    注意：当内部类中定义了静态成员，该内部类必须是static的。

              当外部类中的静态方法访问内部类是，内部类也必须是静态的。

内部类定义原则

     当描述事物时，事物的内部还有事物，该事物用内部类来描述。

    因为内部事物在使用外部事物的内容。

    例：

 class Outer
    {
         private static int x= 3;
          static class Inner	//静态内部类
         {
              static void function()
              {
                   System.out.println("inner:"+x);
              }
         }
 
         class Inner2
         {
              void show()
              {
                   System.out.println("inner2 show");
              }
         }
         public static void method()
         {
              //Inner.function();
              new Inner2().show();
         }
    }
class InnerClassDemo
{
     public static void main(String[] args)
     {
          Outer.method();
           //Outer.Inner.function();
          //new Outer.Inner().function();
          //Outer out = new Outer();
          //out.method();
          //直接访问内部类中的成员。
          //	 Outer.Inner in = new Outer().new Inner();
          //in.function();
     }
}

匿名内部类

例：

class Outer
{
     int x = 3;

     void method(final int a)
     {
          final int y = 4;
      class Inner
      {
           void function()
           {
                System.out.println(a);
           }
      }

      new Inner().function();
     }
}


class InnerClassDemo3
{
     public static void main(String[] args)
     {
          Outer out = new Outer();
          out.method(7);
          out.method(8);
     }
}

内部类定义在局部时，

1、不可以被成员修饰符修饰

2、可以直接访问外部类中的成员，因为还持有外部类中的应用。

    但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量

匿名内部类：

1、匿名内部类其实就是内部类的简写格式。

2、定义匿名内部类的前提：

    内部类必须是继承一个类或者实现接口。

3、匿名内部类的格式：  new 父类或者接口(){定义子类的内容}

4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5、匿名内部类中定义的方法最好不要超过3个。

例：

abstract class AbsDemo
{
     abstract void show();
}


class Outer
{
     int x= 3;
     /*
     class Inner extends AbsDemo
     {
          void show()
          {
               System.out.println("show:"+x);
          }
     }
 */
     public void function()
     {
          //new Inner().show();
          //Inner in = new Inner();
          //in.show();
          //in.abc();

          AbsDemo d = new AbsDemo()
          {
               int num = 9;
               void show()
               {
                    System.out.println("num="+num);
               }
               void adc()
               {
                    System.out.println("haha");
               }
          };

          d.show();
          //d.abc(); 编译失败

    }
}

class InnerClassDemo4
{
     public static void main(String[] args)
     {
          new Outer().function();
     }
}

练习：

interface Inter
{
     void method();
}

class Test
{
     //补足代码。通过匿名内部类。
 
     static Inter function()
     {
          return new Inter()
          {
               public void method()
               {
                    System.out.println("method");
               }
          };
     }
}


class InnerClassTest
{
     public static void main(String[] args)
     {
          //Test.function():Test类中有一个静态的方法function。
          //.method():function这个方法运算后的结果是一个对象。
          //而且是一个Inter类型的对象。
 
          Test.function().method();

          Inter in = Test.function();
          in.method();

          show(new Inter()
          {
               public void method()
               {
                    System.out.println("method show run");
               }
          });
 }

     public static void show(Inter in)
     {
      in.method();
     }
}

总结：内部类就是用new的方式创建一个子类并进行操作。