多态时 成员的特点:
1.成员变量
编译时:参考引用型变量所属的类型中是否有调用的成员变量 有编译成功 否则失败
运行时:参考引用型变量所属的类型中是否有调用的成员变量，并运行该所属类中的成员变量
简单来说就是编译和运行都参考=左边
class A{int num = 1;}
class B extends A{int num = 2;}
class C{
public static void main(String[] arr){
A a = new B();
print(a.num);---->1//等号左边是A 故为1
B b = new B();
print(b.num);---->2//等号左边是B 故为2
}
}
2.成员函数
编译时，参考引用型变量所属的类型中是否有调用的成员变量 --->有则编译通过 否则失败
运行时，参考的是对象所属的类中是否有调用的函数
简单说 编译看左边 运行看右边
3.静态函数
编译时:参考引用型变量所属的类型中是否有调用的静态方法
运行时:参考引用型变量所属的类型中是否有调用的静态方法
简单说 编译和运行都看左边
其实对于静态方法，是不需要对象的，直接用类名调用即可。
内部类:将一个类定义在另一个类里面 对里面的类就成为内部类 外部的则为外部类
访问特定:
1.内部类可以直接访问外部类中的成员
2.外部类要访问内部类，必须建立内部类的对象
一般用于类的设计
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，此时就是还有的事物定义成内部类来描述
直接访问外部类中的内部类中的成员
Outer.Inner in = new Outer().new Inner();
如果内部类是静态的 就相当于外部类
Outer.Inner in = new Outer.Inner();
如果内部类是静态的，成员是静态的。
Outer.Inner.function();
如果内部类中定义了静态成员，该内部类也必须是静态的
为什么内部类能直接访问外部类的成员呢？
因为内部类持有了外部类的引用 外部类名.this
内部类可以存储在局部位置上。
内部类在局部位置上只能访问局部中被final修饰的局部变量
class Outer{
int num = 1;
void method(){
class Inner{
syso(+num);
}
}
}
匿名内部类:就是内部类的简写格式
前提:
内部类必须继承或者实现一个外部类或者接口
其实匿名内部类就是一个匿名子类对象。
格式:
new 父类or接口名(){子类内容}
abstract class Demo
{
abstract void show();
}
class Outer
{
int num = 1;
/*
class Inner extends Demo
{
void show()
{
syso
}
}
*/
public void method()
{
new Demo()
{
void show()
{
syso
}
}
}.show;
}
Object:所有类的根类。
object类是不断抽取而来,
equars(object obj)//比较的是在内存的地址
class Person extends Object
{
private int age;
Person(int age)
{
this.age = age;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
{
throw new ClassCastException("Class Cast Error");
}
Person p = (Person)obj;
return this.age == p.age;
}
}
class Animal{}
public class Equal {
public static void main(String[] args) {
Person p1 = new Person(20);
Person p2 = new Person(20);
Animal a = new Animal();
//Person p3 = p1;
System.out.println(p1==p2);
System.out.println(p1.equals(a));
}
Object.hashcode();
异常:是在运行时期发生的不正常情况。
在Java中用类的形式对不正常情况进行了描述和封装对象
描述不正常的情况的类就称为异常类
以前正常流程代码和问题处理相结合，
现在将正常流程代码和问题处理代码分离，提高阅读性。
其实异常就是Java通过面向对象的思想将问题封装成了对象，用异常类对其描述
问题不同，类不同，进行描述 问题多 类就多 共性抽取--->形成了异常体系
异常两大类:
Throwable:无论是Error还是异常，就应该可以抛出，让调用者处理
可抛性是通过两个关键字体现的
throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性
1.一般不可处理:Error
特点:室友Jvm抛出的严重性问题
这种问题一般不针对性处理 直接修改程序
2.可处理的:Exception
该体系的特点:
子类的后缀名都是用其父类作为后缀名，阅读性很好
如果自定义异常类要继承Exception
class FuShuIndexException extends Exception
异常的分类:
1.编译时被检测异常: 只要是Exception和其子类(除了RuntimeException体系)
//这种问题在编译时就进行检测，让问题可处理
2.编译时不检测异常(运行时异常)RuntimeException及其子类
//这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的，或者引发了内部状态的改变导致的，这种问题一般不处理，通过编译，在运行时，让调用者调用的程序强制停止
自定义异常时，要么定义成Exception，要么定义成RuntimeException
throws和throw的区别
1.throws使用在函数上
throw使用在函数内
2.throws抛出的是异常类，可以抛出多个，用逗号隔开
throw抛出的是异常对象
异常处理的捕捉形式:
这是可以对异常进行针对性处理的方式
格式
try
{
//需要被检测异常的代码
}
catch(异常类 变量)
{
//处理异常的代码
//变量是用于接收发生的异常对象
}
finally
{
//一定会被执行的代码
}
异常处理的原则:
1.函数内部如果抛出需要检测的异常，函数上必须要声明
否则必须在函数内部用trycatch捕捉，否则编译失败
2.如果调用了声明异常的函数，要么trycatch要么throw 否则编译失败
3.功能内部可以解决用catch 解决不了用throw
4.一个功能如果抛出了多个异常，那么调用时必须对应多个CATCH进行针对性处理
内部有几个需要检测到异常就抛几个异常，抛出几个就要catch几个
finally：//通常用于关闭(释放)资源。
try catch finally代码块组合特点
1.
2.try catch()当没有必要资源需要释放时，可以不用定义finally
3.try finally异常无法直接catch处理，但是资源需要关闭
void show()
{
try{
throw new Exception();
}
finally
{}
}
异常的注意事项:
1.子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类
class A extends Exception{}
class B extends A{}
class C extends Exception{}
Exception
--A
--B
--c
class Fu{
void show()throws A
{}
}
class Zi extends Fu
{
void show()throws C
{}
}
class Test{
void method(Fu f){
try(){
f.show();
}catch(A a)
{}
}
}
2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说:子类覆盖父类只能抛出父类的异常或是子类或是子集
如果父类的方法没有抛出异常，那么子类覆盖时不能抛异常，就只能try
