java基础04

java基础04

继承

方法重写（需要有继承关系，子类重写父类的方法）ALT+Insert；override

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大
4. 抛出的异常：范围可以被缩小但不能扩大

为什么需要重写：

父类的关系，子类不一定需要，或者不一定满足！

多态

理解

1. 动态编译：增强程序的可拓展性

2. 同一方法可以根据发送对象的不同而采用多种不同的行为方式

3. 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

   1. 把子类转化为父类，向上转型：可以用父类类型的引用来指向子类对象类型，子类转父类，低转高（可能存在方法的丢失，）

   2. 把父类转化为子类，向下转型：子类类型引用指向父类类型时需要强制转换

   3. 对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大

      Father f=new son();
              Father f2=new Father();
              son s=new son();
              Object o=new son();
              f.run();//申请空间时对run方法重写此时虽然f调用的是子类的重写方法，但是还是不能执行go方法
              f2.run();
              s.go();
      public class son extends Father{
          public void go()
          {
              System.out.println("son go");
          }
          @Override
          public void run()
          {
              System.out.println("son run");
          }
      }
      public class Father {
          public void run()
          {
              System.out.println("Father");
          }
      }
      

注意事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类
3. 存在条件：继承关系，方法需要重写（static和final和private不能重写也没有多态），父类引用指向子类对象！

Static（静态跟类一块加载，只执行一次）

• 静态变量可以直接用类名.调用（多线程！）
• 静态方法也可以直接用类名调用，甚至不需要类名
• 匿名代码块（可以赋初始值）和静态代码块
• 静态导入包

import static java.lang.Math.random;
public static void main(String[] args) {
        System.out.println(random());
        System.out.println(random());
    }

抽象类

• 抽象类的子类都必须重写抽象类的方法

• 局限性，单继承

• 抽象类不能实例化（new）

• 抽象类中可以有普通方法，抽象方法必须在抽象类中

  思考题

  1. 抽象类存在构造器吗？
  2. 抽象类存在的意义

接口（interface，implements）

• 只有规范，无法写方法~专业的约束！约束和实现分离
• 接口的本质是契约，oo的精髓是对对象的抽象
• 接口都需要有实现类，类需要重写所有方法
• 接口中所有定义其实都是抽象的 public abstract
• 多继承
• 作用
  1. 约束
  2. 定义一些方法，让不同的人实现
  3. 接口不能被实例化，接口中没有构造方法

N种内部类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

异常

抛出捕获异常（try,catch,finally,throw,throws）

快捷键 Ctrl+Alt+T

		int a=10;
        int b=0;
        try {
            System.out.println(a/b);
        }catch (Exception e){
            System.out.println("异常");
        }catch (){

        } catch (){

        }//捕获多个异常时要从小到大捕获
        finally {
        }
    }

自定义异常

 public static void main(String[] args) {
        try{
            test(11);
        }catch (MyException e){
            System.out.println("MyException=>"+e);
        }

    }

    static void test(int a)throws MyException{
        System.out.println("传递的参数为"+a);
        if(a>10){
            throw new MyException(a);
        }
    }
public class MyException extends Exception{
    private int detail;
    public MyException(int a) {
        this.detail=a;
    }

    @Override
    public String toString() {
        return "MyException{" +
                detail +
                '}';
    }
}

经验总结

1. 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
2. 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常
4. 尽量去处理异常，切记只是简单地调用printStackTrace（）去打印输出
5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定
6. 尽量添加finally语句块去释放占用的资源