Day18

重写

1. 父类

package com.oop.demo05;

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}

2. 子类

package com.oop.demo05;

public class A extends B{

  public static void test(){
       System.out.println("A=>test()");
    }
}

3. 父类的引用指向了子类
   • 代码

B b=new A();
b.test();//B

结果

B=>test()

4. 方法的调用只和左边，定义的数据类型有关

• 输出结果

• A=>test()
  B=>test()
  

5. 去掉static

6. override

7. 静态方法和非静态方法

• 静态方法：方法的调用只和左边，定义的数据类型有关
• 非静态方法：重写

重写总结

需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表 列表必须相同
3. 修饰符：范围可以扩大但不能缩小：Public>Protected>Default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException---->Exception(大)

重写，子类的方法和父类必须一致：方法体不同！

为什么需要重写：

1. 父类的功能，子类不一定需要，或者不一定满足
2. alt+Insert；override

多态

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

2. 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类、有关系的类）

3. 多态存在的条件

   • 有继承关系
   • 子类重写父类方法
   • 父类引用指向子类对象

4. 注意：多态是方法的多态，属性没有多态性

5. instanceof，（类型转换） 引用类型

6. 子类没有重写父类的，就调用父类的

7. 子类重写父类的，就调用子类的

8. 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大（左边的类里有方法才能调用）

9. Student能调用的方法都是自己的或者继承父类的！

10. Person父类型，可以指向子类，但是不能调用子类独有的方法

    Student s1=new Student();
    Person s2=new Student();
    Object s3=new Student();
    

多态注意事项

1. 多态是方法的多态，属性没有多态

2. 父类和子类，有联系，类型转换异常！ClassCastException

3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1=new Son（）；

4. static方法，属于类，它不属于实例

5. final常量：

6. private方法：

instanceof

static关键字详解

1. 静态方法可以Student.age

package com.oop.demo07;

//static

public class Student {
    private static int age;//静态的变量 多线程
    private double score;//非静态变量

    public static void main(String[] args){
        Student s1=new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
    }



}

2. 匿名代码块

package com.oop.demo07;

public class Person {

    //2:赋初值~
    {
        System.out.println("匿名代码块");
    }


    //1：只执行一次
    static{
        System.out.println("静态代码块");
    }


    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1=new Person();
        System.out.println("===========");
        Person person2=new Person();

    }
}

3.通过final修饰的类不能被继承

抽象类：提高开发效率（不是重点，了解就好）

1. 抽象类的所有方法，继承了它的子类，都必须要实现它的方法

package com.oop.demo08;

//abstract 抽象类

public abstract class Action {

    //约束~有人帮我们实现
    //abstract，抽象方法，只有方法名字，没有方法的实现

    public abstract void doSomething();
}

2. 不能new这个抽象类，只能靠子类去实现它：约束！
3. 抽象类中可以写普通的方法
4. 抽象方法必须在抽象类中

接口

1. 接口中的所有定义其实都是抽象的 public

2. 类 可以实现接口 implements 接口

3. 实现了接口的类，就需要重写接口中的方法

package com.oop.demo09;

//抽象的思维~java
//interface 定义的关键字，接口都需要有实现类

public interface UserService {

    //常量~public static final
    int AGE=99;

    //接口中的所有定义其实都是抽象的public abstract



    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);


}

package com.oop.demo09;

public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

总结

1. 约束
2. 定义一些方法，让不同的人实现~ 10---->1
3. public abstract
4. public static final
5. 接口不能被实例化！接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

异常

捕获和抛出异常

1. 抛出异常
2. 捕获异常

异常处理五个为关键字

• try
• catch
• finally
• throw
• throws

package com.exception;

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;


        //假设要捕获多个异常：从小到大
        try{//try监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){//catch(想要捕获的异常类型) 捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally{//处理善后工作
            System.out.println(("finally"));

        }
    }
}

快捷键，捕获异常（ctrl+alt+t）

package com.exception;

public class Demo01 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}