抽象方法及类，接口，多态，异常已经自定义异常

包+访问修饰符

• 包名：
•   例如：com.baidu.util
• com.fs.dao
• 域名倒置和详细的功能划分
• 目的：针对资源做详细划分

访问修饰符

访问修饰符	本类	同包	子类	其他（不同包 不继承）
public	yes	yes	yes	yes
protected	yes	yes	yes	no
默认	yes	yes	no	no
private	yes	no	no	no

重写与重载

• 重写  当父类方法无法满足子类要求时，重写覆盖父类的方法

重写

1. 与父类的方法名相同
2. 参数与父类一致
3. 返回值与父类一致
4. 子类的修饰符不可严于父类修饰符
5. 继承时重写

重载

1. 方法名相同
2. 参数不同
3. 返回值无关
4. 与访问修饰符无关
5. 同类中重载

抽象与Final

抽象方法：方法没有会被覆盖 因此方法没有价值 干脆不实现方法体 于是构成抽象方法

[访问修饰符] abstract 返回值类型 方法名 （参数）{

        }

1. 抽象方法没有方法主体
2. 抽象类不可以创建对象
3. 抽象方法的类必须定义为抽象
4. 父类的抽象方法 子类必须要重写 ，若子类不重写 则该类也将变为抽象类

抽象类

[访问修饰符] abstract class 类名{

成员变量

成员方法

        }

1. 抽象类中可以有实例方法 不一定有抽象方法
2. 有抽象方法的类必须定义为抽象类
3. 抽象类不可以创建对象

final修饰符

1. 修饰方法： [访问修饰符] final 返回值 方法名()

• final 修饰符方法表示此方法不可被覆盖
• 例图如下

1. 修饰变量

• 访问修饰符 final 数据类型 变量名 =值
• final修饰一个变量则该变量为一个常量
• 常量必须初始化 且用static (常量通常大写)

多态

• 什么 是多态

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

• 为什么要使用多态

解决了程序的拓展性问题

• 如何实现多态

子类重写父类方法

父类引用子类对象

例如：

package Work;

public abstract class Pet {
    public abstract void eat();
}
//定义宠物抽象类

package Work;

public class Cat extends Pet {
    public int health=20;
    @Override
    public void eat() {
        health+=5;
        System.out.println("健康值为"+this.health);
    }
}
//定义猫类继承宠物类 并且重写eat()方法

package Work;

public class Master {
    public void feed(Pet pet){
        pet.eat();
    }
}
//定义主人类且定义饲养方法
package Work;

public class Text {
    public static void main(String[] args) {
        Master master=new Master();//实例化主人
        Pet cat=new Cat();//实例化猫
        master.feed(cat);
    }
}
//main函数调用 

多态对象转换问题

1. 子对象转为父对象 Pet dog=new Dog(）
2. 父对象转为子对象[ClassCastException]

• Pet pet
  if(pet instanceof Dog)//判断pet是不是Dog类型
  {
  
  Dog dogs=(Dog)pet
  dog.bark()//叫方法
          }

  接口

• 什么是接口

接口即是一种强制遵守的约束（规范），若不遵守此规范 则无法使用此接口

• 为什么要使用接口

Java 的继承只能实现单继承 如果要实现继承父类 然后再继承其他元素基因 此时意味着Java的继承是无法实现的。此时依靠Java的接口 通过接口的多实现间接实现Java的多继承

• 怎么实现和使用接口

定义接口
 [访问修饰符] interface 接口名称{
        //成员方法
        //成员变量
    }


接口使用

public class 子类名 implements 接口{

                    //重写接口方法
        }

注意事项

• 接口方法必须是abstract和public方法或者public&static（jdk1.8之后）
• 接口没有构造方法 没有实例化
• 接口的成员变量必须是公共的 和 静态的 常量 public static final
• 接口的方法子类必须重写
• 接口可以多实现 public class 子类名 implements 接口1，接口2，接口3....

类与类的关系

1. 继承 extends
2. 拥有 has...

内部类

A.B xxx=new A().new B();

静态内部类

A.B xxx=new A.B()

匿名类

代码块

• 执行时机：创建对象之前被调用
• 作用：创建对象之前的加载或者初始化工作

静态代码块

• 执行时机：类加载时
• 作用：对类在加载时初始化的工作 只执行一次

异常结构和异常处理

• 异常：依靠程序本身可以解决的非严重问题
• 运行时异常runtimeException

1. 输入类型不匹配异常
2. 算数异常
3. 空指针异常
4. 类转换异常
5. 数组索引下标越界
6. 数字格式化异常

• 检查异常CheckException（在编译阶段就要处理的异常）

1. 类无法加载异常
2. IO流异常
3. 文件无法加载

• 错误：依靠程序本身无法解决的严重性问题

异常处理

1. try捕获异常
2. catch 处理相对应的异常
3. finally 无论发生什么异常 都必定会执行 通常再释放一些内存资源

catch细节：

1. catch可以有多个
2. 当发生对应类型异常时 jvm会创建对应类型的异常对象
3. 处理异常先写子异常 再写父异常
4. 异常处理程序中有return和finally时 先执行finally释放资源 再执行return

自定义异常

1. 自定义异常类 继承Exception
2. 抛出异常对象

• throw new 异常()
• 方法内部抛出异常，要么try...catch处理，要么使用throws将异常抛出继续抛出给其他调用方法者处理
• 定义异常方法

  [访问修饰符] [其他修饰符] 返回值类型 方法名（参数列表） throws 异常列表
  
  try...cacth..finally处理

  例如

  //自定义性别异常类
  public class AgeException extends RuntimeException {
      private String msg;
      public String getMsg() {
          return msg;
      }
      public void setMsg(String msg) {
          this.msg =msg;
      }
  
      AgeException(String msg){
          this.msg=msg;
      }
      AgeException(){
          this.msg="年龄异常";
      }public class AgeException extends RuntimeException {
      private String msg;
      public String getMsg() {
          return msg;
      }
      public void setMsg(String msg) {
          this.msg =msg;
      }
  
      AgeException(String msg){
          this.msg=msg;
      }
      AgeException(){
          this.msg="年龄异常";
      }
  //在学生的setsex方法里面去抛出异常
  public class Student{
      private int age;
      private char sex;
  
      public char getSex() {
          return sex;
      }
  
      public void setSex(char sex) throws SexException {
  
          if (sex=='男'||sex=='女'){
  
          }else {
              throw new SexException();
          }
          this.sex=sex;
      }
  }
  //在main函数中去捕获异常
  public class Test{
      public static void main(String[] args) {
          Student student=new Student();
          try{
              student.setSex('狗');
          }catch (SexException e){
              System.out.println(e.getMsg());
          }
          System.out.println(student.getSex());
  
      }
  }