类和异常

包+访问修饰符：

      包名：

             1.www.baidu.com

                com.baidu.xxx.xx

              -域名倒置

              -详细功能划分

目的：针对资源作详细的划分。

访问修饰符：	本类	同包	子类	其他（不同包，非子类）
public（公共的）	yes	yes	yes	yes
protected（受保护的）	yes	yes	yes	no
默认	yes	yes	no	no
private（私有的）	yes	no	no	no

重写+重载问题：

      重写：当子类继承的父类方法无法满足子类需求，重写覆盖父类的方法。

      重写：方法名，参数名，返回值与父类一致。子类访问修饰符不能严于父类。继承时重写。

      重载：方法名相同。参数列表不同。与返回值无关。与访问修饰符无关。同类中重载。

抽象类+final关键字：

 抽象方法：即没有方法体的方法。

抽象方法的定义：【访问修饰符】 abstract 返回值类型 方法名（参数）

-拥有抽象方法的类必须定义为抽象类。

-抽象类不能创建对象。

-父类为抽象类，子类必须重写抽象方法（除非子类为抽象类）。

-抽象类不一定有抽象方法，可以有实例方法，但抽象方法一定在抽象类。

抽象类的定义：【访问修饰符】 abstract class 类名{

//成员变量

//成员方法

}

目的：方法的实现没有任何价值。于是不实现方法体。构成抽象方法。

final修饰符

1.修饰方法

【访问修饰符】 final 返回值 方法名（）......

-final表示此方法不能被覆盖。

2.修饰变量

【访问修饰符】 final static  数据类型 变量名=值；

-final修饰的变量不能被修改，表示常量。

-常量必须初始化，并且用static修饰。

注意：常量名称所有字母一般大写。

3.修饰类

【访问修饰符】 final class 类名{......}

-final修饰的类不能被继承。

多态

什么是多态：

同一个引用类型使用不同实例而执行的不同操作。

为什么要使用多态：

多态解决了程序的拓展性问题。

怎么实现多态：

1.继承，子类重写父类的方法。

2.父类的引用指向子类对象。

-编译时多态：编译阶段，被调用方法的对象属于哪个类则调用哪个类的方法

public void feed(Pet pet)

{pet.pet();}

-运行时多态：根据对象的引用找到堆中的实际类对象，调用该类的对象方法。

Mater mater=new Mater();

Pet dog=new Dog();

Pet cat=new Cat();

mater.eat(dog);

mater.eat(cat);

多态对象转型问题：
  1.子对象转父对象：
Pet dog=new Dog（）；

2.父对象转子对象：classex.....

if（pet instanceof Dog）

{

 Dog   dog = （Dog）pet；

dog.band;

}

接口：

什么是接口：

接口即是一种强制遵守的规范，如果不遵守此规范，则不能使用此接口。

为什么要使用接口：

原因：Java的继承只能实现单继承，如果要同时实现继承父类，然后再继承其他元素基因，此时java的继承无法实现。

解决方法：使用Java的接口，通过接口的多实现，间接实现java的多继承。

怎么实现接口：

1.定义接口

【访问修饰符】 interface 接口名称{   

//成员变量

//成员方法  

}

2.实现接口

public   class  子类 implement  接口{

//重写父接口的方法

}

注意细节：

1.接口的方法必须是public&abstract（默认）的方法。

或者public&static（jdk1.8后）方法

2.接口没有构造方法，所以接口不能实例化。（抽象类有构造方法，因为太抽象不能被实例化）

3.接口的成员变量必须是static&final（默认）的是常量。

4.接口的方法子类必须实现（重写）。

5.接口可以多实现。

类与类的关系

1.is。。。a继承。

Student is a  Person

2.has。。。a 拥有

Student   has    a   Phone

内部类

1.内部类对象的创建：

A.B  a=new A（）.newB（）；

2.静态内部类

A.B  a=new A.B（）；

3.匿名内部类  一次性  作用和存活周期很短，用完即丢。

接口（或抽象类）名称    对象名 =new  接口名（）{

//方法的覆盖

}

*代码块执行问题
  代码块
     执行时机： 对象被创建之前
     作用： 对象创建之前的加载或者初始化工作

   静态代码块：
     执行时机:  类加载时
     作用： 对类在加载时做一些初始化的工作，只执行一次。
       

*异常结构和异常处理
   Throwable
       -异常(Exception)：依靠程序本身可以解决的非严重性问题
            1)运行时异常(RuntimeException)
          InputMismatchException:输入类型不匹配异常
          ArithmeticException：算数异常
          NullPointerException：空指针异常
          ClassCastException：类转换异常
          ArrayIndexOutOfBoundsExceptio：数组索引下标越界
          NumberFormatException: 数字格式化异常
          
        2)检查异常(CheckException)
          ClassNotFoundException ： 类无法加载异常
          IOException: IO流异常(文件的读写)
          FileNotFoundException: 文件无法加载

       -错误(Error)：依靠程序本身可以无法解决的严重性问题

异常处理：

try:捕获异常，

catch：处理对应的异常。

finally：无论是否发生异常都必定会执行。通常再次释放内存的资源。例如IO流对象的释放。

注意：

1.catch可以有多个。

2.当发生对应异常时，jvm创建对应异常对象。

3.catch处理异常的顺序一定要按照从子到父。

4.异常处理语句中有return，先执行finally再执行return。

自定义异常：

1.定义异常类，继承exception类。 

2.抛出异常对象：

throw  new 异常（）

注意：

       方法内部抛出异常，要么try...catch处理，要么使用throws交给其它调用对象处理。

3.定义方法的异常抛出

【访问修饰符】【其它修饰符】 返回值类型  方法名  （参数列表）  throws  异常列表

{

}

4.处理异常

try ......catch.....finally