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

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称为运行时异常