java常用API中Object类

一．    API中Object类：

   1：Object类：是所有类的根类，超类；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 instanceofStudent))

                     {

                            return false;

                     }

                     //向下转型

                     Student s = (Student) obj;

                     return this.age == s.age;

               }

3：==和equals的用法。

A:==怎么用？

                     **可以用于比较基本数据类型，比较的就是基本数据类型的值是否相等。

                     **可以用于比较引用数据类型，比较的是对象的地址值是否相等。

        B:equals怎么用？equals只能用于比较引用数据类型的。

                     **Object提供的equals是用于比较对象地址值是否相同。

                     **自定义类中，如果重写了equals方法，那么就是按照你自己的需求来比较的。例如：String类中的equals被重写了，比较的是字符串的内容：

                     String str = newString("hello");

                     String str2 = new String("hello");

                     sop(str.equals(str2));//true

  4.package关键字

       (1)包：其实就是文件夹。用于区分不同包下相同的类名。

       (2)好处：A：对类文件进行分类管理;B：给类提供了多层命名空间;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的子类才行)

       5.import关键字

       (1)导入包的关键字

       (2)格式：import包名;

       (3)注意：

              A:一个程序文件中只有一个package，可以有多个import。

              B:用来导包中的类，不导入包中的包。

              C:通常写import mypack.Demo;

       (4)关键字的顺序

              类，包，导包这些关键的顺序;包 -- > 到包 -- >类

              package xxx.yyy.zzz;

              import java.util.Scanner;

              class Demo

              {

              }

6：权限修饰符

               本类中      同一个包中  不同包中的子类中不同包中

private        OK

默认            OK          Ok             

protected  OK           Ok               OK

public          OK           Ok               OK                 Ok

 

A：不同修饰符可以修饰哪些内容

                    类  构造方法 成员变量 成员方法        

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+返回类型+方法名

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

 7.内部类

       (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 = newInner();

                            i.show();

                     }

              }

              注意：

                     如果测试类中想直接访问内部类，格式如下

                     外部类名.内部类名对象名 =外部类对象.内部类对象;

                     Outer.Inner oi = newOuter().new Inner();

                     假如内部类使用static修饰的，在测试类中使用，格式如下

                     外部类名.内部类名对象名 = new外部类.内部类();

                     Outer.Inner oi = newOuter.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 = newInner();

                            i.show();

                     }

              }

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

       (5)通过class文件我们就可以区分是否带有内部类，以及内部类的位置

              Outer$Inner:成员内部类

              Outer$1Inner:局部内部类

       (6)匿名内部类(局部内部类的简写) (重点)

              前提：继承一个类或者实现一个接口

              格式：

                     new 父类名或者接口名()

                     {

                            重写父类方法或者实现接口中的方法。

                            也可以自定义其他方法。

                     };

              举例：

              interface Inter

              {

                     public abstract voidshow();

              }

              class Outer

              {

                     public void method()

                     {

                            new Inter()

                            {

                                   public voidshow()

                                   {

                                          sop("show");

                                   }

                            };

                            //如何调用方法呢？

                            new Inter()

                            {

                                   public voidshow()

                                   {

                                          sop("show");

                                   }

                            }.show();

                            //或者

                            Inter i = newInter()

                            {

                                   public voidshow()

                                   {

                                          sop("show");

                                   }

                            };

                            i.show();

                     }

              }