黑马程序员：Object类：超父类的学习

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

Object：所有类的父类
所有对象都具备的内容不断地抽取，就到了一个顶层Object类中。
equals()方法
 所有对象都可以进行比较，我们之前用的都是比较数据(数值)时运算符
 而对象是不能比较运算符，所有对象都能比较，那就只能用Object 类的比较方法equals();
 为什么只用传一个比较对象boolean equals(Object  obj)，因为对象本身就是一个需要比较的对象
 equals的使用：
  equals 比较的是两个对象的地址值的方式
  d1.equals(d2) 比较的是两个引用是否指向同一个对象
 因为子类已经继承了父类 的所以功能，
 既然父类中已经提供了对对象相等的比较。可经直接使用，如果比较内容不是所需要，
 可以将其覆盖，保留其功能声明，定义自己所需的比较内容

 通常在开发时，每一个对象都具备该方法，但是每个对象都有自己的属性的比较方式
 所以都会覆盖该 方法建 立每个对象自己特定的判断相同的依据
 public boolean equals(Object obj)
 {
 //只要年龄相同，就是同龄人，就是相同对象
 既然要用到对象的特有内容。向下转型 
 if(obj instanceof Person)
 {
   return false ;  //在工作中是不会返回false 的而是抛出异常
 }
  Person p=(Person)obj;
 if(this.age==obej.age)
 
 }
toString方法： 把对象变成字符串
    Person p=new Person();  
    System.out.println(p.toString());  //在输出语句里，如果输出的是引用型变量，
					那会调用toString方法，将其变成字符串进行打印。


为了让自定义的对象对应的字符串表现形式有意义，
那就覆盖toString方法即可。
public String toString()
{
 return "Person"+age;
}

在以后的工作中，如果想要让自定的对象特定的字串形式更有意义
那就可以覆写Object类中的toString方法。
 建议所有子类都重写此方法

 getClass()方法：获取任意一个对象所属的字节码文件对象
  Person p1=new Person()
  Person p2=new Person();
  Class c1=p1.getClass();
  Class c2=p2.getClass(); //c1==c2 比较的是同一个字解码文件的对象
  System.out.println(c1.getName());打印类名

  hashCode()：拿到任何一个对象的哈希码值
   p1.getclass().getName()+"@"+Integer.toHexString(p.hashCode());

  native(本地)：jvm会自动去找windows的方法。
  -----------------------------------
  内部类

  将一个类中还有一个类
特点：
  内部类可以直接访问外部类中的成员
  外部类要访问内部类中的成员必须创建内部类的对象

  为什么要定义内部类？
  类是用于描述事物的，而事物中如果还有具体的事物，而且这个内部的事物在访问
  着所属事物 中的内容
  这时这个内部的事物，也需要用到类来描述。这个类就是内部类


  为什内部类可以直接访问外部类中的成员？
  因为内部类都 持有一个外部类的引用。外部类名.this
----------------------------------------
内部类的修饰符
 当内部类定义在外部类的成员位置上时，
 可以使用成员的修饰来进行内部类的修饰


 1,权限修饰符
    默认的(default)或者公有的(public )
     可以直接访问内部类
     外部类名。内部类名 变量名=new 外部类对象()。new 内部类对象()
    私有的(private)
      是不可以直接在外部访问
    
  内部类也可以被修饰符修饰


  static 修饰符：
	内部类被静态修饰，出现访问局限性，只能访问外部中的静态成员
	内部类被静态后，会随着外部类的加载而加载
	静态内部类的格式：new Outer.Inner();
	   直接new内部类对象，调用内部类中的非静态成员
	   
如果内部类中定义了静态成员，该内部类必须被静态修饰

     
记住：内部类只有定义在外部类的成员位置上，才具备这些修饰符

  class Outer
  {
   int num=4;
   //内部类
   class Inner
   {
    void method()
    {
    }
   
   }

   public void show()
   {
     Inner in=new Inner()
      in.method();
       外部类想要调用内部类的时候 就要创建对象进行调用
   }
  }
class InnerClassDemo
{
 public static void main(String[] args)
 {
  直接在其他类中，访问一个类的内部类
  new Outer().show();
    
    在其也类中直接访问内部类的方法
  Outer.Inner in=new Outer.new Inner();
}
}

------------------------
内部类也可以定义在外部类中的局部位置上(静态只修饰成员，不能修饰局部)

内部类定义在局部位置上，不允许访问局部中变量。
只能访问被final 修饰的局部常量
class Outer
{
 public void show()// 局部变量也可以使用final修饰
 {
  int x=5; //内部类中不能访问局部变量
  class Inner
  {
   void method()
   {
   }
  }
 
   Inner in=new Inner
    in.method();
 }

}

---------------------
匿名内部类
  凡是匿名都是简写格式

  定义匿名内部类，必须要前提
 ****** 内部类需要继承或者实现一个外部类或者接口
  这时才能简写匿名内部类的形式


  匿名内部类其实就是一个匿名子类对象，这个对象用{}结尾内部定义了成员
  也就是说是一个带有成员内容的对象，这个对象有点胖


  格式： new 父类名或接口名{}。成员();
abstract class Dmeo
{
 abstract void show();
}
class Outer
{
 class Inner extends Demo  //内部类是可以继承或实现类、抽象、接口
{}
//匿名内部类: 就是Demo的一个匿名子类对象
 Demo d= new Demo()
  {
   void show()
   {
   System.out.println("---------------");
   }
  };
  d.show();
}
匿名内部类特有方法可以用in.方法名调用吗？
in.show3(); //不可以，因为这个子类对象 已经提升为Inter接口类型，
只能使用Inter中的方法，不能使用子类的特有方法。
-----------------
什么时候使用匿名内部类？？
当只使用一两个方法时， 就可以使用匿名内部类
匿名内部类使用场景之一：
 当接口类型参数，该接口中方法不超过三个，可以使用匿名内部类作为函数的参数进行传递 
 这亲简化了书写
 但是接口方法较多时，不要使用匿名内部类，影响阅读性


 -------------------
----异常
 不正常
 在运行时期发生的一些不正常情况，就是异常。

 异常的由来：程序运行时总会一些不正常的情况
	java语言对这些不正常情况进行了描述
	并对这些不正常进行了对象的封闭。
	是描述不正常情况的对象
异常情况有多种，都需要分别描述，意味着异常情况应该会有一个体系。
多个异常具备共性不断的向上抽取，就形成体系
就是Exception就是一个父类 
	通过查阅api 发现异常体系是这样的
Throwable：可抛出
    Error:严重的问题，一般都是由JVM从底层抛出来的问题，通常不需要处理，直接修改程序即可
    Exception：是可以定义针对性的处理方式对该种情况进行处理

不正常情况分两种，一种是可以解决的Exception、 一种是严重性的Error
无论是Error还是Exception，它们的子类都一个特点，子类名的后缀都是父类名

这个异常体系最大的特点：就在于该体系中的类和对象都具备可抛性
	可抛性的体现就是无论是类，还是对象都可以被throws或者throw所操作
	throws操作类，throw操作对象
	异常是可以处理的.
	处理方式：
	 1、声明抛出。 告诉调用者功能会有问题。通过throws关键字对问题声明在功能上
	 2、进行捕捉。
	 try
	 {
	   //需要被检测的代码
	 }catch(异常类 变量)
	 {
	 //异常处理代码
	 
	 }
	 finally
	 {
	 //一定会被执行的代码块
	 }


	异常处理的流程 ：jvm默认异常处理方式就是将收到的异常名字，信息，位置，都打印在控制台上，结束程序

throw和throws关键字有什么区别
 throws用在函数上，用于功能声明异常，后面抛出的是异常类可以抛出多个，只要用逗号隔开就可以了
  int div()throws Exception,RuntimeException
  throw只能用在函数内，用于抛出异常对象，额外特点：一旦执行，功能就结束了。
  正常流程代码
  if()
    throw 问题 对象（）;
  if()
     throw 问题 对象（）;

 问题处理代码 和正常流程代码分开

 catch()
 {
 问题处理代码
 }
 catch()
 {
 问题处理代码
 }

-----------------------
自定义异常：
对于常见的不正常情况，java 都有对应的描述，比如角标越界，或者空指针等
对于自定义的程序 中出现的特有问题，java并没有给出对应的描述
这时就需要我们按照面向对象的思想对这个问题进行描述，象异常一样将其封装成对象

定义的方式：
 1、 定义一个类，对问题进行描述 
  2、必须要让这个类继承异常类，具备可抛性

  class FuShuException extends Exception
  {
  }
  这就是自定一个负数的异常


  细节：
   定义 功能，功能内部因为传入的参数问题，导致了功能会出现问题
  这时为了解决这个问题，通常我们都会将问题通过throws声明在函数上
  目的：为了调用者在使用这个功能的时候，能明确处理方式。
  也就是说throws抛出的目的是为了让调用者预先定义好问题的处理方式

  2、如果一个功能抛出多个异常。那么在调用该功能时，需要有多个catch进行每一个异常针对性处理
  如果多个catch中有父类异常，一定要定义在最下面，否则编译失败
  3、特殊部分：

  函数内throw抛出异常对象，函数上一定要throws进行声明抛出，或者try catch捕捉，否则，编译失败

  注意：异常分两种
  1、编译时被编译器检测的异常
	通常都需要编写针对性的处理代码进行处理
  2、编译时不被检测的异常，这种异常出现，编译时期是不在检查之列。这种异常称为运行时异常
     也就是说函数内throw抛出运行时异常，不需要在函数上声明，即使声明了，
     调用者也不用一定给出预先处理方式，因为它不会导致编译失败
     通常，不编写针对性的代码进行处理，一旦发生，就让程序停掉
     为了对代码进行修正。

  运行时异常和编译时异常区分方式：
  Exception中一个特殊的子类，RuntimeException就是运行时异常
  RuntimeException和其子类都不需要编译时检测
  意味着： 我们在自定义异常时，可以继承Exception，称为编译时被检测的异常
   也可以继承RuntimeException称为运行时异常
	

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