java基础学习笔记

面向对象的三大特征：
1. 封装
2. 继承。
3. 多态


多态：一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)


或者是接口 的引用类型变量指向了接口实现类的对象)


多态的前提：必须存在继承或者实现 关系。


    动物  a  = new   狗();


多态要注意 的细节：
1.  多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
2.  多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3.  多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。


4.  多态情况下，不能访问子类特有的成员。


总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。


编译看左边，运行不一定看右边。


编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。






多态的应用：
  1. 多态用于形参类型的时候，可以接收更多类型的数据 。
  2. 多态用于返回值类型的时候，可以返回更多类型的数据。






多态的好处： 提高了代码的拓展性。


抽象类：


什么是时候使用抽象类：
描述一类事物的时候，发现该事物确实存在着某种 行为，但是 目前这种 
是不具体的，这时候应该抽取这种行为的声明，而不去实现该种行为，这时候
这种行为我们把它称为抽象的行为，这时候应该使用抽象类。


抽象类要注意的细节：
1. 如果一个方法没有方法体，那么该方法必须使用abstract修饰。
2. 如果一个类函数抽象方法，那么这个类肯定是一个抽象类或者接口。
3. 抽象类不能创建对象。
4. 抽象类是含有构造方法的。
5. 抽象类可以存在非抽象方法与抽象方法。
6. 抽象类可以不存在抽象方法。
7. 非抽象类继承抽象类的时候，必须要把抽象类中所有抽象方法全部实现。


abstract不能与以下关键字一起使用
1.abstract 不能与static共同修饰一个方法。
2. abstract 不能与private共同修饰一个方法。
3. abstract不能以final关键字共同修饰一个方法。




接口：


接口的定义格式：

interface 接口名{
成员变量


成员函数..
}


接口的作用：
1. 程序解耦。
2. 定义约束规范
3. 拓展功能。


接口要注意的细节：
1. 接口中成员变量都是常量，默认 的修饰符是 public static fianl.
2. 接口中的方法全部都是抽象的方法，默认的修饰符： public abstract。
3. 接口不能创建对象。
4. 接口是没有构造函数 的。
5. 非抽象类通过implements实现接口的时候，必须要把接口中所有方法全部实现。 




接口与类之间 的关系： 实现关系。


注意： 一个类可以实现多个接口。


接口与接口之间的关系： 继续关系。


注意： 一个接口是可以继承多个接口的。




多态：父类的引用类型变量指向了子类的对象，或者是接口的引用类型变量指向了接口实现类的对象。




多态要注意细节：
1. 多态情况下，如果子父类存在同名的成员变量时，访问的是父类的成员变量.
2. 多态情况下，如果子父类存在同名的非静态函数时，访问的是子类 的成员函数。
3. 多态情况下，如果子父类存在同名的静态函数时，访问的是父类的成员函数。
4. 多态情况下， 不能访问子类特有的成员。


多态的应用： 
1.多态用于形参类型的时候，可以接收更多类型的数据
2. 多态用于返回值类型的时候，可以返回更多类型的数据








                                              throwable 




                          error （错误）              exception(异常)




                                                         编译时异常       运行时异常   












/*
内部类


内部类类别：


成员内部类: 在一个类的成员位置定义另外一个类，那么另外 一个 类就称作为成员内部类。


成员内部类的访问方式：
方式1： 在外部类内提供一个方法创建内部类的对象进行访问。


方式2： 在其他类创建内部类的对象进行访问。 创建的格式： 外部类.内部类  变量名 = new 外部类().new 内部类();


注意：如果是静态内部类在其他类的创建对象方式：  外部类.内部类 变量名=  new 外部类.内部类();


成员内部类要注意的事项：
1. 成员内部类可以直接访问外部类成员。
2. 如果成员内部类与外部类存在同名的成员，在内部类中默认是访问内部类 的成员。
成员通过“外部类.this.成员”指定访问外部类的成员。
3. 如果成员内部类出现了静态的成员，那么该成员内部类也必须使用static修饰。
4. 如果成员内部类是私有的，那么创建内部类的对象就只能在外部类提供方法创建。


局部内部类  ： 在一个类的方法内部定义另外一个类,  另外一个类就称作为局部内部类。


局部内部类要注意： 如果局部内部类访问了局部变量，那么该变量需要使用fianl修饰。 （原因： 因为生命周期不一致，所以内部类访问局部变量其实是一个复制品。）




匿名内部类 : 没有类名的类。


匿名内部类的好处： 简化书写。


匿名内部类的使用前提： 必须存在继承或者实现关系。


匿名内部类的格式：


new 父类(父接口){

匿名内部类的成员;


};




异常：


异常的体系：
---------|Throwable 
--------------|  Error （错误）  错误一般是由于jvm或者是硬件引发的问题，所以我们一般都不会通过代码去处理。
--------------| Exception (异常) 异常我们一般都会通过代码去处理的。




异常的处理方式



方式一：捕获处理

捕获处理的格式

try{

可能发生异常的代码


}catch(捕获的异常类型  变量名){
处理异常的代码
}

捕获处理要注意的细节：
1. 如果一个try块中出现了异常的代码，经过处理之后，那么try-catch块外面的代码可以正常执行。
2. 如果一个try块中出现了异常的代码，那么在try块中出现异常的代码后面 的语句无法执行。
3. 一个try块后面可以跟多个catch块，也就是一个try块可以捕获多种异常的类型，但是捕获的
异常类型必须从小到大进行捕获。


方式二：抛出处理(throw throws)




抛出处理要注意的细节：
1. 如果一个方法内部抛出了一个编译时异常对象，那么该方法必须要声明抛出。
2. 如果调用了一个声明抛出编译时异常的方法，那么调用者必须要处理。
3. 如果一个方法抛出了一个异常对象，那么该方法也会马上停止（一个方法遇到了throw关键字，那么该方法就会马上停止）
4. 在一种情况下只能抛出一种异常对象。

throw 关键字是用于方法体之内抛出异常对象 的，throws是用于方法 声明上声明抛出异常类型的。