黑马程序员 Object类，包和匿名内部类

------- android培训、java培训、期待与您交流！ ----------

1：Object类(重点)
     (1)是所有类的根类，超类。
          java中提供的类以及我们自定义的类都直接或者间接的继承自Object类。
     (2)Object类中的方法
         A:void finalize()
            当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
         B:Class getClass()
            获取对象的字节码文件的描述类，后面再讲反射的时候还会在说这个类。
           String name = s.getClass().getName();
        C:int hashCode()
           获取对象的哈希值。其实就是对象的内存地址值十进制表示
        D:String toString()
          返回对象的字符串表示。
          表示格式：
          getClass().getName()+"@"+Integer.toHexString(hashCode());

          一般我们输出对象名的时候，其实底层调用的就是该对象的toString()方法。
          这种返回没有意义，所以，我们会重写这个方法，显示类的成员变量信息。
        E:boolean equals(Object obj)
           用于比较两个对象的地址值是否相同。
           我们获取对象后，比较它的地址值意义不大。所以也会对这个方法进行重写。
          重写要完成什么功能，是根据需求定的。

          假如：有一个学生类，其中有一个int类型的age成员变量。我们需要用此方法
          实现比较学生的年龄是否相同。

          public boolean equals(Object obj) //向上转型
          {
             //为了提高效率
             if(this == obj)
             {
               return true;
             }

            //为了提高程序的健壮性
             if(!(obj instanceof Student))
              {
                return false;
              }

             //向下转型
            Student s = (Student) obj;
             return this.age == s.age;
             }
 (3)==和equals的用法。
       A:==怎么用？
          **可以用于比较基本数据类型，比较的就是基本数据类型的值是否相等。
          **可以用于比较引用数据类型，比较的是对象的地址值是否相等。
       B:equals怎么用？
          equals只能用于比较引用数据类型的。
          **Object提供的equals是用于比较对象地址值是否相同。
          **自定义类中，如果重写了equals方法，那么就是按照你自己的需求来比较的。
 
          String str = new String("hello");
          String str2 = new String("hello");

          sop(str.equals(str2)); //true
 (4)练习：
      有一个学生类(姓名，年龄)。
      需要提供一个功能：这个功能是用于比较学生的姓名和年龄是否同时相同。
                    如果同时相同，那么，我就认为这是同一个学生。返回true。

      Student s1 = new Student("张国荣",20);
      Student s2 = new Student("张国荣",20);

      sop(s1.equals(s2)); //false

2：package关键字
     (1)包：其实就是文件夹。用于区分不同包下相同的类名。
     (2)好处：
          A：对类文件进行分类管理。
          B：给类提供了多层命名空间
          aaa.Demo
          bbb.Demo
          C：写在程序文件的第一行。
          D：包也是一种封装形式。
 (3)包的关键字是：package
         格式：
         单层包
         package 包名;
         多层包
         package 包1.包2.包...;
 (4)带包的类如何运行呢？
      A:首先编译这个类文件
         其次，手动创建包名，把class文件放入包中。
         最后，访问格式
         包名.类名
      B:java提供了另外一个格式
         javac -d . 类文件

         - d：表示后面跟的是目录
   .     ：表示的是当前目录

        编译：javac -d . PackageDemo.java
        执行：java cn.itcast.PackageDemo
 (5)不同包下的类是如何访问的？
      A:被访问的包中的类权限必须是public的。
      B:类中的成员权限：public或者protected(protected 这个时候，
          PackageDemo2要是Tool的子类才行)
 (6)练习：
       如果访问写在包中的类。

3：import关键字
      (1)导入包的关键字
      (2)格式：
          import 包名;
 (3)注意：
      A:一个程序文件中只有一个package，可以有多个import。
      B:用来导包中的类，不导入包中的包。
      C:通常写import  mypack.Demo;
          而不写import mypack.*;为什么？

         明确自己使用的类。
 (4)关键字的顺序
       类，包，导包这些关键的顺序。

       包 -- >  到包 -- > 类

        package xxx.yyy.zzz;

        import java.util.Scanner;

        class Demo
        {
 
        }

4：权限修饰符
                      本类中 同一个包中 不同包中的子类中 不同包中
      private      OK
      默认          OK          Ok 
      protected  OK          Ok                OK
      public        OK          Ok                OK                     Ok

5：不同修饰符可以修饰哪些内容
                 类 构造方法 成员变量 成员方法 
private             OK           OK          OK
默认          Ok  Ok            Ok          OK
protected         OK           OK          Ok
public        Ok  Ok            OK          OK
static                                OK          Ok
final           Ok                  OK          OK
abstract    Ok                                  OK

一般格式：
            成员变量：
            权限修饰符+static/final+数据类型+成员变量名
            public static final int NUM = 10;
 
 成员方法：
           权限修饰符+static/final/abstract+返回类型+方法名

           权限修饰符只能有一个，如果没写就是默认权限。

6：内部类(次重点)
     (1)把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。
     (2)访问形式：
         A:内部类可以直接访问外部类中的成员。
         B:外部类要想访问内部类的成员，必须创建对象访问。
     (3)什么使用时候内部类呢？
         假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，
         需要创建对象访问，这个时候，就可以把A类定义为B类的内部类。
     (4)内部类的位置
         A:成员位置
             **可以被private修饰(Body，Heart)
             **可以被static修饰。(它访问的外部类的成员必须是静态的)

            class Outer
            {
               int num = 10;

               class Inner
               {
                  public void show()
                  {
                   sop(num);
                  }
               } 

              public void method()
               {
                  Inner i = new Inner();
                  i.show();
               }
             }

  注意：
       如果测试类中想直接访问内部类，格式如下
       外部类名.内部类名 对象名 = 外部类对象.内部类对象;
       Outer.Inner oi = new Outer().new Inner();

       假如内部类使用static修饰的，在测试类中使用，格式如下
       外部类名.内部类名 对象名 = new 外部类.内部类();
       Outer.Inner oi = new Outer.Inner();
 
  B:局部位置
       **可以直接访问外部类中的成员，也可以直接访问局部成员，但是
        局部成员要用final修饰。
 
    class Outer
   {
        int num = 10;

        public void method()
        {
               int num2 = 20;
               final int num3 = 30;

               class Inner
               {
                     public void show()
                     {
                            sop(num3);
                     }
               }

              Inner i = new Inner();
              i.show();
        }
    }

   注意：
           局部内部类不能用private和static修饰。

   (5)通过class文件我们就可以区分是否带有内部类，以及内部类的位置
        Outer$Inner:成员内部类
        Outer$1Inner:局部内部类

 (6)匿名内部类(局部内部类的简写) (重点)
     前提：继承一个类或者实现一个接口

     格式：
     new 父类名或者接口名()
     {
           重写父类方法或者实现接口中的方法。
           也可以自定义其他方法。
     };

  举例：
    interface Inter
    {
          public abstract void show();
    }

    class Outer
    {
           public void method()
           {
                new Inter()
                {
                     public void show()
                     {
                          sop("show");
                     }
                };

                //如何调用方法呢？
                new Inter()
               {
                     public void show()
                     {
                          sop("show");
                     }
                }.show();

               //或者
                Inter i = new Inter()
                {
                      public void show()
                      {
                           sop("show");
                      }
                };
             i.show();
            }
        }
 (7)面试题
  interface Inter
  {
   void show();
  }

  class Outer
  {
   //补齐代码，完成主方法中定义的功能
  }

  class Test
  {
   public static void main(String[] args)
   {
    Outer.method().show(); //自己名字的拼音
   }
  }